One Task, Five Tools, One Trace

Let’s not talk about the stack in the abstract. Let’s follow one ordinary task all the way through it and watch what each layer actually does. The task is the most normal thing an agent does all day: fix a real bug in a real repo. Nothing exotic. Just the kind of work where things quietly go wrong.

We will trace it hop by hop. At each hop, remember the honest framing: every layer helps on its own. Composed, they do something better than help. They remove failure modes you are usually just resigned to.

Hop one: the agent reads ground truth

The agent opens the task and needs to know what the code actually does: the call graph, the data flow, where the framework boundaries sit, what touches the thing that broke. Without a real picture, this is where an agent invents one. It reads a couple of files, pattern-matches, and forms a confident theory that happens to be wrong.

With TheAuditor in the loop, the agent reads ground truth instead of guessing. It gets a deterministic account of the code rather than a plausible story it assembled from fragments. The failure mode this removes is the silent wrong assumption, the one that produces a fix that looks right and breaks something two modules over.

Hop two: it starts from history, not from zero

Now the agent needs to know why the code is shaped this way. Has this bug been touched before? Was there a decision that looks wrong but was deliberate? A cold agent starts from nothing every single time and re-derives context that a teammate would already have in their head.

With Curator, the agent starts with the history and the decisions that led here. It picks up where the last session left off instead of re-litigating settled ground. The failure mode this removes is the forgotten decision, the one that gets “fixed” back into a bug because nobody in the room remembered why it was made.

Hop three: it keeps the action tight and the facts intact

The agent now has a correct picture and real history. That is a lot of context, and this is exactly where a careless client drowns it. Facts get flattened into prose, the token budget goes to shuffling boilerplate, and the good context you assembled gets crowded out of the window right when it matters.

With Warden, the action stays tight and the facts stay intact. It treats facts as facts and spends the budget on the work, not the wrapper. The failure mode this removes is the wasted context window, the slow drift where the agent gets dumber the longer the task runs because the useful stuff scrolled off the top.

Hop four: it survives the wall

Real work runs long. Somewhere in the middle the machine reboots, or the account hits a rate limit, or a provider throttles you into the dirt. Left alone, that is the end of the run. You come back to a half-finished job and no clean way to resume it.

With Arbiter over the top, the run state survives the crash and the operation can route around a throttled account. It supervises, accounts for interrupted work, and preserves the artifacts needed to recover deliberately. The failure mode this removes is the lost run, the night’s progress that vanishes because nothing was watching the job that was watching the code.

Hop five: you can believe the verdict

The fix lands and a scanner in the loop says “fixed.” That word is only worth anything if the scanner can actually find what it claims to find. Plenty of them cannot, and they will still tell you the bug is gone. So now you are trusting a verdict from a tool you never verified.

With BenchProctor, you can measure what that scanner catches against a balanced public answer key designed to resist label leakage. Its verdict now comes with evidence you can inspect instead of a green check taken entirely on faith.

The whole trace, in one line

Each of those five hops is useful in isolation. Any one of them, dropped into your setup today, earns its place alone. That is the promise we keep first.

But run the trace end to end and notice what happened: the silent wrong assumption, the forgotten decision, the wasted context, the lost run, the unverifiable claim, all gone from a single ordinary task. Not because we built a bigger tool. Because we shrank the surface where things go wrong. That is the whole idea behind Code Reality Labs: five tools you would pick on their own merits, that happen to add up to a task with far fewer ways to fail.