In April 2025 Ahrefs looked at 900,000 newly created English-language web pages and checked what made them.

74.2 percent contained AI-generated content. Only 25.8 percent were purely human. The largest group by far, 71.7 percent, was a mixture of the two.

That is the corpus. Not a forecast about the corpus. That is what was published, in one month, on the open web that every model is trained on.

Which raises a question that sounded theoretical two years ago and does not now. What happens to a model trained on the output of models?

Collapse is not what it sounds like

The phrase is model collapse, and it comes from work by Ilia Shumailov and colleagues in 2023.

The failure mode is not gibberish. It is quieter than that. Their finding is that using model-generated content in training causes irreversible defects, and specifically that the tails of the original content distribution disappear.

Read that carefully. Not the middle. The tails.

A model trained on its own descendants keeps producing fluent, plausible, average output. What it loses is the rare case. The unusual phrasing, the edge condition, the thing that happened twice. It becomes more confident about the common and quietly ignorant of the exceptional, and the two are indistinguishable in any test built from common examples.

They found it across model families, not just language models. Variational autoencoders and Gaussian mixture models degrade the same way, which suggests this is a property of the feedback loop rather than of any architecture.

That generality is the part that should register. If it were a quirk of one model type it would be an engineering bug for one vendor to fix. Appearing in three unrelated families makes it a property of learning from your own output.

The tails are the part you were paying for

For an enterprise this is precisely the wrong thing to lose.

Nobody needs help with the invoice that matches the purchase order. That case is already automated, or trivially automatable, and it was never expensive. The cost sits in the 3 percent that arrives with a missing line, a currency mismatch, a vendor that changed its bank details, a contract clause nobody has seen before.

Those are the tails. They are what makes a process expensive and what makes automation valuable, and they are the first thing a recursively trained model forgets.

Put numbers on it. If 97 percent of your invoices are routine and 3 percent are not, the 3 percent can absorb most of the labour and nearly all of the risk. A model that improves from 98 to 99 percent on the routine 97 has moved almost nothing. A model that degrades on the 3 has moved everything, and the headline accuracy figure will barely twitch either way.

So the trajectory is a system that gets better at the work you did not need help with, while getting worse at the work you bought it for, and reporting improved average accuracy throughout.

The finding that is not doom

The alarming version of this circulated widely and the correction did not, which is worth fixing.

In 2024 Matthias Gerstgrasser and colleagues examined whether collapse is inevitable. Their answer is no, and the condition is specific. Collapse happens when each generation of synthetic data replaces the real data. If instead the synthetic data accumulates alongside the original real data, the test error has a finite upper bound independent of the number of iterations, and collapse does not occur.

That is a design instruction, not a prophecy. The failure is not caused by synthetic data existing. It is caused by throwing the real data away.

Two regimes, then. Replace and degrade without limit. Accumulate and degrade to a bound. The difference is a retention policy.

Where this bites inside a company

The public web is somebody else's problem. Your own corpus is not.

Consider what your organization has been writing since 2023. Support tickets summarized by a model. Meeting notes generated from transcripts. Draft policies expanded from bullets. Product descriptions, incident reports, first drafts of everything.

Now consider what your retrieval systems point at. Most enterprise AI reads internal documents, and a rising share of those documents were written by an earlier model, often summarizing a document that was itself generated.

That is the same recursion, running inside one company, with no external real-data reservoir to accumulate against. The difference is that on the open web the effect is diluted across the whole internet. In a single organization the loop is tight and the corpus is small.

A company with 40,000 documents and three years of assisted writing is a much faster feedback loop than a web with billions of pages and 25.8 percent of new ones still purely human.

Provenance becomes a data engineering requirement

The practical consequence is unglamorous and specific. You have to know which of your documents a human wrote.

That means labelling at the moment of creation, because it cannot be recovered later with any reliability. Detection tools for this are weak, and they get weaker as models improve. A field on the record saying human, assisted or generated is worth more than any classifier you could buy afterward.

It is also nearly free at the point of creation and nearly impossible later. One boolean, written once, against a retrospective classification project that will never be accurate. The 74.2 percent figure exists because researchers had to infer provenance rather than read it.

It also means never overwriting. Keep the human-authored corpus as a durable set rather than letting generated summaries supersede the originals. That is exactly the accumulate-rather-than-replace condition, applied to a document store instead of a training run.

And it means resisting the tidy instinct. Deduplicating a knowledge base by keeping the cleanest version of each document will systematically prefer the generated one, because generated text is cleaner. The cleaning step is the collapse mechanism.

That one is worth flagging to whoever runs your content operations, because it looks like housekeeping. Consolidating six overlapping documents into one good one is normally a service to everybody. Here it quietly deletes five records of how humans actually described the problem.

What to ask a vendor

This gives you one useful procurement question that most vendors have not rehearsed.

What is the provenance of your training data, and how do you prevent your own outputs from re-entering it? A serious answer describes retention of original sources and a separation between generated and collected data. An unserious answer talks about data volume.

Ask the same question about their evaluation set. A benchmark built from generated examples measures fluency on the middle of the distribution, which is the thing that survives collapse.

Neither question is hostile. Both have good answers available, and a vendor who has thought about this will be pleased to be asked.

The test to run this week

Take your most-used internal knowledge base. Sample 20 documents that your AI systems retrieve from most often.

For each, answer one question. Did a person write this, or did a model produce it from something else?

If you cannot tell, that is the finding. You are running retrieval over a corpus of unknown provenance, and every generation of summarizing makes it thinner at exactly the edges where your hard cases live.

Then ask the question that follows. Of the documents that were generated, is the human original still stored anywhere, or did the summary replace it?

If the originals are gone, you have already run the replace regime on your own corpus. There is no way to recover the tails, which is what irreversible means in the original paper.

Sources