The Reviewer Never Saw the Chat
The Reviewer Never Saw the Chat
There's a temptation, when you run a team of agents, to give every agent everything. Full transcript, full history, all the context the lead agent has accumulated. More context means better output, right?
For one role, the opposite is true: the reviewer.
The setup
A common pattern in agentic operations is a small internal pipeline: one agent writes the code or the plan, another reviews it before anything ships. The builder gets a concrete spec — objective, inputs, expected output, edge cases. The reviewer gets the finished artifact and the spec. That's it.
Crucially, the reviewer does not get the conversation that produced the work. It never sees the builder's reasoning, the false starts, the "I think this is fine because…" justifications. It reads the diff cold, the way a stranger would.
Why cold reads matter
When a reviewer shares context with the author, it inherits the author's assumptions. If the builder convinced itself that an input can never be empty, and the reviewer reads that reasoning first, the reviewer nods along. The whole point of a second pair of eyes is that they haven't been staring at the same thing for an hour.
This is doubly true for agents, because agents are agreeable by construction. Feed a model a transcript full of confident reasoning and it will tend to continue the pattern rather than attack it. Context isn't just information — it's momentum. A reviewer with the author's context is a reviewer already leaning yes.
The fix is structural, not motivational. You don't prompt the reviewer to "be extra critical." You withhold the transcript. Isolation does what instructions can't.
Verdicts, not vibes
The second half of the pattern: the reviewer's output is a verdict from a fixed ladder — approve, approve with nits, request changes, block. Not an essay. Not "looks pretty good overall!"
Fixed verdicts matter because the pipeline is a machine, and machines need decisions they can branch on. "Request changes" loops the work back to the builder with the findings attached. "Block" stops the line and escalates to a human. A free-form review that hedges in prose gives the orchestrator nothing to act on — and in practice, ambiguity always resolves toward shipping.
The failure mode this catches
A concrete pattern from the field: a builder agent writes a maintenance script, tests it against the happy path, and declares victory. The cold reviewer — with no memory of the builder's testing narrative — asks the obvious stranger's question: what happens when the target list is empty? Answer: the script interpreted "empty" as "all," which is the kind of bug that turns a cleanup task into an incident.
The builder wasn't careless. It was contextual. It knew the list "would never" be empty because upstream always populated it. The reviewer didn't know that, so it checked. Ignorance, deliberately engineered, was the safety feature.
The takeaway
If you're wiring up multi-agent pipelines, resist the urge to share context generously. Ask instead: what does this role need to NOT know to do its job well?
- Builders need the spec, not the whole business.
- Reviewers need the artifact, not the author's reasoning.
- Both need output formats a machine can branch on.
Separation of context is the agentic version of separation of duties. The reviewer never saw the chat — and that's exactly why its opinion is worth something.