A workshop of intelligences, guided by the master.
The master's quality.
The workshop's price.
Atelier is a new AI architecture for writing code. It delivers the quality of Fable — the frontier AI model that leads at coding — at a fraction of the price, by letting fast, inexpensive AI models do the work and calling in Fable only when your tests prove it's needed.
That is the metaphor on this page: cheap AI models are the apprentices, painting most of the canvas; Fable is the master, whose hand touches only where the canaries — your code's own tests — sing that something is off.
Every word on this page is a real thing — here's the cast
The metaphor — and why it's literal
How a master painted a masterpiece without painting every inch
In Rembrandt's atelier, apprentices prepared the canvas and painted the drapery, the hands, the background. The master saved his own brush for the gaze, the light — what only he could do. And there was always a signal to tell him where the work wasn't yet worthy. Atelier does exactly this, with AI models.
They do most of the work — and do it well. For a fraction of the cost, they cover the canvas. Well-directed, they resolve the overwhelming majority of tasks entirely on their own.
Summoned sparingly — Fable is called in only for the strokes the workshop can't close. It's costly because it's exceptional, so Atelier reserves it for where it truly makes the difference, and nowhere else.
Birds that sing at the first sign of danger. Here, they are the repository's own objective tests: when they fail, we know exactly where the work isn't ready — and only then is the master called. No guessing, no "looks right."
Plainly: most coding assistants either always use the expensive model — so you pay top dollar for everything — or use a cheap one and hope for the best. Atelier makes the cheap one do the work, and calls the expensive one only when a test proves it was needed. You get the master's work at the workshop's price.
The method
Two crafts, one result
What makes the atelier work isn't a routing trick — it's teaching the apprentices the craft, and having an honest signal for when to call the master.
The apprentice paints
A fast model reads the code, locates the spot, edits, and runs the tests — the full craft, not a one-shot guess.
The tests sing
Green? The work is done, delivered by the workshop. Failing? The canary points to the flaw — an objective signal, not an opinion.
The right hand steps in
Only when the canary sings does the frontier model take over that task and bring it home — verified again by the tests.
Pillar 1 · the craftA bench that teaches the apprentice
Atelier doesn't toss a raw prompt at a model. It hands over a bench of tools — search, read passages, edit with precision, run the tests, iterate. It's the same technique that makes a modest model deliver like a great one. An apprentice with the right tools paints like a pro.
Pillar 2 · the signalEscalation guided by truth, not by guesswork
Other routers guess at difficulty and sometimes send a task to the wrong model — because cheap models are confidently wrong. Atelier doesn't guess: it escalates if and only if an objective test proves the draft failed. Falsifiable, auditable, honest.
What no one else does
The gate guesses. The canary knows.
Every other way to "use a cheaper model" shares one flaw: it guesses. A mixture-of-experts gate, a difficulty classifier, a routing heuristic — each one picks which model to trust before a single line is written. And a cheap model's most dangerous trait is that it is confidently wrong: the guess looks safe, and ships the bug.
A gate predicts which model to trust.
- The prediction is invisible, learned, and unfalsifiable.
- A Mixture-of-Experts mixes models inside a guess.
- When the guess is wrong, you find out in production.
Your tests decide — after the work, on proof.
- The apprentice paints first; the canary renders the verdict.
- The master is summoned only when a real test fails.
- Every escalation carries a reason you can read.
The one difference: everyone else predicts which model should do the work. Atelier proves it — with your code's own tests. Verification instead of prediction. That single shift is the whole art: near-frontier quality, at a fraction of the price, with a reason behind every dollar.
The gallery of proof
Don't ask for faith. Ask for the canvases.
Every proof below was measured with real hidden tests — no self-grading. They're framed as what they are: works that hold up to the most skeptical eye.
The workshop matches the master — at a third of the price
How to read it: an exceptional frontier model solves everything — but charges for everything. The cheap workshop nearly matches it; and when the canaries sang on the four hardest tasks, the master stepped in and closed them. Final result: identical quality to the top, at 31% of the cost.
The master's eye checks the measure
Why it matters: before comparing anything, we proved the measurement is honest. If the bench can't reproduce the known, the bench is broken — not the model.
The fleet outdraws the soloist
A diversity of hands, well orchestrated, sees what a single hand misses — and pays less for it.
The canaries never miss the alarm
The hardest part of trusting a system is knowing it fails gracefully. We pre-registered how it should behave — and it behaved, on all 16.
For skeptics — and we like them
Why this proof survives the hardest look
Good numbers are easy to stage. These were designed not to be. Here's the discipline behind every canvas.
Objective truth, not vibes. "Solved" means the code's own tests pass — re-run for real. No LLM judge, no self-report.
Paired arms. The same tasks ran through the cheap model, through Atelier, and through the frontier model. The cascade's contribution is isolated and measurable.
Public benchmarks. Aider-polyglot, SWE-bench, DABStep — proof anyone recognizes and can re-run. Nothing invented by us.
Pre-registered. The expectations were written before the run. You can't rationalize the result after the fact.
No cribbing. The reference solution was removed from the tasks; web search was turned off. The model solves — it doesn't copy.
Reproducible in minutes. Clone it, run the command, get the same table. The definitive proof is the one you run yourself.
The open workshop
Ask, and it gets added
Want a model, provider, or language test‑runner supported? Request it — and it gets built. The fleet grows with the community. And Atelier is at its best on a diverse, multi‑vendor fleet: mixing models from different families sharpens the disagreement signal, so the master is called exactly where two independent minds diverge. Single‑vendor works — multi‑vendor works even better.
The atelier opens its doors
The method the big labs keep — open, and yours
Free and MIT-licensed. The same engineering teams pay dearly to build, ready for you to point your editor at and go. No catch: we give it away because a tool you can trust proves itself.