Large Language Model (LLM) Editing Quietly Corrupts Documents. Here’s What the Research Says

Key Takeaways

The DELEGATE-52 study from Microsoft Research tested 19 LLMs on document editing tasks across 52 professional domains over 20 editing interactions.  Even top frontier LLMs at the time, including Gemini 3.1 Pro, Claude 4.6 Opus, and GPT 5.4, corrupted an average of 25 percent of document content by the end of long editing workflows.  Average degradation reached 50 percent across all 19 LLMs tested. Errors are sparse but severe: a small number of consequential changes that read as grammatically correct rather than many small typos.  Giving LLMs a basic agentic harness with file tools made performance slightly worse (roughly 6 percent more degradation) while consuming two to five times more input tokens.  Python was the only domain where most LLMs cleared the study’s 98 percent accuracy threshold. Even the best-performing model reached that bar in only 11 of the 52 domains tested. 

When large language models (LLMs) edit documents, they make a specific kind of mistake that can be more dangerous than a hallucination. It’s subtle enough to pass a casual review, damaging enough to matter, and systematic enough to compound across multiple editing sessions. 

A Microsoft Research study published on April 17, 2026, puts hard numbers on this. The findings should change how every content team thinks about where AI belongs in the editing workflow. 

What the Research Actually Found

Microsoft researchers built DELEGATE-52 to mimic how people use LLMs for document work. It didn’t focus on one-off edits, but long, multi-session workflows where an LLM handles a running sequence of revisions and refinements. 

The team gave 19 LLMs professional documents spanning 52 domains — including coding, crystallography, music notation, accounting records, and recipes — then asked them to complete 20 editing interactions. Those domains cover both highly structured formats (code, database schemas) and natural-language writing (fiction, email), and the corruption showed up in both, which is what makes the pattern relevant to the prose-heavy documents content teams produce. 

Frontier LLMs, the ones considered most capable, corrupted an average of 25 percent of document content by interaction 20. Non-frontier models performed worse, dragging the average for all 19 models to 50 percent. Python was the only domain where most models cleared the study’s 98 percent accuracy threshold. Even the best-performing model, Gemini 3.1 Pro, hit that bar in just 11 of the 52 domains tested. 

Source 

The specific error pattern is what makes this finding operationally important. The study calls the errors “sparse but severe”: the LLMs made a small number of high-impact mistakes rather than lots of little ones. In the kinds of documents content teams work with, those are the errors editors already worry about most: a statistic shifted by a digit, a clause dropped mid-sentence, or a name or attribution subtly altered. These errors read as grammatically correct, so a standard proofreading pass might miss them. Catching them takes a reviewer who knows what the original said. 

The agentic finding is equally significant. Wrapping the LLMs in a basic agentic harness with file tools (the kind of setup that’s supposed to make LLMs more capable) made performance roughly 6 percent worse on DELEGATE-52 while consuming two to five times more input tokens. The “agentic version will handle this” response to the findings does not hold up against the data. 

Why This Matters More for Long-Form Content

The error pattern described in DELEGATE-52 is most dangerous in the content types where a misattributed figure or altered claim does real reputational damage. Think white papers, pillar pages, executive thought leadership, client case studies, research reports, and legal or compliance documentation. 

These are precisely the formats where teams are most tempted to hand an LLM an entire document and ask it to “clean this up” or “polish this section.” The open-ended, multi-turn editing request is exactly the scenario DELEGATE-52 tested, and it’s exactly where these tools fail in ways that look fine on the surface. 

For short, tightly scoped edits, the risk is much lower. The corruption is cumulative rather than uniform. It builds up interaction by interaction, and compounds with document length. After 20 interactions, 1,000-token documents held at roughly 91 percent accuracy, while 10,000-token documents dropped to about 60 percent. 

A surgical edit to a specific paragraph, a defined claim, or a single section produces dramatically fewer errors than an open-ended “improve the whole document” instruction. The scope of the request and the size of the document directly determine the level of risk. 

