Auteur Build
This is not vibe coding. This is deep coding, with intent and guardrails. Build is for the long-form coding project you would not trust to a single chat window: a game, a platform, a product, a codebase with months of history. You describe what you want built, and Build runs it as a campaign: not one model guessing, but a governed team of models from whichever providers you choose, working in an organized, constructed order, each step checked by a model from a different company, inside proprietary guardrails that keep every worker in its lane. The campaign remembers what it is supposed to do, tracks every step, keeps a receipt for every attempt, and stops at the first failed test instead of a week later. Bring the models and subscriptions you already pay for, add open-source models on your own hardware, and the result is complex code you can actually verify, at a fraction of what a frontier-only pipeline would burn.
No hype and no black box: just a durable record of exactly what ran, what changed, what it cost, and what passed, every time.
Two words you will meet on this page. A campaign is one build, run the studio way: you state the objective, the work is split into rounds, each round is built by AI workers in their own private copies of your project, checked by an AI from a different company, proven by tests, and held for your approval before it is merged. Every attempt, including the failed ones, leaves a receipt. A seat is any AI you bring to that table: a subscription you already pay for, a pay-as-you-go model through a gateway, or a model running on your own hardware. That is the whole vocabulary.
An actual build lifecycle
brief→scope→campaign plan→private, sandboxed workspaces→parallel build→a review by a different company's AI→tests must pass→your approval→merged into your project→receipts
One project identity travels the whole chain, a system that wraps around your engineering process, not another coding assistant: a build intelligence and cost-prediction layer.
Bring the coding harness you already use, Claude Code, Codex, Cursor, or Grok. Auteur gives it a durable campaign, real repository tools, and a receipt for every step, so the build stays tracked and repeatable work can run under configured gates and review policies.
And it is never just one model. Whatever leading models you bring, Auteur’s guardrail engineering runs them as a governed team. Models from different providers build in private, sandboxed workspaces and adversarially review each other, so one catches the bug or the dead end another would have shipped, and problems surface early, while they are still cheap, not after a week of tokens on something that does not work. Your intent drives the merge, not any single model’s guess. Coding comes out more correct, better reviewed, and cheaper than one model working alone.
This site was built exactly this way: 88 tracked build jobs, 16 bad attempts caught and fixed before they reached the site, none shipped, all for 39 cents (we had set a 25 dollar limit and never came close).
Built together, not one by one
The power of Auteur Intelligence™ in a build is not a queue of models taking turns. It is different models from different providers working the same problem at the same time, collaboratively, checking each other's work as they go, inside software-engineered scaffolding that keeps every model in its lane and doing the job you want done. That is what dramatically reduces hallucinations, bugs, and dead ends, and it is what prevents the costly failed build: issues get identified early, while they are still cheap, not after you have spent a week's worth of tokens on something that does not work.
Use Build with or without an existing harness, and you keep peace of mind either way. The build has receipts. The costs are estimated up front, and you carry a live read on how long the work should take at every point. Look into the build at any time and see what was intended and what the result was, then adjust model selections, provider selections, and code content while the build is going on, not after. Our proprietary scaffolding designs the campaign with you and helps you pick the best models at your disposal before anything runs, so your job is tailored, not random.
"Design tonight's build with me: pick the seats from what I hold, estimate cost and time, and flag anything risky before you start. If a seat drifts mid-run, I want to swap its model without stopping the campaign."
Who it's for
Professional developers and technical teams running complex engineering work with agents, who need the result to be provable rather than merely reported.
“Build this mobile game using only local models. Have the Bloom judges review every phase before it advances, then bring in a frontier seat for the final audit.”
Not just for studios
Build is a general instrument for anyone shipping something complex: a Fortune 500 team taming a sprawling internal workflow, an animator wiring a pipeline, or a coder building the next Minecraft-scale idea. If the work is big enough to lose track of, Build is the control layer, no film required.
Built on our own engine
Build does not ride on any harness vendor's framework, the campaign system, eval, memory, and receipts are proprietary, ground-up engineering. The harnesses you bring are seats at the table; the table is ours.
“Spin up a campaign to refactor the exporter: local models draft, a frontier seat reviews, and stop everything the moment the test suite goes red.”
Security for the agent era
Multi-agent builds create risks your traditional tools were never designed to meet: agents that reach out onto the internet and bring things back, prompts that arrive poisoned, secrets that drift into repositories. Build treats this as an engineering problem, inbound content is screened for malicious prompt injections, and a nightly integrity sweep scans the repository for leaked secrets. Coverage is measured, not guaranteed, which is why the receipts matter.
We do not replace your virus protection; we anticipate the new-world challenges it may not see coming when complex multi-agent work is spilling out onto the internet and bringing material home.
Fast is for demos. Checked is for shipping.
A single harness sprinting alone is fine for a prototype. A build that has to survive, a game, a platform, a codebase with months of history, needs review by AI from more than one company, where no seat verifies its own work and the reviewer answers to a different lab, because siblings from one provider miss the same things, gates that stop a round at the first failed test, and a scaffold that remembers why every decision was made. The receipts from this studio's own construction: 16 seat failures caught before it reached the site on the site build alone, zero shipped; 10.64 billion tokens across 1,460 tracked jobs for 37 dollars and 44 cents total. Discipline is the feature. The speed comes back at delivery time, when nothing has to be rebuilt.
When the machine goes down
The honest benefit is not that a crash can never interrupt an agent. It is that a crash becomes a recoverable, auditable interruption instead of a manual reconstruction exercise or a lost chain of reasoning.
On 1 September 2026 the workstation running one of our own campaigns crashed in the middle of a cross-model review. Within about a minute of the machine coming back, the controller recorded the lost review as a named event, checked both child branches for drift, and re-queued the round's integration from the state it had already saved. Three minutes later the integration was green and the campaign was waiting at its human gate, where the only human action was to authorize a fresh review. Every step of that recovery is a row in the campaign's audit trail, readable after the fact.
A chat window that dies mid-task keeps none of this. The plan, the partial work, and the reasoning that produced it are gone with the session, and someone has to rebuild them from memory. Here they were never only in a session to begin with. How trust works here.
Draft local, finish frontier
Eval and the judge functions make a two-tier strategy safe: local models take the first draft for near-zero token cost, a frontier model takes the second pass, and cross-model judging decides what survives, so the cheap draft is never trusted blindly. The receipts from this site's own build: 88 governed jobs for 39 cents of metered spend, with 16 failed attempts caught before anything shipped.
The campaign builder
This is the most adaptable machine in the stack, and it stands alone: builds you can watch, stop, resume, and come back to days later; every attempt eval-scored and receipted; every round reviewable long after the session that made it. The in-house campaign author drafts the campaign itself, and an overnight currency sweep surveys OpenRouter, Hugging Face, and the trade news for the newest relevant models, so your builds stay current while you sleep. The same overnight currency feeds the writing and visual lanes with what is newest there, too.
What it solves
An agent will tell you it finished. Build derives what actually happened, independently of the agent's own claim, and stops runaway branches and repeated dead ends before they burn the rest of the budget.
How it works
You describe an objective, and Build runs it as a durable, multi-round campaign rather than a single throwaway session, the plan, the ownership, the budget, and the recovery all persist. Whatever the AI workers report, Build derives what actually happened, ancestry, commits, changed paths, diff validity, and tests, from the record itself, so the result is verified independently of any agent's own claim.
Workspaces included
- Campaign Builder, turns an objective into a governed multi-agent campaign with acceptance gates, recovery, and proof.
- Many workers, one set of rules, Codex, Claude Code, OpenRouter, direct APIs, and local models under one campaign plan and one standard of proof.
- Private workspaces, each worker gets its own copy of the project, is limited to the files it owns, and its changes are observed independently.
- Receipts, a record of what changed and what passed for every attempt, verified independently of what the worker itself reports.
- Failure and cost control, hard limits on attempts, tokens, time, and spending; repeated dead ends are recognized and stopped, and recovery stays within bounds.
Inside the other products
Build does not fold another paid product inside it. Build's campaign runtime is what powers the complex work inside the other products, but as a standalone product it stands on its own.
Moving up
Conductor lets you drive campaigns from the AI harness you already use, and Studio carries Build alongside the creative shelf.
Where it runs
It runs the models and subscriptions you already hold rather than requiring new ones, on your own machine or in the cloud, depending on the posture you choose.
Shown working
By 2026-08-28, campaigns with workers from several providers, private, sandboxed workspaces, independent receipt verification, and spending limits had run with an extensive history of real campaign receipts behind them.
Current limitations
Build verifies what actually changed rather than trusting a worker's report, and it runs the models you already hold rather than reselling capacity; it is not a model provider of its own.
Related products
Conductor · Learning · Story · Prep · Film · Game · Studio
Questions
Which AI workers can it run? Codex, Claude Code, OpenRouter, direct APIs, and local models, under one campaign plan, and never swapped for a different provider without telling you.
Does it just trust the agent's word? No. Build reads the record itself: which commit came from which, which files changed, whether the change is sound, and whether the tests passed.
Do I need more than one model family? No, one is enough to run a campaign. We recommend several: models from different companies, open source, local, any mix you can hold. Siblings from one provider share the same blind spots, and a reviewer from a different provider does not, so variety is what makes the cross-checking bite. More on the requirements page.
Can a campaign run away with my budget? No. Limits on attempts, tokens, time, and spending are hard limits, and a worker that keeps hitting the same wall is stopped rather than left to try again.
Take the next step
Apply for the Founding Beta, /founding-beta/. An application to work alongside us; this starts a conversation with us, and seats, when offered, are paid.
Proof
Every claim on this page traces to the product status registry, with evidence in code, campaign evidence, and product documents, last verified 2026-08-28. The receipts behind it are claims BUILD-001–005, PLAT-003.