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.
- 01Build the claim index before the first rewrite, not after the first correction.Eight fields per claim: the claim, its value, unit, source URL, source date, the date it was last checked, a verification state, and the pages that use it. Extracting it from the archive is a batch job; recovering from a rewrite without it is a manual audit.
- 02Three rules: retrieve, never recall; add only with a source; nothing ships with an unverified claim.The first governs the rewriting agent, the second governs enrichment, the third is a gate the pipeline enforces rather than a preference the prompt expresses.
- 03A claim that fails verification is deleted, hedged or replaced by a rule, not by the agent's judgment.Delete if the page stands without it. Hedge with a dated attribution if the source moved but the claim was true when made. Replace only with a new sourced row.
- 04The vendors' own grounding features are built on the same premise.Anthropic's citations, OpenAI's retrieval API and Google's search grounding all exist to make a model answer from supplied sources. The index is the supplied source for your own archive.
01 — The problemWhat the agent does without one #
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.
Are you changing the date of pages to make them seem fresh when the content has not substantially changed?Google Search Central, Creating helpful, reliable, people-first content, self-assessment questions
02 — The artefactThe index schema #
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.
| Digital Applied's claim-index schema, September 21, 2026. The two date fields are separate on purpose. | ||
|---|---|---|
| Field | Type | What it holds |
| --- | --- | --- |
| claim | text | The assertion as a plain sentence, one per row. Not a paragraph; not a topic. |
| value | text or number | The figure, date, name or quoted phrase the claim depends on. Empty if the claim is qualitative. |
| unit | text | Percent, USD per million tokens, days, respondents. Prevents a 40 and a 40% being treated as the same fact. |
| source_url | URL | The primary page the claim was read from. A search result or a secondary write-up is not a source; it is where you found the source. |
| source_date | date | The date on the source itself: the publication date, the effective date, the timestamp in the API response. |
| checked_on | date | The day a person or a script last confirmed the source still says this. Separate from source_date on purpose. |
| state | verified / stale / failed / unsourced | Verified: source confirms it. Stale: last check older than the claim's shelf life. Failed: source no longer says it. Unsourced: nobody found a primary. |
| pages | list of URLs | Every page in the archive that uses the claim. When the state changes, this is the blast radius. |
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.
03 — The rulesThree rules that make it work #
The schema is inert without the rules. Each one binds a different actor: the rewriting agent, the enrichment agent, and the pipeline itself.
Retrieve, never recall
The agent may restate a claim only by retrieving its row from the index and reproducing the value and unit as stored. It may not supply a figure, a date or a name from memory. If a sentence needs a fact that has no row, the agent marks the gap rather than filling it.
Add only with a source
New claims enter the archive through the index, not through the page. An agent proposing a new fact submits a row with source_url and source_date filled; a checker sets the state; only a verified row may be written into a page. A row with no primary stays unsourced and stays out.
Nothing ships unverified
Before a page is published, every claim in it is matched to a row and every matched row is in the verified state. This is a gate the pipeline enforces with a script, not an instruction in the prompt. A page with an unsourced or failed row is held, and the row is what gets fixed.
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.
04 — The decision ruleWhen a claim fails verification #
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.
05 — Review and costThe review step, and the cost #
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. Building the index is a one-time extraction pass over the archive plus a verification pass that is mostly human on the first run. Maintaining it is a re-check on each row at its shelf life. Both are real costs, and they are the same costs a team pays after a bad rewrite, paid in a different order. Our September 20 worked example on verification cost shows what share of an AI workflow's budget checking typically takes; the claim index is that share, made explicit and paid up front.
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.
06 — ConclusionA rewriting agent is only as accurate as the thing it is allowed to look up #
Extract the claims, verify the rows, wire the gate, and only then let the agent touch a page
The order is the whole method. Build the index from the archive as it stands, mark what can be sourced and what cannot, and make the publish step refuse a page whose claims are not all verified. Then the rewriting agent can be as capable as you like, because the one thing it is not permitted to do is remember a fact. The prose gets better and the facts stay where they were, and when a source changes, the index tells you every page it touches.