The Harness
Is the Product.

I didn't set out to build a multi-agent framework. I set out to stop being the integration layer between my own Claude sessions.

The pattern was always the same. One session drafted a spec. I pasted it into another, which argued architecture. I pasted the plan into a third, and code appeared. Then I diffed it by hand, found three contradictions the model had forgotten since page one, and started over.

The models were not the problem. The harness was.

More precisely, the harness was me: tired, holding the whole context in my head, deciding which answer counted, remembering what the last reviewer said, re-checking whether "fixed" meant fixed. Nothing on disk was authoritative. Nothing outside my own attention enforced the workflow.

So I built the harness.

01The Bureau

The system is called the Bureau. It lives as one global install at ~/Code/novadiem/agent-framework, and it is not a wrapper around a chat window. It's a workflow engine: a task registry, isolated run directories, specialist personas, model routing by role, human checkpoints, and gates that something other than a model has to clear.

The Conductor — the central session — writes no specs and no code. It triages the task against the registry (bug fix, feature, execute-plan, operational-build) and spawns specialists into fresh contexts.

The cast is functional, even where the names are theatrical. If I'm going to live inside a system for months, it should have enough personality that I want to come back to it.

The conversation is never the source of truth

Every run gets its own directory. Machine state lives in state.json. Human history lives in log.md. Specs, plans, briefs, prompts, reviews and build outputs are all ordinary files. The artifacts are authoritative — not the chat.

Routing is by role, not by favourite chatbot

The framework defines provider-neutral tiers and a resolver maps them to whatever host is running the work — Claude Code, Codex, OpenRouter-backed models, anything appropriate. The Conductor runs strong; the Challenger runs strong in a fresh context; ad-hoc spawns never inherit a premium session, because that is how you burn tokens grepping a log file.

I've shipped real work through this. Four production systems, one person — not because the harness writes better code than I do, but because it holds the context I can't, and won't call a thing done until an artifact on disk says so.

02Where the system lied to me

That's the harness working. But I trust it most in the opposite case: when something inside it is wrong and the system catches the lie anyway.

Every trusted green signal in this system has lied to me at least once: my own diagnosis, the cold reviewer, the passing fixture. Each time, the thing that caught the lie was the same — something repo-aware, reading the actual code, outside the party that wanted to ship. Here are four.

03The run where green meant wrong

I was designing a Delegate: a narrow agent to hold routine checkpoint gates so runs could continue while I was asleep, or parenting, or doing any of the parts of life that aren't pasting agent output between windows. Flow and gating only — not a preference model. Just: does this artifact meet the written spec, checklist, and acceptance contract?

Before building it, I stress-tested the design against five general-purpose models — Claude, Grok, ChatGPT, DeepSeek, Mistral. The feedback was useful. One caught fused responsibilities. One sharpened the audit trail. One pushed me to separate Delegate and Notary concerns. By the fifth review the returns had collapsed into agreement, and it felt earned.

Then I ran Codex in the actual repository, with the relay telemetry in front of it. My central diagnosis was wrong.

I'd assumed the cost problem was the growing Conductor transcript. Clean diagnosis, clean fix. Codex looked at the numbers instead:

# my diagnosis: the transcript is the sink
input_tokens        = 52,000,000
cached              = 50,200,000   → ~96% cached. not the transcript.

# the real sink
terminal_roundtrips = 126          redraw noise + re-verified artifacts
stalled_session     = 8 min        resumed, spun, produced nothing

It also found two design claims I'd been treating as facts. I'd said the Delegate persona would clear the framework's battle-test gate; Codex checked the rules — that gate applies to workflows, not personas. I'd said the Delegate could intercept an existing review step as a checkpoint; Codex traced the workflows — that step runs straight through, and intercepting it means adding gates to the workflows, not making a small local substitution.

Five reviewers with only my design document converged on a confident wrong story. One reviewer with the running system found what was actually broken.

04The role still earned its place

The cost diagnosis was wrong. The role was not.

I had a hard run sitting in the output directory: a 109 KB spec, a 94 KB prompt set, a shell-and-jq feature with an ugly validation contract. The Challenger had passed the prompts. A focused verification pass reported zero blockers. The Delegate prototype kept going, and caught twenty build-breaking defects across three rounds.

That settled something I'd been unsure about. A second reviewer earns its place when it checks how the first reviewer's findings were handled — not "does this read well cold?" but:

Nobody else in the pipeline was asking that. And it narrowed the cost story honestly: you don't make a 94 KB prompt review cheap by pretending the bug lives on page one. The real win is mechanical — kill the live-terminal overhead, kill cross-round accumulation, run the review in a fresh process: read files, write verdict, exit. Not magic. Just less machinery left running.

05The expensive loops were upstream

Once I stopped blaming the wrong thing, another pattern surfaced. The expensive loops weren't mainly The Challenger being picky. They were Analizer 2000 and The Architect drifting apart. Analizer writes the requirements. The Architect designs against them — sometimes reading them differently, sometimes barred from editing them — so it bolts on an addendum. Now the second half quietly contradicts the first.

06CI is the gate, not another voice

I'm building toward mechanical enforcement, not a bigger panel of advisory reviewers. The execute-plan workflow already supports regression fixtures inside the run directory — shell commands with expected output. Before every build-prompt dispatch, the fixtures run again. A failure blocks the prompt. Not "the Conductor thinks we're fine." The command passes or it doesn't.

Then I learned that fixtures can false-pass in ways that look exactly like green CI. One static-grep guard matched its token inside a comment line: delete the actual guarantee from the code and the fixture still passed.

That's the shape of gate I want everywhere. Not "the model said proceed," not "five models agreed." A script. A schema check. A cold attestation on a sealed artifact packet. Something outside the party that wants to ship. The Notary is exactly that — external cold attestation on a sealed packet. The Delegate holds the routine checkpoints; the Notary samples whether the Delegate's "proceed" calls were actually justified against the artifacts.

07What I haven't shipped yet

Honest inventory. It's tempting to jump straight to "an agent that knows what I'd do." I don't think that's the right first abstraction. I'd rather build a system that can prove an artifact met its written contract before I build one that claims to know my taste.

• BenchmarkedThe Delegate is designed and benchmarked on real build-breakers — but not in production. Open question: does the file-mailbox version actually beat the live relay on cost across a full feature run?
• IdentifiedThe analyst-drift pass is identified, not yet wired into every workflow.
• PartialCI-as-merge-gate exists at the run-fixture level. I haven't closed the loop so a repo-level merge is blocked on fixture-green the way I want for unsupervised overnight runs.
• DeferredThe Principal — the agent that will eventually act on my behalf according to my decision principles — is explicitly deferred. I'm not pretending it exists. Flow-and-gating comes first.

08The harness decides

The models are instruments, not competing chatbots. Claude Code is strong for orchestration and build. Codex earns its place when I need something to read the repo and argue with receipts. GPT, Gemini and the rest route through gateways where the product needs them. Different costs, different context behavior, different failure modes. The harness is what decides:

What I'm looking for

Not a place that wants slide decks about agentic AI. People who already understand the difference between "I use AI for coding" and "I built the thing that decides which agent runs, on what artifact, with what gate, and what happens when it lies."

The Bureau still breaks in predictable ways: cold reviewers rubber-stamp, fixtures false-pass, paper designs survive five model reviews until something repo-aware reads the code. Each failure goes into a cross-run lessons log, and when the same shape shows up twice it gets promoted into the framework. That's the loop I trust, and the job I want: build the harness, run real work through it, find where it lied, and fix the part that let it. Then leave it running overnight.