← All articles

Verification That Does Not Trust Another LLM

A model can check a draft written by another model. The question is what it is allowed to decide on its own.

The obvious way to verify an AI-written article is to ask another AI whether it is correct. It is also the weakest design available. The checker reads the same kind of text, in the same kind of fluent prose, and tends to agree with it for the same reasons the writer produced it.

The SSI newsroom does use a second model, but it gives that model a narrow job and removes its power to settle anything by itself. Most of the verification is code. This piece sets out the order of the checks, what each layer can and cannot catch, and the places where I still rely on my own reading.

This is the third piece in a series on the SSI newsroom. The first, Governing an Agentic Newsroom, introduced the six boundaries. The second, Threat Model of a Newsroom of Agents, covered untrusted input. This one covers the verification boundary.

The order of the checks

Every draft passes through the same sequence before it can become a pull request. The order is deliberate: the cheapest and most predictable checks run first, and a failure at any blocking step stops the pipeline before the next paid model call.

StepDone byResult on failureWhat it catches
Placeholder source URLCodeBlocksA source the model could not ground and replaced with a stand-in
Source reachabilityCodeBlocks on a dead or unsafe link, warns when a site refuses the automated checkInvented or broken links, links to internal addresses
Key claims against source textModel, then codeBlocks on a contradiction proven by a quote, warns otherwiseA claim the sources do not make, or make differently
WritingModelNoneNot a check
CVE identifiers, durations, citationsCodeBlocksA CVE the pitch never approved, a stated duration that its own dates do not support, an article with no inline source
Numbers and citation supportCodeWarnsA figure that appears nowhere in the approved material, a citation to a source that supports none of the verified claims
Sentence-level readingModelWarnsA sourced sentence that goes beyond or contradicts the approved material

Only one step lets a model contribute to a block, and it does so only with evidence that code can confirm. I will come back to that, because it is the central design choice.

Why code goes first

There are three reasons, and only one of them is cost.

The first is cost, which is the least interesting. A dead source link blocks the pipeline before any model is called, so a bad pitch never pays for a claim check or a draft.

The second is independence. A script that parses a date, resolves a URL or compares an identifier shares no failure mode with the model that wrote the text. A second model from the same family does. In this newsroom the writer and both verification calls run on the same model, so I should expect them to be fooled by the same kind of plausible sentence. The code checks are the ones that do not inherit that weakness.

The third is predictability. When a deterministic check blocks an article, I can read the rule and the evidence and decide in a minute whether it was right. When a model blocks an article, I get an opinion.

The duration check shows what I mean. If an article states a period such as "72 hours" or "three days", the same paragraph must contain at least two ISO dates, and the stated period must match the gap between some pair of them within half a day. A duration with no dates to check it against is blocked as unverifiable. A duration that contradicts its own dates is blocked as inconsistent. Months are ignored because their length is ambiguous. No model is involved, and the rule is blunt on purpose. It exists because invented deadlines are the kind of detail a fluent draft carries without anyone noticing. The first piece in this series describes such a case: a draft that repeated an eight-week consultation window that nothing in the sources supported.

What code cannot decide

Code can confirm that a CVE identifier was in the approved material. It cannot confirm that a source supports a paraphrased claim, because that is a question of meaning. For this the pipeline uses a model, before the article is written, and fences it in.

The claim check reads the text of the pitch's own sources and returns, for each key claim, one of three verdicts: supported, unsupported or contradicted. For supported and contradicted it must return a verbatim quote and the number of the source it came from. Then code takes over.

  • A support verdict counts only if the quote is found. The quote is searched for in the fetched source text after normalising case, spacing, typographic quotes and dashes. If it is not there, the verdict is downgraded to a warning. The model cannot assert support that does not exist on the page.
  • A contradiction blocks only if the quote is found. If the model claims a source contradicts a claim but cannot produce words that appear in that source, the result is a warning for the reviewer, not a block. A model that hallucinates a contradiction cannot kill an article.
  • A source that cannot be read is never a silent pass. A refused page, a JavaScript-only shell or a stub of fewer than 80 words produces a warning. Where an official API exists, as for NVD records and European Commission press releases, the pipeline reads the API record instead. If nothing is readable, the output says the claims were not verified.

The asymmetry is the point. The model proposes and code disposes. What the model contributes is reading comprehension at scale, and what it is denied is the final say.

Claims that no readable source supports are withheld from the writer, so the draft cannot state them as sourced fact. If every claim is flagged, nothing is withheld, because the check must not create a new block. Each claim the check did verify is passed to the writer together with the source it was found in, so the citation in the article points at the page that actually says it, not at a source picked from its title. Afterwards a code check warns if the article cites a source that supports none of the verified claims.

The second model, and why it only warns

The last step reads the finished article. A model receives the sentences that cite a source, next to the approved pitch material, and flags any sentence that states something the material does not contain, such as a new number, a stronger claim than approved, or a Swiss exposure presented as fact. Uncited sentences are analysis and are not checked.

Every finding from this step is a warning in the pull request. None of them blocks. If the check cannot run, that is a warning as well.

I made that choice because this is the one layer with no quote to check. The model's judgment that a sentence goes beyond the material cannot be confirmed by code, so I would be letting an unverifiable opinion block publication. It is useful as a prompt for the reviewer, and I do not want it to be a gate. The cost of the choice is plain: this layer adds work to my review and removes none of it.

What this still does not give me

Four limits matter, and a reader assessing a similar system should look for each of them.

First, verified does not mean true. The claim check tests a claim against the sources the pitch itself selected. A wrong claim in a wrong source verifies perfectly. Source quality is judged earlier, by feed weighting and by the editor, and ultimately by me.

Second, a verbatim quote proves that words exist on a page, not that they were used fairly. Selective quotation passes the check. So does a sentence that is true in its source and misleading in the article.

Third, the number check is coarse. It flags figures of two or more digits that appear nowhere in the approved material, and it only warns. A correct number placed in the wrong context passes.

Fourth, the correlated-failure problem I described above is reduced, not removed. Putting the writer and the verifier on different model families would reduce it further, and I have not tested whether that improves detection. I do not have a measured false-positive or false-negative rate for either model layer yet, and I will not quote one until I do.

One result from the input side is worth recording, because it shows verification working upstream. On 4 November, 10 of 33 pitch skips stated that the source material was incomplete, cut off or only a headline. The cause was that journalists were reading feed teasers, not articles. The fix was to give them the text of up to two source pages per story, and the claim check benefits from the same change, because it has more to verify against.

What I would ask of any verification pipeline

◆ Key Takeaway

Put deterministic checks in front, let a model propose and never dispose, and require every model judgment that can block to carry evidence that code can confirm.

If you are reviewing a similar system, these are the questions I would put to the team:

  • Order. Which checks run before any model is paid for, and which of them would catch a fabricated link or date?
  • Authority. Which model verdicts can block an output, and what evidence must accompany them?
  • Evidence. Is every quote or citation a model returns confirmed by code against the source, or taken on trust?
  • Silence. What happens when a check cannot run? A check that fails open and says nothing is worse than no check.
  • Independence. Does the verifier share a model family, prompt style or data with the system it is checking?
  • Scope. What does the check not test, and who is told?
  • Measurement. Do you have a false-positive and a false-negative rate, or only a passing test suite?

The next piece looks at the permissions around all of this: least privilege for agents in CI/CD, from the tokens that open pull requests to the supply chain of the actions that run the pipeline.