How it works
A malformed signal enters; refined briefs leave; the queue takes them into implementation; delivery is checked against the remote. First the line, stage by stage. Then the six mechanisms that make each stage stop living in the operator.
Running more agents is the easy part.
Every one of them must be briefed, watched, transitioned and remembered, and all of that lands on the single component that does not scale: the person.
Capacity went up. The choreography went up with it, and it went up in the human. Four places it hurts:
The session is the wrong container
Context accumulates until the window fills, and then the understanding built inside it ends. A transcript records everything and privileges nothing: the decision weighs the same as the typos.
The human became the scheduler
The agent writes the code. The person opens sessions, loads context, composes prompts, watches the window, saves state, repeats. Measured: one task, eight sessions, human input almost entirely "resume" and "go ahead".
Declared done is not verified done
Documented scar: four tasks marked done in state files, nothing on the remote, worktrees deleted, $13.50 silently destroyed. An agent that says it finished and an agent that finished are indistinguishable without evidence.
The bottleneck is upstream of execution
Demand arrives malformed: a Slack thread, a feeling the release is risky, a promise made in a meeting. Turning that into a dependency-ordered set of executable tasks is hours of unassisted work, and every tool on the market starts after it.
One line per signal, capture to verified delivery.
Intent Distill is the surface; the prepare governor drives it. A malformed signal enters; refined briefs leave; the queue takes them into implementation. The choreography you used to perform between sessions is the product.
Fire-and-forget when you want it: the line runs unattended end to end. Whatever deserves your answer lands in a NEEDS YOU queue and notifies you, desktop and mobile, so the line never sits idle. Answering always wins; nothing outward-facing fires without you.
Everything lands in an inbox that carries no obligation: a thread, an alert, an idea on the way out the door.
Findings surface, ambiguities are forced up and resolved by you, before execution, never mid-flight.
Egested as briefs a competent stranger could execute: acceptance criteria, dependency order, workflow mode.
WIP-limited, dependency-ordered. How much runs at once is a number you set, not a habit you fight.
Each task moves through gated modes; every session records its cost, turns and artifacts.
Delivery is checked against the remote, and what could not be read reports as a gap, not a zero.
Only three things escalate: a product or scope decision, a fact only you know, an outward-facing effect. Everything else is arbitrated with a recorded rationale.
Every decision taken in your name is recorded: the action, the object, the criterion used, and a deep link that reopens the exact session.
A run's own findings re-enter through the same front door as any signal. What the work turned up but did not do is never lost; it queues.
Six things that stop living in the operator.
None of them is judgment. Some things genuinely require it: is this the right plan, is this worth starting, is this actually done. There the work stops and waits for you. Everything else moves.
The task outlives the session
The session is disposable by design; the task is not. It moves through named modes, and every transition is guarded by an artifact on disk. Progress is something a directory can prove, and the next session resumes from files, not from memory.
The choreography is the product
The prompt for each mode is composed, not typed: the task's state, the files that must be in front of the agent, the standards that apply. Hooks rebase before, commit and push after, write state back. Eight manual setups became one command.
A limit that actually holds
Work waiting to run is a queue with priorities and dependencies, resolved in topological order. How much runs at once is a number you set, not a habit you fight. Something genuinely blocked stays blocked instead of being started twice.
The refinery closes the gap upstream
Signal to findings to decisions to briefs, with adversarial lenses applied while the refinery can still fix what it wrote. Only three kinds of decision cross to you; every other call is arbitrated with a recorded rationale and a receipt you can reopen.
Done that proves itself
Gates are files on disk, checkable by anything that reads a directory. The delivery scoreboard reads the remote, never the local checkout, and prints the ref, the sha, and when it looked. A false "done" gets flagged, not shipped.
An economics ledger nobody else has
Cost and turns per session, per mode, per task. Where the time goes, which mode is expensive, whether a task was badly sized: questions with answers. A supervisor can be wrong about their own system and find out.
All product views on this page are stylized recreations of the live surfaces, with representative data.
Supervision that never stalls
Autonomy that cannot be inspected is opacity with a better name. Every mode is named, every gate is checkable, every session can be reopened by hand, and the merge is always yours.