Coder: how we are building the best coding agent yet
Our aim for Coder is simple to say: the best coding agent yet. This post is about how we are building it, and how we intend to prove it rather than just claim it. We will also be honest about where it stands today, because a coding agent that overstates its own results is the thing we are trying not to build.
Make an application by talking about it
Coder is one window. The conversation is in the middle, the project’s files
on the left, and the file the conversation is about on the right. You say
make a stopwatch. Then you watch the agent create the project from a
template, check it, build it, run it on your desktop, and fix whatever the
check found. Every step is a row in the conversation, in the tool’s own
words: coder check stopwatch · running, then done or failed.
What comes out is a native Lisa application: Flutter on Lisa’s own frameworks, packaged as a real bundle, the same kind of thing as Lisa’s own apps. It is not a web page or a prototype.
Coder has no agent of its own
This is the decision everything else rests on. Coder carries no agent loop and makes no call to a model. Its agent is the Harness, Lisa’s one agent loop, a system service that every surface shares. Coder is the window a developer meets it in.
That has consequences you can feel:
- Your model, your key, never Coder’s. You choose the model in Settings. The key lives in the one daemon allowed to talk to a remote provider, and Coder never sees a provider, a key or an endpoint. Every turn that left the machine carries the egress mark. We were offered a shortcut, a direct provider call from Coder, on 30 September, and refused it.
- The same conversation everywhere. The session belongs to the Harness, so the Assistant can pick up a conversation Coder started.
- Everything is ledgered. Every tool call is an entry in the Ledger of the daemon that served it.
Every act is a command you could type
The agent does not have private powers. Each of its coding tools is either a
coder verb or a plain file read or write:
| tool | what it runs |
|---|---|
coder_create |
coder create <name> --template blank|counter |
coder_check |
coder check: the analyzer, the tests, the goldens, the contract checks |
coder_build · coder_package |
a development build and bundle |
coder_run |
coder run, launching the app on this desktop |
read_file · write_file |
a file inside the project, nowhere else |
So anything the agent did, you can reproduce from a terminal with the same
words. The tools run in a jail: your Developer folder, with every path
walked one component at a time and no symlink followed out of it. No tool
deploys, publishes or reaches past the workspace. A coding agent that can
push to production on its own is a risk, not a feature.
What makes the loop good
“Best” is not one trick. It is a set of decisions, each written down in the specification, about where coding agents usually go wrong.
Best of N, judged by a verifier the agent cannot weaken. The easiest way for an agent to “pass” is to edit the tests. So before choosing between attempts, the Harness restores the whole verifier, including the acceptance tests, the runner configuration, the command and the fixtures, to what it was before the attempt. Then it runs that untouched verifier against each attempt. A smaller diff never wins just for being smaller.
Finding the right code is deterministic. Before an agent can fix code, it has to find it. Lisa’s localisation uses no judge model. It uses a map of the repository ranked by how central each part is, weighted toward the names in your task and toward recent changes, plus tools the model drives: outline, find references, expand. Its regular expressions run in linear time and cannot be made to backtrack.
Compaction condenses; it never stubs. Long sessions overflow any context window. When the Harness shortens an old result, it keeps the skeleton by rule: the tool, the arguments, the paths, the exit code, the first and last lines, the errors and the counts. The agent never forgets that a test failed, only the lines that did not matter.
Reflection is triggered by a count. The second identical failure makes the model stop and say what most likely went wrong and what it will change. Values that wobble from run to run count as the same failure, so an agent going round in circles is caught rather than rewarded for variety.
Other agents are quarries. When another harness proves an idea, it comes into Lisa as Lisa’s own code, with its tests watched failing first. It is never vendored as a subsystem. A foreign agent can run inside the same jail, under the same guard, but never as something Lisa depends on.
How we will know
The specification sets two evaluation tiers, and is strict about what each one can say:
- A committed tier of real bugs runs offline on every commit. It is small, so it can catch a large regression. It can never certify an improvement.
- A public tier, pinned by hash, is large enough to tell a real improvement from noise. It is the only gate allowed to say Coder got better.
A task the harness cannot set up counts as a failure, never a quiet skip. That rule exists because it is the easiest way to inflate a score. “Best coding agent yet” is a claim we intend to earn on the public tier, in the open, and not before.
Where it is going
Coder’s page lays out seven milestones, each with a gate it has to pass:
- The conversation over the Harness, with tool rows, the projects pane and a read-only editor.
- What each tool said, such as analyzer rows and a run’s journal, shown under the row that produced it.
- A real editor: undo per file, format on save, diagnostics inline.
- Developer Mode, so a project runs on a sealed desktop.
- Live UI: change a widget and see the window update within two seconds, with breakpoints.
- Package and ship: an application written in Coder appears in Harbor on a second machine.
- A design canvas that writes Dart, both ways with the editor.
The acceptance test we like best is the last word on the loop: an agent creates a project, breaks a test, fixes it and runs it green, every step a ledgered command. And Coder’s own: Coder builds Coder.
Where it stands today
We are at the first milestone, and it is rough:
- The window is a first slice. On 2 October, with no model connected,
it showed the agent’s tool calls as raw JSON and a
coder createthat failed without saying why. Tool calls as proper cards, and failures that name their reason, are owed. - No coding tool has run to its end on a real machine. The tools are in
every release since 30 September and tested in isolation, but the
codercommand is not on the image yet, so every tool fails with could not run. - Best of N runs one attempt after another, by snapshot and restore, not in parallel copies.
- The public evaluation tier is not built. Until it is, nobody, including us, can say how good the loop is.
- Developer Mode does not exist yet, so Coder can build an app but not run it on a sealed desktop.
That list is the work ahead. The design is the part we are confident in, and the numbers will have to show the rest.
Where to read more
- Coder: the window, the tools, the milestones and everything not yet true.
- The agent: the Harness, and coding in it.
- Lisa for developers: the SDK and the
codercommand.