
A Strong Model Delegates Its Reading, And Starts Believing Forgeries
11/16/2026
0:00
14:05
A Strong Model Delegates Its Reading, And Starts Believing Forgeries
Source: https://arxiv.org/abs/2611.17520
Paper was published on November 12, 2026
This episode was AI-generated on November 16, 2026. The script was written by an AI language model and the host voices were synthesized by Eleven Labs. The producer is not affiliated with Anthropic or Eleven Labs.
Point Claude Code at a folder with five forged documents and it catches the fake 179 times out of 180. Let it hand the reading to the cheaper helper model it ships with — same model on top, same files — and it adopts the forger's answer 75 times out of 180. A new paper argues the model you trust only protects you on the evidence it reads itself.
Key Takeaways:
- Why a strong orchestrator that catches a forgery 180 out of 180 times starts failing once a cheaper sub-agent reads the files for it
- The two controls that rule out 'summaries just lose information': a clean folder gave zero failures, and an equal-strength helper gave near-zero
- The uncomfortable detail inside the handoff — even when the helper's report did flag the forgery, the orchestrator sided with the fake 21 times out of 96
- Why explicit prompt injection was resisted everywhere, while forged text that 'makes no demand' got through
- The honest limits: forgeries were built to be catchable, failure means picking a wrong fictional name, and the 'weakest agent' slogan doesn't hold as a clean rule
- Two cheap defenses that brought failures from 15 to 3 and 1 in a 40-trial test — including one that just tells a verifier to be skeptical
00:00 - An attack that doesn't work — until it does: The cold open sets up the forged-archive setup and the single change — delegating the reading to a cheaper helper — that takes failures from 1 in 180 to 75 in 180.
01:20 - Where the evidence stops being the model's: Background on coding agents as models in a tool loop, and how the orchestrator/sub-agent feature splits the model that reads evidence from the model that decides.
02:15 - Forgeries designed to be catchable: How the fictional test items and forged documents were built — including the two planted flaws, a bad date and a missing accession line, that a careful reader should catch.
03:13 - What 'failure' actually means here: Eric flags that a 'harmful revision' means picking the wrong fictional name — no code run, nothing stolen — before the headline numbers arrive.
04:01 - The numbers jump everywhere: How delegation was forced on each product, and the across-the-board failure increases: 1→20 on Claude Code, 0→44 on Codex, 553 of 900 in the authors' own harness.
04:58 - Is it the handoff, or the reader?: The controls that isolate the cause — clean-folder delegation and equal-strength helpers both produce near-zero harm — plus the confound the authors could only argue, not test, in the products.
06:19 - The warning that never arrives — or gets ignored: Inside the sub-agent's report: the orchestrator spotted the missing provenance 180 of 180 times reading directly, but the helper's report carried the signal only 96 times — and even then the orchestrator sided with the forgery 21 times.
07:43 - Why delegation removes the occasion to verify: The authors' tool-call hypothesis — about six calls when reading directly versus three when delegating — and their admission that the testing experiment hasn't been run.
08:23 - The forgery that makes no demand: Classic prompt injection was resisted everywhere, while forgeries that merely look like records got through — and the attack only lives in a narrow window of catchable-but-missable content.
09:32 - Where the slogan breaks down: Eric pushes back on the title's claim: the system failed 75 times where the cheap model alone failed 136, so it inherits an error budget rather than the weak reader's specific errors — plus noise and delivery-route effects.
10:39 - Give it the source, errors go to zero: The aggregator simulation — 751 of 757 errors repeated from a fooled worker, dropping to zero in 780 once the aggregator sees the source — and a small defense test taking failures from 15 to 3 and 1.
11:58 - The cheap helper is a trust boundary: Closing argument: the sub-agent's report speaks in the system's own voice, so entry-point defenses miss it, and testing the orchestrator alone would never surface the failure.
Recommended Reading:
- Not what you've signed up for: Compromising Real-World LLM-Integrated Applications with Indirect Prompt Injection: The canonical indirect prompt injection paper — useful contrast to this episode's finding that explicit planted instructions were resisted while a forgery that 'makes no demand' succeeded. (https://arxiv.org/abs/2302.12173)
- AgentDojo: A Dynamic Environment to Evaluate Attacks and Defenses for LLM Agents: A benchmark for attacking and defending tool-using agents, which shows the kind of harness the episode's authors would need to measure how often real forged content lands in their 'catchable but missable' window. (https://arxiv.org/abs/2406.13352)
- Defeating Prompt Injections by Design (CaMeL): Proposes enforcing a hard trust boundary around data that flows back from tools — directly relevant to the episode's point that a sub-agent's report arrives as the system's own voice and escapes input-tagging defenses. (https://arxiv.org/abs/2503.18813)
- Towards Understanding Sycophancy in Language Models: Background for the episode's most unsettling number — the orchestrator siding with the forgery 21 times out of 96 even when its helper's memo flagged the problem. (https://arxiv.org/abs/2310.13548)
More episodes from "AI Papers: A Deep Dive"



Don't miss an episode of “AI Papers: A Deep Dive” and subscribe to it in the GetPodcast app.








