Talk, don't block: splitting the coding-agent composer from the worker

You are watching a coding agent work. You see it go the wrong way at step 6 of 40. You type.

The product has three bad options: queue the message until the turn ends (too late), inject it into the same turn (prefix-cache roulette), or cancel the turn (you just threw away the useful half).

I kept hitting this in Grok Build, Claude Code, and Codex. Different UIs. Same bug: the composer is owned by the worker.

Before

One agent is both conversational partner and writer. Tools run in the main checkout. Subagents exist but nesting is effectively off. The task pane is a flat list.

You ──every message──► Agent
                          │
                          ├── edits / shell ──► MainTree
                          └── optional depth-1 child ──► MainTree

Enter means "talk to the thing that holds the write lock." Esc means "abort the useful half." That is not a conversation. It is a hostage negotiation with a process.

After

You always talk to a supervisor. Mutating work is a tree of background jobs. Writers get worktrees. The supervisor reads, steers, kills. It does not hold the write lock.

You ──every message──► Supervisor
                          │
                          ├── read / search ──► MainTree
                          ├── spawn / steer / kill ──► JobA (worktree)
                          └── JobB (shared if read-only)

The supervisor is the free conversational partner. Jobs own context. Parallel. May nest within a depth cap. Writers stay isolated by default.

What Enter does

Action	Stops a job?	Prefix cache
Type to supervisor	No	Jobs untouched
Supervisor steers a job	No	Child: append-only
Supervisor kills a job	That node/subtree	Child aborted; committed history kept
Esc / send-now	Supervisor turn only	Jobs keep running

Steer is append-only interjection at the child's next safe gap. Kill is explicit. Cancel never means "throw away the worker that was almost done."

Landing

When a writer finishes: try to apply the worktree onto main.

Clean: land, wake supervisor.
Conflict: spawn a merge worker with "resolve, do not invent features." Two retries. Then tell the supervisor it is blocked.

Default is not "please click Approve on this diff." That is a setting (auto_merge / propose / branch). Humans are not the merge tool by default.

Isolation rules that matter

Mutating jobs: worktree default.
Explore / plan: shared tree default.
Depth while supervisor is on: parent → child → grandchild (cap 3).
Concurrency: capped. Unlimited nesting is a non-goal.

What this is not

Not a second IDE. Not a mission-control dashboard product. Not unlimited nesting. Headless one-shots stay single-agent (Solo) unless opted in. The supervisor does not do long-running shell or file edits itself — that is the whole point.

Why labs should care

Post-training improves tool-call validity. It does not fix a product that destroys prefix cache or cancels useful work when a human wants to talk. The harness shape is the control plane around the model. If talking kills the job, you are measuring the wrong failure.

The eval that matters is boring: did talking kill the job? That is the first slice of what I am calling steer-bench.

Offer

This pattern is being implemented in the open as steer — a clean-room control plane. Original code. Not a fork of any vendor CLI. Public names: Supervisor, Job, Isolation, LandingPolicy, spawn_job, steer_job, kill_job.

I build the layer around the model. This is the architecture I want to push until the boring eval turns green.