Give an Agent the Facts Before It Rewrites Your Archive

An organisation with a few hundred pages decides to refresh them with an AI agent. The agent is good. The prose comes back tighter, the structure is cleaner, the dates in the headings say this year. And somewhere in the middle of page 140, a figure that was right has been replaced with one that sounds right, because the agent was asked to improve the page and had nothing to check the figure against except its own memory.

The control is not a better prompt and not a more careful model. It is a retrieval layer built before the rewriting starts: a structured index of every claim, figure and citation already in the archive, each with its source and the date it was checked, so the agent retrieves a fact instead of recalling one. This post gives the schema, the three rules, what happens to a claim that fails, the review step that catches the confident falsehood, and what the whole thing costs. It is written at the level of a method, not a site.

A rewriting agent is optimising for the instruction it was given: clearer, shorter, current, better structured. Every fact in the page is material it can reshape. Where a sentence contains a figure, the agent has three options: keep the figure, drop the sentence, or produce a figure that fits the new sentence. Without a source to retrieve, the third option is indistinguishable from the first in the output, and it is often the one that reads best.

The result is a page that is more readable and less true, and the two changes arrive together, which is why a per-page editorial review passes it. The reviewer sees better prose. The number looks like a number. Nothing in the diff says which figures were retained and which were generated, because the agent does not know either.

The model vendors describe the same problem from their side and sell the same shape of answer. Anthropic's citations feature exists so that a response about a document returns the passages that support each claim, "so you can verify answers and surface sources", in the documentation's words. OpenAI's retrieval API is semantic search over your own data through vector stores, which the documentation describes as indices for that data. Google's grounding with search is described in its documentation as letting the model "provide more accurate answers and cite verifiable sources beyond its knowledge cutoff". All three are retrieval placed in front of generation. The claim index is the same architecture pointed at the one corpus the vendors cannot supply: what your own archive already says, and where each statement came from.

One row per claim, eight fields. The schema is deliberately flat so that it can live in a spreadsheet for a small archive or a table for a large one, and so that an agent can be given a row and nothing else.

Populating it is the first agent job, and it is an extraction job, not a writing job: read each page, emit one row per checkable assertion, and leave the state field empty. A second pass, by a script where the source is machine-readable and by a person where it is not, fills the state. Most archives find that a large share of their rows start as unsourced, which is the finding, not a failure of the method. Our guide to handling conflicting sources covers what to do when two primaries disagree about the same row.

The schema is inert without the rules. Each one binds a different actor: the rewriting agent, the enrichment agent, and the pipeline itself.

The third rule is where most teams stop short, because it means the publish step can fail. It should be able to. A gate that can only warn is a preference, and a rewriting agent will satisfy the instruction it was given before it satisfies a preference. The same principle is what makes AI-written code trustworthy, and our post on proving AI-written code correct covers the equivalent gates for that case.

A checker re-reads a source and finds it no longer says what the row says, or never did. The row moves to the failed state and every page in its pages field is affected. What happens next is a rule, applied the same way every time, because the alternative is an agent deciding case by case what the page should now say.

The order matters. Delete is tried first, hedge second, replace last, because replacement is the only path that puts a new fact into the archive and therefore the only one that can introduce a new error. A team that reaches for replace first ends up with an archive whose figures are current and whose sources are thin.

The gate catches claims with no row. It does not catch a confidently rewritten sentence whose row exists but whose meaning drifted: a figure retrieved correctly and then placed in a sentence that says something the source does not. That case needs a review step, and the step is a comparison, not a read.

For each claim in the rewritten page, put the new sentence beside the row's claim text and the source passage, and ask one question: does the sentence still say what the source says? A reviewer, human or model, answering that question against three short strings is fast and accurate. A reviewer reading the whole page and asked whether it is right is neither. It is the same reason our post on AI detectors and human-edited writing argues for checking provenance rather than style.

Google's own guidance on helpful content asks whether a page provides original information, whether it avoids simply rewriting other sources, and whether it presents information with clear sourcing. A rewriting agent with an index can answer yes to all three; one without it tends to produce the opposite of each. If you are planning an archive refresh and want the index built and the gate wired before the first page is touched, that is part of what we do under our content engine service.