When you ask one model to check another model's work — if the input already contains a ready-made conclusion ("I think the error is here") — the second model almost always just parrots that conclusion, even when it's wrong. Strip out that one phrase from the report, and the model starts actually analyzing the facts — though how much it helps depends on whether the original conclusion was right or wrong to begin with.
Picture a chain of several AI agents: each one does its step and writes a report with observations and its own conclusion — "the problem seems to have happened at step 3." When you need a third model to audit the chain and figure out where things actually broke, that auditor reads all the reports. If even one agent incorrectly fingered the culprit, the auditor follows that lead 96% of the time — accuracy craters to 4%, worse than random guessing (20%). The model isn't checking anything — it's just relaying someone else's opinion down the line, like a game of telephone.
The fix is simple: delete one line from the report — the "suspected source of error" — and leave only the raw observations. Without that phrase, auditor accuracy in cases where the upstream agent was wrong jumps from 4% to 45%. But in cases where the upstream agent was right, accuracy drops from 70% to 56%. This isn't a flat-out improvement — it's a trade-off: remove the hint and you lose the benefit of correct hints, but you stop inheriting other agents' mistakes.
Method Blueprint
STEP 1: Each agent/stage writes a report → observations + a separate conclusion ("step X is to blame")
STEP 2 (option A): Auditor reads reports WITH conclusions → almost always just repeats someone else's conclusion
STEP 2 (option B): Auditor reads reports WITHOUT the conclusion, only observations → reasons independently
Both steps run as separate requests (or separate chats) — first you collect the reports, then you run the audit as a separate prompt.
Example Use Case
Task: At an IT company, an incident passed through three support tiers (L1 → L2 → L3), and each tier wrote a report with facts plus its own opinion about the root cause. You need to figure out objectively who's actually at fault — for the postmortem.
Prompt (after collecting reports from all three tiers):
Here are the reports from three support tiers about the incident.
I removed each tier's final conclusion about the cause —
I kept only the factual observations.
L1 report (observations): {what tier 1 saw, without the "the problem is X" conclusion}
L2 report (observations): {what tier 2 saw, without the conclusion}
L3 report (observations): {what tier 3 saw, without the conclusion}
Analyze only these observations on your own.
Don't try to guess what each tier "probably" thought —
form your own conclusion about which stage
actually caused the failure, and back it up with the facts above.
Result: The model will give you an independent, fact-based breakdown instead of parroting someone else's opinion. If one support tier mistakenly blamed the wrong party, the model is much more likely to catch it — because there's no ready-made "answer" sitting there for it to copy.
⚠️ If you're confident the support tiers' opinions are usually correct — don't strip them out. In that case, the auditor will be right more often on straightforward cases, but it will blindly repeat the rare mistakes.
Why This Works
LLMs are prone to anchoring — if a ready-made textual conclusion sits right next to the facts, the model tends to latch onto it instead of reasoning from scratch. It works like a hint written into an exam question: if the answer is right there in the prompt, the brain (and the model) gets lazy and skips re-checking it.
Where models genuinely shine is reasoning from facts when there's no ready-made answer available. They're good at drawing logical conclusions from observations — as long as they're not nudged toward copying.
The method removes the "hint," leaving only raw data — which forces the model to form its own conclusion instead of copying one. But the research is upfront about the ceiling here: even without someone else's conclusion, the auditor still falls short of the accuracy you get from full raw documentation (45% vs. 60%) — meaning the reports themselves are incomplete, and cutting the conclusion doesn't fix everything.
The control lever: whether to show or hide a prior agent's conclusion depends on how much you trust its accuracy. If the upstream agent is usually right, keep the conclusion. If it's often wrong, or you simply don't know how reliable it is, strip the conclusion out and ask the model to reason from scratch.
Prompt Template
Here are the observations from {number} participants in the {process name} process.
I deliberately removed their final conclusions/suspicions —
I kept only the facts they recorded.
{participant_1}: {observations only, no conclusion}
{participant_2}: {observations only, no conclusion}
{participant_3}: {observations only, no conclusion}
Your job is to independently determine {what you're looking for: where the error occurred / who's at fault / what went wrong},
based ONLY on the facts above.
Don't assume what the participants might have thought —
form an independent conclusion and back it up.
🚀 Quick start — paste this into a chat:
Here's a template for independently auditing a multi-step process.
Adapt it to my task: {your task}.
Ask me questions to fill in the fields.
[paste the template above]
The LLM will ask how many stages/participants are in the process and what data you have for each — because the method requires separating each participant's facts from their conclusions, and without that separation, the trick won't work.
Limitations
⚠️ A trade-off, not a straight improvement: removing a prior agent's conclusion only helps when that conclusion is frequently wrong. If the original opinions are usually accurate, removing the conclusion lowers overall audit accuracy.
⚠️ Accuracy ceiling: even without someone else's conclusion, the auditor still doesn't match the accuracy you'd get from full access to the process's raw data. The method reduces harm — it doesn't substitute for complete information.
⚠️ Effect size varies by model: the direction of the effect (removing the conclusion helps when upstream was wrong) holds up consistently, but the magnitude swings widely across models and domains — from 8 to 61 percentage points.
How It Was Studied
Researchers built a synthetic chain of 6 "agents" (raw material certification → manufacturing → inspection → shipping → and so on), each with its own isolated access to information — as if they were separate companies. The original hypothesis was about "diffusion of responsibility": if accountability is collective rather than individual, agents would flag problems less often as the chain grew longer. They tested this hypothesis across 345,600 prompts per model — and it didn't hold up. Being upfront about that failure, the authors dug further and found something else: when an auditor (a third model) reads the agents' reports to find the source of an error, it picks the culprit from among the options the agents themselves proposed 95% of the time — even when every single agent got it wrong. They pinned down the causality with surgical precision: they removed exactly one phrase ("suspected source: step N") while keeping everything else unchanged — and saw a clear effect that replicated with a second auditor, across two top-tier models (GPT-5, Claude Sonnet), and in a completely different domain (a software development pipeline), where the effect was actually even stronger.
Resources
Audit Without Verification: When LLM Accountability Layers Relay Rather Than Check. Paul-Peter Arslan, Institute for Future Technologies. Preprint, under review. Related work: Zhang et al. 2025 (error-attribution benchmark for multi-agent systems), Chen et al. 2026 (effect of full execution traces), Hao et al. 2026 (conformity in agent debates), Huang et al. 2025 (anchoring in LLMs).