You Cannot Prove an AI Is Neutral. You Can Prove Nobody Removed the Checks.

"Build a neutral AI journalist" is a request with a trap inside it. You cannot prove an LLM is neutral. It is not deterministic, "neutral" is itself contested, and any claim that a model is unbiased is unfalsifiable hand-waving. So I stopped trying to prove the output and started proving the process.

The Neutral Wire is an autonomous journalism pipeline with one unusual property: it can publish a cryptographic receipt proving that the exact neutrality checks it claims to run actually ran, on the exact code that was deployed. Not that the article is true. That nobody quietly deleted the bias checks before shipping.

The pipeline

Eight stages, each one inspectable:

Ingest, cluster, generate, evaluate, calibrate, gate, attest, publish.

It ingests from eight politically diverse outlets (NPR, The Guardian, Reuters, the Associated Press, BBC News, the Wall Street Journal, The Economist, and Fox News), clusters articles by topic, and enforces minimum source coverage, optionally requiring both left- and right-leaning outlets before it will write anything. Then an LLM synthesises a single neutral article from the clustered sources.

Scoring bias on six axes

A neutral-sounding draft is not the end. A separate evaluator call scores every draft on six dimensions:

Overall slant: left or right lean
Loaded language: emotional or partisan wording
Omission risk: missing facts or perspectives
Source balance: representation proportional to the evidence
Consensus preservation: whether it keeps real expert consensus instead of flattening it into a false debate
Attribution: whether disputed claims stay tied to their sources instead of being laundered into the narrator's voice

The last two are the ones I am proudest of. "Both sides" framing and consensus-flattening are the subtle failures of automated neutrality, and they do not show up if you only check for angry adjectives.

The calibration loop

If a draft fails the multi-dimensional gate, the evaluator's scores and reasoning are fed back to the writer for a targeted rewrite. The loop runs up to three rounds. If it still fails, the gate blocks publication outright. The agent would rather publish nothing than publish something slanted.

The trust chain

Here is the actual idea. The verifiability is about code integrity, not output determinism:

The code enforces neutrality through prompts, the evaluator, the calibration loop, sourcing rules, and the publish gate.
An EigenCompute TEE (trusted execution environment) proves that the exact Docker image is running, unmodified.
An attestation contract logs a per-article receipt on-chain: hashes of the article, the source set, the evaluator output, and the prompts, plus the number of calibration rounds.
Anyone can verify that the deployed agent really ran the pipeline it claims to run.

You do not need to prove the model produced the same words twice. You need to prove that no one secretly removed the neutrality checks before deployment. That is a question cryptography can actually answer.

What is honestly unfinished

86 of 89 tests pass. Three behavioural cases still fail, and the behavioural tests are the ones that matter most here, so I am not calling this done. The TEE proofs run in the local and daemon paths, but the production EigenCloud deployment is not live yet. Until it is, "verifiable" describes a design that works in testing, not something you can independently check on a public chain today.

Why this matters

The debate about AI and misinformation is stuck on an unwinnable question: is the model biased? I think the useful question is narrower and answerable: can you prove the safeguards a system claims to have are the safeguards that actually ran? That generalises well beyond journalism, to any agent whose operator says "trust me, the checks are on". Make them prove it.

Ongoing. Next: the three failing behavioural cases, and a production TEE deployment so the receipts are publicly verifiable.