The archive never argues from itself

In July 2024, a paper in Nature gave a name to something practitioners had been circling for a while. Train a generative model on data produced by generative models, repeat the cycle, and the model degrades in a characteristic way: rare cases vanish first, variety collapses toward a bland center, and eventually the outputs are confidently useless. The authors called it model collapse, and their sharpest finding was about prevention: the loop stays healthy only when fresh human data keeps entering it. Left to consume its own outputs, the system does not plateau. It decays.

That result is usually discussed as a problem for the companies training frontier models on an internet that increasingly contains their own exhaust. It is that. But the mechanism is more general than training, and it is worth stating plainly: any system that feeds its outputs back in as inputs will compound its errors unless something governs the loop. You do not need a training run. A memory feature is enough.

The small version of the loop

DocuStrata remembers its own answers. When the product gives you a grounded, cited answer, that answer is saved into your archive, so that in September you can find what you asked in March the same way you find any document. Memory that accumulates is a large part of what makes an archive more useful in month six than in week one.

It is also, structurally, the exact loop the collapse research describes, at retrieval scale instead of training scale. A saved answer is a machine output sitting in the same corpus as your contracts and statements. If a future question retrieves it, the system is now reading its own writing. If that future answer is saved too, generation two derives from generation one. Nothing about this is hypothetical for us, because we watched it happen.

This month, in an archive holding several legal matters with an overlapping cast of people, an answer about one deal wrongly pulled in material from another. Wrong, but ordinary: retrieval selects by resemblance, and two disputes involving the same names resemble each other. What happened next is the interesting part. The blended answer was saved to memory, titled after the deal it was asked about. The next ask retrieved it, on its title, and blended again. Within an hour there were five saved answers, each citing the ones before it, each more confident than the last. The final answer in the chain cited nothing but earlier answers. The error was no longer a mistake. It was an inheritance.

That incident cost us an afternoon and taught us more than most quarters do. The fixes it forced are now how the product works, and they reduce to a single rule.

Derived material never re-enters the evidence class ungoverned

Everything below is a mechanism enforcing that one sentence.

Provenance is typed at the moment of writing. Every artifact in the archive is permanently marked as primary (something you added) or derived (something the system produced). A saved answer says what it is, carries its date, and names the sources it drew from. A system that cannot tell its own outputs from its inputs cannot be governed at all; this labeling is the precondition for every other control.

Reading privileges are asymmetric. Derived material may help you recall what was discussed. It may not serve as evidence. When a question names a specific matter, the context assembled for the model is primary sources only: saved answers are excluded even when their titles match, because a matching title on derived material is precisely how contamination re-enters. The primary documents contain everything a clean past answer would, without the recursion.

Memory stores generation one, and nothing deeper. An answer that cites a past answer is a derivative of a derivative. You still see it, since it may be a perfectly good reply to what you asked, but it is never saved. Stored memory therefore only ever contains answers derived directly from primary documents. This is the retrieval-layer equivalent of the fresh-data requirement in the training literature: every generation in the store traces to human material in one step.

You hold a brake. Any answer that was saved to memory carries a control to remove it. Marking an answer wrong does two things at once: it registers your judgment, and it deletes the derived record, so the wrong answer stops informing future ones the moment you say so. The answer itself stays visible in your conversation, because what was said is history. What is remembered is corrigible.

The loop is measured. A daily job tracks how often answers cite saved answers, and separately verifies an invariant: no stored memory record may derive from derived material. The first number is a health trend. The second must be zero, and if it ever is not, the engineering alarm goes off before a user notices anything.

Why keep memory at all

The severe response to the collapse problem would be to never save answers. It would also throw away the thing that makes a long-lived archive compound in value: the questions you have already asked are part of your record, and finding them again is real work the product should do. Compounding is symmetric. The same accumulation that lets errors inherit is what lets knowledge accrue. The difference between the two outcomes is not the memory. It is whether the loop is governed.

That is also why this belongs in public writing rather than in a changelog. Products in this category are all going to add memory, because memory is what users want. Few have yet confronted what memory does to their evidence base, mostly because few have run long enough, on serious corpora, to watch an answer cite itself. When yours does, the question that will matter is not whether the model is good. It is whether the system can tell what it wrote from what it read.

Ours can. The archive remembers, and the archive never argues from itself.