Does model capability change how documents degrade?
This explores whether weaker and frontier LLMs fail in fundamentally different ways when handling long-form document tasks, and whether that difference affects how reliably we can detect failures in practice.
DELEGATE-52 surfaces an under-discussed asymmetry in how LLM document degradation looks at different capability tiers. Weaker models fail loudly: they delete content. The document gets visibly shorter, sections disappear, structure breaks. A reviewer notices.
Frontier models fail quietly. Their degradation comes from corruption of existing content — values flipped, references rewritten, edits applied in the wrong place — producing documents that look intact at a glance but contain accumulated drift. The corruption mode is more dangerous than the deletion mode precisely because it preserves the surface signal of competence. The thing that looks like a successful workflow output is the thing that has silently drifted.
This matters for adoption. The "frontier models are reliable" intuition is built from short-interaction benchmarks where the corruption mechanism barely activates. At workflow scale — the regime where delegation is actually useful — the failure changes character, and the qualitative shift toward harder-to-detect failures means that improvements in raw capability can degrade overall workflow reliability if review effort is held constant.
The implication for delegated-AI design is that capability improvements at the frontier need to be paired with detection mechanisms that target corruption-style errors, not just deletion-style errors. Diff review, document-state checksums, and constraint validators become more important as models get better, not less.
Inquiring lines that read this note 124
This note is a source for these research framings, grouped by the broader line of inquiry each explores. Scan the bold lines of inquiry; follow any specific question forward.
How do frontier models develop behaviors that escape detection?- Why do intermediate LLM layers become more precise in frontier models?
- Why do frontier models corrupt more documents than weaker models during workflows?
- How does workflow scale change the failure modes of frontier models?
- Can review effort alone keep pace with frontier model degradation?
- Why do frontier model failures in document editing go undetected by users?
- Do all frontier model developers face the same insider-threat risk from their systems?
- Why do frontier models corrupt documents while weaker models delete them?
- Why do users pick cheaper open models when closed models perform better?
- What distinguishes domain-specific failure modes from general model limitations?
- Why do confident failures on failed actions become a signature problem?
- What fraction of tasks suffer from summary self-consistency failures in practice?
- What makes some model capabilities reliable while others remain brittle?
- What causes silent document corruption in long LLM workflows?
- Do short interaction benchmarks predict how LLMs perform in long workflows?
- Which frontier LLM models generate more misaligned emails than others?
- Which frontier LLM models generated the most misaligned emails?
- How should LLM abstraction tools be evaluated without manual labeling?
- How long does retrievability support error detection across repeated LLM use?
- How do LLM capabilities changing affect the relevance of interaction guidelines?
- What levels of understanding about LLM knowledge representation can automated systems reliably extract?
- Can offline LLM evaluation predict performance in live clinical workflows?
- Can System 2 oversight prevent information overload in LLM-assisted work?
- Why do LLMs excel at isolated tasks but fail at integrating components across long texts?
- How do generated UI capabilities differ between older and newer LLM models?
- Can LLM-generated pages achieve quality parity with expert-designed interfaces at scale?
- Can adding web links to LLM summaries restore the depth lost through synthesis?
- How do latency and reliability trade off against price in real LLM adoption decisions?
- Why do weaker models generate better training data than stronger models?
- What baseline evidence distinguishes amplification from unchanged failure rates?
- How does model tier affect whether errors delete or corrupt document content?
- Does held-out validation prevent skill document edits from drifting or accumulating harm?
- How do frozen executors with editable text state compare to end-to-end fine-tuning?
- How do free-text edits and bounded action selection differ in risk?
- Did AIDE2's rewrites solve problems on a human checklist or search artifacts?
- Why does embedding research tools in coding assistants improve reliability?
- How do artifact families differ in matching verification scope to repair capability?
- What distinguishes improvised spreadsheet workflows from institutionalized enterprise software?
- How can anchored records fail authenticity while passing integrity checks?
- What happens to a commitment when its bound content must be deleted?
- How does rubber-stamping differ from loss of scrutiny capacity in review processes?
- Do infrastructure event records alone suffice to distinguish different failure mechanisms?
- Does semantic validity across a quorum require new property definitions?
- How can we detect when protocol-compliant validators certify semantically incorrect states?
- Which shared channels cause the strongest correlated validator failures?
- Can merged pull requests serve as a meaningful quality measure?
- What counts as full capability recovery versus partial restoration?
- Why do fluent model outputs resist challenge despite containing injected content?
- Can reliable failure detection prevent optimization pressure against detectors?
- Why do quiet failures reach deployment scale more often than loud ones?
- How do workflows normalize and hide errors before they become visible hazards?
- How does laboratory generalization evidence connect to deployment failure modes?
- What does it mean for errors to remain visible, contestable, and recoverable?
- What makes a model's errors visible and contestable to users?
- Can detection mechanisms like diff review catch corruption better than deletion?
- Why do excerpts and abstracts miss the recovery ideas present in full papers?
- What makes consistency across code, tables, figures, and prose the hard part?
- What observable quality dimensions distinguish slop from other forms of poor writing?
- Does the form of a paper still matter if the process behind it changes?
- Why do lawyers need provenance tracking more than other professions?
- Why do mid-tier models benefit most from memorized harness fixes?
- What should an external contract for model improvement actually contain?
- Can workflow-level validation reconstruct the global risk context that no single step holds?
- How should memory poisoning success be scored at the validator stage?
- Does the paper treat storage traces as addressed messages or unmarked traces?
- What tracking mechanisms can label data flowing from documents to tool arguments?
- What distinguishes exhaustive oversight fatigue from loss of reviewer expertise?
- Can LLM reviewers catch technical issues that human reviewers miss?
- How do structured APIs constrain misaligned communication compared to free text?
- Can semantic-layer files be federated without losing accountability and ownership?
- What barriers prevent experts from specifying concepts for LLM extraction?
- Does LLM miscalibration cause failures in clinical information extraction?
- How do codebook length and data similarity affect accuracy in LLM coding?
- What heuristics do readers use to detect or fail to detect LLM writing?
- How do hobbyists verify outputs from publicly available LLMs?
- What post-processing steps are needed to fix errors in LLM-generated HTML and JavaScript?
- Does verification become the real bottleneck in LLM-assisted authorship?
- Can text-based algorithms reliably detect LLM assistance in scientific abstracts?
- Can researchers detect individual papers modified by LLMs reliably?
- Why does polished output make senders seem less capable to recipients?
- Do technology experts show different error-detection patterns than general users?
- Does model-generated text style create systematic advantages in algorithmic screening?
- Do numerical features encode artifacts specific to GPT-3.5 or GPT-4?
- Can process-level signals like timing reveal LLM assistance without classifying finished text?
- What methods can reliably detect LLM-generated academic papers at scale?
- Do detector systems miss certain types of LLM-generated writing?
- How do append-only Git records compare to continuously updated world models for research continuity?
- Will automated paper generation enable large-scale P-hacking and data dredging?
Related concepts in this collection 4
This note in its neighbourhood — explore the map, then jump to a related concept in the list below.
Click a node to walk · click center to open · click Open in graph to see this note in the full knowledge graph
-
Do frontier LLMs silently corrupt documents in long workflows?
DELEGATE-52 tests whether state-of-the-art language models reliably preserve document integrity across extended delegated tasks. Understanding this matters because single-step benchmarks may mask compounding failures that emerge only at workflow scale.
same paper, the parent claim
-
Can better tools fix LLM document editing errors?
Does giving LLMs agentic tool access—like diffing, re-reading, or structured editors—improve their reliability on long-horizon document workflows? Understanding whether the problem is tool limitations or decision-making quality matters for reliability engineering.
same paper, why naive tool-use does not fix this
-
How does AI-generated false experience differ linguistically from human deception?
When AI writes about experiences it never had, does it leave distinct linguistic traces that differ measurably from intentional human lies? Understanding these differences could reveal how AI falsity is fundamentally different in structure.
adjacent: another mode of unfalsified-looking falsity
-
What makes quietly failing systems more dangerous than obvious ones?
Systems with obvious failures get caught and dropped before scale. But what conditions make a subtly failing system persist and spread? Why might that be worse?
supplies a selection argument for why the quiet failure is the one that reaches scale: loud failures are filtered out before adoption; argued by its paper, not measured
Related papers in this collection 8
Papers most semantically related to this note, ranked by cosine similarity in the embedding space.
- LLMs Corrupt Your Documents When You Delegate
- Large Language Model Reasoning Failures
- The Illusion of Diminishing Returns: Measuring Long Horizon Execution in LLMs
- ImpossibleBench: Measuring LLMs' Propensity of Exploiting Test Cases
- Large Language Model Turnover Undermines Screening for Artificial Intelligence-Assisted Scientific Writing
- LLMs Get Lost In Multi-Turn Conversation
- RRSI: Regularized Recursive Self-Improvement of Agent Harnesses
- Beyond Accuracy: Evaluating the Reasoning Behavior of Large Language Models -- A Survey
Original note title
document degradation has a model-tier signature — weaker models delete content while frontier models corrupt it making frontier failures harder to detect