LLMs Corrupt Your Documents When You Delegate
Philippe Laban, Tobias Schnabel, Jennifer Neville ยท article ยท 2026-04-17 source โ Reader ๐ฅ๏ธ
Current LLMs are unreliable delegates that silently corrupt documents during long delegated workflows, as demonstrated by the DELEGATE-52 benchmark across 52 professional domains and 19 models.
practical ยท argumentative โ Empirical benchmark study with a clear argumentative thrust: current LLMs are unreliable delegates. Practical because it directly addresses the readiness of deployed AI systems for real-world delegation workflows.
Structure
| Part | Role |
|---|---|
| Motivation: delegation as a new interaction paradigm | Sets the stakes โ delegation (e.g., vibe coding) is emerging and requires trust |
| Introduction of DELEGATE-52 benchmark | Presents the evaluation instrument โ 52 domains, long editing workflows |
| Main experimental finding: frontier models corrupt ~25% of content | Core evidence for the thesis |
| Aggravating factors: document size, interaction length, distractor files | Identifies conditions that worsen degradation |
| Negative result: agentic tool use does not help | Closes an obvious objection (maybe tools fix it) |
| Characterization: sparse but severe, silently compounding errors | Describes the failure mode qualitatively |
Key terms
- delegation Delegated Editing & Document Corruption
An interaction paradigm where users hand off document-editing tasks to an LLM with the expectation of faithful execution โ distinct from conversational or co-editing use - DELEGATE-52 Evals
A benchmark simulating long delegated workflows requiring in-depth document editing across 52 professional domains - document corruption Delegated Editing & Document Corruption
Unintended degradation of document content introduced by the LLM during editing, measured as percentage of content corrupted - vibe coding Vibe Coding
Used as an example of delegated work โ coding driven by high-level intent rather than precise specification
Propositions
- explicitDelegation is emerging as a new interaction paradigm for LLMs in knowledge work.conf: high
- explicitDelegation requires trust that the LLM will faithfully execute tasks without introducing errors.conf: high
- explicitEven frontier models (Gemini 3.1 Pro, Claude 4.6 Opus, GPT 5.4) corrupt an average of 25% of document content by the end of long workflows.conf: high
- explicitNon-frontier models fail more severely than frontier models on DELEGATE-52.conf: high
- explicitAgentic tool use does not improve LLM performance on delegated document editing tasks.conf: highrefinesMeta's new model is Muse Spark, and meta.ai chat has interesting new tools ยท p3 โ Qualifies the harness-as-important-as-model claim: agentic tool use adds nothing on delegated document-editing fidelity.
- explicitDocument degradation worsens with larger documents, longer interactions, and the presence of distractor files.conf: highsupportsHarness design for long-running application development ยท p1 โ DELEGATE-52's finding that degradation worsens with longer interactions and larger inputs independently corroborates the long-running coherence-loss failure mode.supportsAgents don't know what good looks like. And that's exactly the problem. ยท p4 โ DELEGATE-52 finds degradation grows with document size, interaction length, and distractor files โ empirical backing for the claim that more context degrades output.
- explicitcorroboratedLLM-introduced errors are sparse but severe and silently compounding.conf: highsupports โBliki: Vibe Coding ยท p8 โ Non-deterministic edits introducing regressions in unrelated code matches the sparse-but-severe, silently compounding error finding.
- implicitcontestedCurrent LLMs are not ready to be trusted as autonomous delegates for document editing.conf: highcontradictsSkill Issue: Andrej Karpathy on Code Agents, AutoResearch, and the Loopy Era of AI ยท p4 โ Benchmark evidence that autonomous delegation silently corrupts documents cuts against the advice to arrange work to be completely autonomous.refinesPresentation: AI-First Software Delivery: Balancing Innovation with Proven Practices ยท p2 โ The DELEGATE-52 finding that even frontier models silently corrupt long delegated workflows adds an empirical caution to the advice to progressively move toward unsupervised agents.
- implicitdevelopedThe compounding nature of errors means that longer autonomous sessions are disproportionately dangerous, not just linearly worse.conf: mediumrefines โAgentics / Tech Things: Tokenmaxxing is dead, long live tokenmaxxing ยท p5 โ theahura explicitly concedes the 'compounding error' regime was real ('up until recently... we called this compounding error') and claims a regime shift has since flipped it, bounding the 'longer autonomous sessions are disproportionately dangerous' claim in time rather than denying it. Note: his evidence for the flip is a single security-domain data point, so weight the refinement accordingly.
- implicitcorroboratedHuman review checkpoints during long delegated workflows may be necessary to mitigate corruption.conf: mediumsupports โA cautionary tale about AI in tech writing: Why "Trust but Verify" is the only way to scale ยท p7 โ Independently corroborates that autonomous LLM self-review/delegation is unsafe and that external checkpoints (here: deterministic tooling plus a separate human proofing pass) are needed to prevent silent corruption of long documents.
Arguments
Current LLMs are unreliable delegates for document editing workflows. strength: high
Explicit premises:
- DELEGATE-52 simulates long delegated workflows across 52 professional domains
- 19 LLMs were tested on this benchmark
- Even frontier models corrupt ~25% of document content by the end of long workflows
- Non-frontier models fail more severely
Implicit premises:
- 25% content corruption is an unacceptable error rate for professional document editing
- The 52 domains in DELEGATE-52 are representative of real-world delegation use cases
- The simulated workflow lengths are representative of actual delegated sessions
Inferences:
- If the best models corrupt a quarter of content, the technology is not ready for unsupervised delegation
The delegation problem is fundamental, not an artifact of tooling limitations. strength: medium
Explicit premises:
- Agentic tool use does not improve performance on DELEGATE-52
Implicit premises:
- If the problem were about capability gaps (e.g., inability to read files), tool use would help
- The tested agentic setups are representative of current tool-use approaches
Inferences:
- The corruption stems from something deeper than missing tools โ likely the models' inability to maintain document fidelity during extended editing
Narratives
- Vibe coding as exemplar of delegation
โ Makes the abstract concept of 'delegated work' concrete and timely for readers familiar with the vibe coding trend
Questions addressed
- โ
Are current LLMs ready to be trusted with delegated document editing across professional domains?
No โ even frontier models corrupt ~25% of content in long workflows. - โ
Does agentic tool use mitigate document corruption in delegated workflows?
No โ agentic tool use does not improve performance. - โ
What factors exacerbate document degradation?
Document size, interaction length, and presence of distractor files. - โญ What mitigations or solutions could reduce delegation-induced corruption?
Not addressed in the abstract โ the paper diagnoses the problem but does not propose fixes.
Gaps
- incompleteThe abstract does not define what counts as 'corruption' โ whether it includes formatting changes, semantic drift, factual errors, or data loss. The 25% figure is hard to evaluate without knowing the corruption metric.
Read next: Read the full paper's methodology section to understand how corruption is operationalized and measured. - incompleteNo mitigation strategies are proposed. The paper identifies the problem but does not suggest solutions such as checkpointing, diff-based review, or constrained editing modes.
Read next: Check the full paper's discussion/future work sections, or look for follow-up work on delegation-safe architectures.closed byCoding Models Are Doing Too Much โ Supplies the missing mitigation strategies for unrequested-modification corruption: explicit preserve-the-original prompt instructions and RL training that generalizes minimal-editing behavior. - incompleteThe abstract does not clarify what 'agentic tool use' configurations were tested. The negative result (tools don't help) is only as strong as the range of agentic approaches evaluated.
Read next: Read the full paper's experimental setup for agentic configurations. - incompleteNo discussion of whether corruption rates vary significantly across the 52 domains. Some domains (e.g., music notation, crystallography) may have much stricter fidelity requirements than others.
Read next: Check the full paper for per-domain breakdowns. - incompleteExtraction limited to abstract only (242 words). The full paper likely contains detailed methodology, per-model results, domain breakdowns, and qualitative error analysis not available here.
Read next: Obtain and extract the full PDF at https://arxiv.org/pdf/2604.15597
Closes gaps elsewhere
- Skill Issue: Andrej Karpathy on Code Agents, AutoResearch, and the Loopy Era of AI ยท g1 โ DELEGATE-52 documents systematic failures (25% corruption even in frontier models, unimproved by agentic tooling) that persist regardless of operator skill โ the counter-evidence to the unfalsifiable skill-issue framing the gap asks for.
Related documents
- Presentation: AI-First Software Delivery: Balancing Innovation with Proven Practices
- Agents don't know what good looks like. And that's exactly the problem.
- Skill Issue: Andrej Karpathy on Code Agents, AutoResearch, and the Loopy Era of AI
- Meta's new model is Muse Spark, and meta.ai chat has interesting new tools
- Harness design for long-running application development
- Podcast: Tiger Teams, Evals and Agents: The New AI Engineering Playbook
- Article: Agentic Fitness Functions: Extending Evolutionary Architecture Beyond Deterministic Rules
- Presentation: From AI Agent Demo to Production: Automated Testing and Evaluation
- Android Studio Quail 2 Redesigns Agent Mode, Streamlines AI-Assisted Coding
- Presentation: Engineering AI for Creativity and Curiosity on Mobile