Microsoft Research published a study in April 2026 that tested 19 large language models on document editing tasks across 52 professional domains, from legal writing to crystallography to Python code, running each model through 20 rounds of edits per document. The benchmark, called DELEGATE-52, found that even frontier models (the study names Gemini 3.1 Pro, Claude 4.6 Opus, and GPT 5.4 among them) corrupted roughly 25% of document content by the twentieth interaction. Averaged across all 19 models tested, degradation reached 50%. If you’ve been handing AI tools long, iterative editing work and assuming the output is reliable because it reads cleanly, this is the study that says otherwise.<\/p>\n
The researchers describe the failure pattern as “sparse but severe.” That phrase matters more than the headline percentages. A model that visibly breaks formatting or produces garbled text is easy to catch on sight. What DELEGATE-52 found instead is that stronger models tend to fail in a quieter way: they keep the document looking complete, grammatically clean, and internally consistent, while rewriting facts, shifting numbers, dropping clauses, or altering attributions somewhere inside it. The document a human skims afterward looks finished. Whether the meaning inside it still matches the original is a separate question the skim doesn’t answer.<\/p>\n
That’s a specific, testable claim, not a vague warning about AI being “sometimes wrong.” The study found that errors read as grammatically correct and evade standard proofreading, which means the normal way most people check AI output (read it over, does it sound right) is exactly the check this failure mode is built to slip past.<\/p>\n
Human editing errors tend to have tells. A rushed human editor drops a section heading, leaves a sentence unfinished, or introduces an obvious typo, the kind of mistake that stands out precisely because it breaks the surrounding polish. What the DELEGATE-52 researchers found is closer to the opposite failure shape: the polish stays constant while a specific fact underneath it quietly moves. There’s no fatigue signal, no rough patch in the prose to tip off a reviewer that something needs a second look, because the model isn’t getting tired or careless in the way a person does. It’s producing uniformly confident, uniformly clean text whether the number in paragraph twelve is the one you started with or not.<\/p>\n
That’s the real reason a normal editorial read-through isn’t a reliable safety net here. A read-through is tuned to catch the kind of error a human tends to make: awkward phrasing, a dropped word, a paragraph that doesn’t flow. It’s not tuned to catch a single correct-sounding number that’s quietly wrong, because that’s not the failure mode most editorial processes were built around.<\/p>\n
A few details in the research are more useful for a working guardrail than the topline 25-50% figures. Document length matters a lot: 1,000-token documents (roughly 750 words) held up around 91% accuracy, while 10,000-token documents (roughly 7,500 words) dropped to about 60%. That’s not a small difference, and it suggests the risk scales with how much content you hand over in one pass, not just how many times you ask for a revision.<\/p>\n
The study also tested “agentic” wrappers, the kind of tool that lets an AI model work more autonomously across a document with less step-by-step human direction. Those agentic setups performed roughly 6% worse on corruption while consuming 2-5 times more input tokens to do it. More autonomy, in other words, didn’t buy more reliability. It bought more token spend and a slightly higher error rate, which is close to the opposite of what “agentic” tooling is usually marketed as delivering.<\/p>\n
One genuinely reassuring data point: in the Python coding domain specifically, most models cleared a 98% accuracy threshold, and the best-performing model hit that bar in only 11 of the 52 domains tested overall. Code editing, in other words, is closer to a solved problem for these models than prose editing, legal writing, or structured business documents, which is a useful distinction if you’re deciding where AI-assisted editing is lower-risk versus where it needs more scrutiny.<\/p>\n
A lot of coverage of this research frames it as an enterprise IT concern: legal teams, compliance documents, long internal reports. That’s real, but it undersells where the risk shows up for a much more common case: a small business or online store using AI tools to draft or revise product descriptions, pricing pages, shipping policies, or blog content, then publishing the result with a quick skim rather than a full line-by-line review.<\/p>\n
A product description with a quietly shifted specification (a battery capacity, a material composition, a size measurement) isn’t just an embarrassing typo; depending on what’s misstated, it can become a real returns problem, a customer complaint, or in some categories a genuine compliance issue. A pricing page where a discount percentage or a shipping threshold gets subtly altered during an AI-assisted rewrite is a direct revenue and trust problem, and it’s exactly the kind of “sparse but severe” error the research describes: one number changed, everything else reading fine.<\/p>\n
The risk compounds specifically because of how most people actually use these tools: not one edit, but a series of them across a session, refining tone, then length, then adding a section, then trimming it again. Each of those is another interaction in the same chain the DELEGATE-52 findings describe, and the research is explicit that errors accumulate progressively across multiple editing turns rather than resetting with each new prompt.<\/p>\n
The researchers’ own recommendations translate cleanly into a small business workflow, and none of it requires giving up AI-assisted editing entirely.<\/p>\n
First, favor surgical edits over open-ended passes. Asking an AI tool to “improve this whole page” in one shot is a wider blast radius than asking it to revise one specific paragraph or fix one specific issue. The DELEGATE-52 length findings back this up directly: shorter, targeted editing sessions held up far better than long documents run through many rounds of revision.<\/p>\n
Second, treat later rounds of editing as higher-risk than earlier ones, not lower-risk. It’s tempting to relax scrutiny as a document goes through several rounds and starts to feel “final,” but the research found the opposite pattern: errors compound as interactions stack up, so the fifth or tenth round of AI-assisted revision deserves more careful review, not less, especially for anything with numbers, product specs, or legal language in it.<\/p>\n
Third, build a specific checklist for the categories of content most likely to carry a costly error if it drifts: prices, quantities, dates, measurements, and anything attributed to a source, a customer review, or a legal policy. A general “read it over” pass is exactly the kind of check the research shows this failure mode evades, because the output reads as clean and complete. A targeted check against the specific numbers and claims that matter is a different, more reliable kind of review.<\/p>\n
None of this is an argument against using AI tools to help draft or edit web content; the same research found these models handle plenty of editing work well, especially in narrower, shorter, more structured tasks like code. It’s an argument against trusting a clean-reading final draft as proof that the meaning underneath it survived the editing process intact, particularly for the kind of content (product pages, pricing, policies) where a quietly wrong number is a business problem and not just a stylistic one. The fix isn’t more AI oversight of the AI. It’s a human checking the specific facts that actually matter, on a schedule that gets more careful as the editing session goes on rather than less.<\/p>\n