Three Workflow Changes That Reduce the Risk

The research points toward three concrete shifts in how you should use LLMs in content production workflows. 

Use LLMs for surgical edits, not open-ended passes. LLM editing can be great for a specific paragraph, a defined claim, or a single section. Scoped requests are far safer than sweeping ones. The more latitude a model has to interpret what needs to change, the more opportunity it has to introduce subtle errors.  Weight human review toward the back half of the workflow. Current practice in most content teams treats the first draft as the high-scrutiny moment and later editing interactions as lower-stakes. The DELEGATE-52 findings reverse that logic. Errors compound silently from one turn to the next, so rounds two, three, and four carry more accumulated risk than round one. When researchers extended the test to 100 interactions, the degradation kept climbing, with no point at which the models stabilized. Review intensity should ramp up as a document accumulates LLM interactions, not wind down.  Add targeted QA checkpoints for the error types LLMs introduce. Standard proofreading catches typos, grammatical errors, and obvious factual claims. It may not catch a shifted number that reads correctly, a dropped clause that changes meaning without breaking grammar, or an attribution that’s been quietly changed. Any QA process for LLM-assisted content should hunt specifically in the danger zones: numbers, named attributions, data points, and quoted material. 

Where the Stakes Are Highest

In low-stakes content, this failure mode is survivable. A shifted phrase in a social post or a minor structural change in a blog draft is an inconvenience. In specific content categories, though, the same error pattern carries significantly higher consequences. 

Legal and compliance documentation is the clearest example. A dropped clause in a contract summary or an altered definition in a terms-of-service summary can create material legal exposure. Standard proofreading may not catch these errors, because they read as correct prose and slot neatly into the surrounding context. 

Client-facing research and attribution is another high-risk category. White papers, case studies, and thought leadership pieces that attribute specific statistics or quotes to clients or data sources carry reputational risk when even one of those attributions is off. A client who sees their name attached to a data point they did not provide, or a study whose findings have been slightly modified, faces a trust breakdown that is difficult to reverse. 

Executive and spokesperson content carries the same risk at a different level. LLM editing of speeches, op-eds, or public statements, iterated over multiple review rounds, can drift meaningfully from the executive’s original intent through a series of small changes that each seem harmless. That cumulative drift, measured over 10 to 20 editing interactions, is exactly what DELEGATE-52 quantified. 

For all these content types, the practical rule from the research is that the longer an LLM works on a document, the more scrutiny the final version requires. 

What This Does Not Mean

The research is not an argument for eliminating LLMs from content workflows. They deliver genuine value in research, drafting, structural suggestions, and early draft generation. AI adds value in content workflows where human judgment needs to stay in control, particularly when the raw material for the work comes from a human with real expertise and subject matter knowledge. 

The finding is specifically about delegated editing, which means handing a model a document and asking it to handle the revision process autonomously across multiple sessions. That specific use case is where the degradation pattern emerges. Keeping a human with genuine editing judgment in control of every revision decision, with LLMs as drafting and suggestion tools rather than autonomous editors, avoids the problem the research identifies. 

Remember that mistakes are not always visible in output. LLM-corrupted content looks fine. It passes grammar checks. It reads fluently. The damage only surfaces when someone who knows the original compares it directly against what the model produced. 

FAQs

Does this apply to all AI models or just older ones?

What kinds of errors does AI introduce most often?

Does giving AI access to tools (agentic use) improve accuracy?

Is there any domain where AI editing is reliable?

How should I change my content workflow based on this?

Conclusion

The DELEGATE-52 findings confirm what experienced content editors have observed informally: LLM editing in extended workflows introduces errors that standard review processes are not designed to catch. The research makes the scale of that risk quantifiable. 

An LLM should never be the final authority on a document. The risk is too high, and the errors are too subtle. There are real consequences for content that carries reputational weight. The right role for LLMs in content production is as a capable assistant with a human editor maintaining control of every consequential revision decision.