The relay between the two models becomes a command. The human stays at the three gates that carry judgement.
Today the review model and the executing model each live in a chat tab, and every pack, stop and amendment travels between them by hand. The harness moves that traffic as files, applies the mechanical edits itself, and asks the human only where the rulebook already says a human decides.
The rulebook keeps its three gates. Only the courier changes.
Mark's standing rulebook already names the points where a human must decide. The harness does not add or remove one; it removes the pasting between them.
| Point in the round | Today | With the harness |
|---|---|---|
| Decisions settled, pack written | Review model with the human in chat | Review model, using tools that count against the bundle before it submits; if it needs a decision first, it asks and the human answers in one line |
| Pack ratified before any build | The human reads it in the tab | The human sees every old and new wording in full, types the round number |
| Pack carried to the executor | The human pastes | Nobody: it is a file |
| Edits applied, counts asserted | Executing model, by hand | The harness, in code, all of a stage or none of it |
| Checkpoint after the riskiest stage | The human reads the report in the tab | The human reads the report file, one keypress to continue |
| A stop carried back for an amendment | The human pastes, twice | Nobody: the report becomes the reviewer's next message |
| Amendment approved, run resumes | The human pastes again | The human sees the one-line diff, one keypress |
What changes for the person running it
One command, not two tabs
A round starts with one command in a terminal and ends with a round report. The models are told what they may touch and cannot reach past it.
The mechanical half runs as code
Counting, replacing, registering and stopping are done by the harness, keyless. A model is asked only for what code cannot do: judge a comment, write a wording, read a page.
The record writes itself
Every edit, stop, gate answer and model turn lands in append-only registers inside the bundle, so a fresh session can pick the round up from the files alone.
What you need
Python 3.12 and the repo
Clone, create a virtual environment, install. The keyless selftest proves the core works before any model is involved.
Your claude.ai plan, or an API key
Since June 2026 every claude.ai plan carries a monthly Agent SDK credit (Pro $20, Max 5x $100, Max 20x $200), claimed once in your account. The harness's default backend runs on that credit through the Agent SDK, logged in with your own Claude account. An Anthropic Console API key is the other path, pay as you go, and the right one for an enterprise deployment.
No Claude Code in your day
You never open Claude Code. The subscription backend installs the Agent SDK, which carries the Claude Code runtime as a library; the API backend uses the plain client SDK. Either way the loop is one command in a terminal.
What exists today and what is still to build
| Piece | State | What it does |
|---|---|---|
| Deterministic core | Built | Parses a pack, asserts every count in a stage before writing, applies, registers, stops, checkpoints, resumes from the failed item. Keyless. Tested. |
| Reviewer tools and draft check | Built | Checks a draft pack against the bundle before a human sees it and refuses to accept an unclean one; a command does the same with no model. Keyless. Tested. |
| Config, client seam and transcripts | Built | Which models run each role, recorded with every round; every model turn appended to a transcript the round can be rebuilt from. The live client itself is not yet connected. |
| Executor conversation and gates | Built | The pre-flight, the run, the four gates, the state machine. Runs end to end on scripted models with no key. |
| Live model backends | Built | Subscription path through the Agent SDK (default) and API-key path through the client SDK. The subscription path has run live twice on a real login: the first run stopped to ask four scoping questions, the second submitted a clean pack. Each cost between one and two dollars of the monthly credit. |
| Render and measure | Built | Rulebook Part 5: a pack item renders a page to an image, measures its ink and its drift from a reference, keeps the render as evidence, and stops the round if the page is blank or drifted. A missing renderer stops rather than passes. |
| Post-round verification and the concurrent-modification stop | Built | After a round the review model independently re-tests the bundle against a deterministic diff and files a verdict. A file changed by anything other than the harness between ratification and a run fails the round with the rulebook's quarantine instruction. |
| Code | Meaning | Who answers it |
|---|---|---|
| 0 | Round complete, report written | Nobody: the bundle goes back to the review model for its own check |
| 2 | Checkpoint stage complete, report waiting | The human |
| 3 | Something did not match, stop report waiting | The review model, with an amended pack |
The next thing to agree
The pack format is the contract between the two models, and it is generic: exact old text, exact new text, an asserted count, grouped into stages with at least one checkpoint. It fits any build where a change can be stated that way, which covers contracts, reports, bid packs and generated code alike.
What it needs now is one real round, on synthetic material, run against it. That is the point at which the format either holds or gets amended through the rulebook's own loop.