Jun 6, 2026 · 5 min read

Three changes that made my coding agents reliable

Adversarial verification, artifact-driven context, and loop-until-done — what building a multi-agent coding harness taught me about where the leverage actually lives.

I’ve spent the last few weeks building a multi-agent harness for software delivery — the orchestration layer that carries a task from request to shipped change across planning, building, and review. I went in expecting the work to be about prompting. It mostly wasn’t.

The biggest lesson surprised me: the model was never the bottleneck. As the underlying models get better, the leverage moves out of the model and into the system around it. The same model, dropped into a better harness, goes from “impressive demo” to “actually reliable.” Three changes moved my reliability more than any prompt tweak.

Shipped ✓Builderwrites codeArtifactplan · diffReviewerisolated contextGatedone?approvednot done → loop back and iterate
The harness as a loop, not a single pass. The builder ships an artifact; an independent reviewer judges it at a gate. “Done” is something the work has to pass — not something the builder gets to declare.

1. Adversarial verification, not self-verification

Asking a builder agent to check its own work is asking it to be skeptical of a conclusion it just spent its whole context arguing for. It almost always declares victory.

The fix is a separate reviewer agent with its own isolated context. It never saw the builder’s reasoning, so it has nothing to be loyal to — it reads the artifact and the diff cold and tries to find what’s wrong. That one change caught the single most common failure mode in agent workflows: declared done too early. The builder is convinced; the reviewer, with fresh eyes and no sunk cost, is not.

Builder agentargues its own work is correctlong, invested contextno shared memoryReviewer agentfresh, isolated contextthe artifact + diffread coldnothing to be loyal toclaims: donerejects: not done
Adversarial, not self-, verification. The reviewer never saw the builder’s reasoning, so it has no conclusion to defend — it catches “declared done too early” far better than asking the builder to grade itself.

2. Artifact-driven context over conversation memory

The naive design threads everything through one growing conversation. It works for short runs and falls apart on long ones — once the history gets noisy, the model starts drifting, re-litigating settled decisions, and losing track of the actual goal.

Passing structured artifacts between stages fixes this. Each stage produces a typed, self-contained output — a plan, a diff, a review verdict — and the next stage consumes that, not the raw transcript. The context each agent sees stays small, clean, and relevant no matter how long the overall run gets.

Artifact-driven contexteach stage hands off a clean, typed outputPlanstage 1Buildstage 2Reviewstage 3Conversation memorytaskdrift · repetitionone long transcript — context degrades as it grows
Structured artifacts keep each agent’s context small, clean, and relevant — no matter how long the overall run gets. A single growing transcript does the opposite.

3. Loop-until-done, not one-pass generation

One heroic prompt that tries to do everything in a single pass is fragile. Explicit stage ownership with approval gates beats it every time: each stage owns one job, hands off an artifact, and the run loops — build, review, fix, re-review — until the reviewer signs off.

The loop is the point. “Done” is a gate the work has to pass, not a thing the builder gets to declare.

The takeaway:

The competitive edge in agentic systems isn’t a smarter agent. It’s the harness — the orchestration, traceability, and verification around the model. Swap in next year’s model and a good harness gets better for free; a bad one stays unreliable.

So what?

If you’re building with agents, the instinct is to reach for a bigger model or a cleverer prompt when reliability slips. In my experience the higher-leverage move is almost always structural: isolate the reviewer, pass artifacts instead of transcripts, and make “done” a gate.

I’m curious what failure modes others are hitting. If you’re running agents in production — what’s the one change that most improved your reliability?

← Back to blog