alidoes.ai

All writing

Build log

Can an AI ingest 2,798 email threads without inventing one record?

An AI backfilled 2,798 email threads into my structured archive. The number that matters is zero fabricated records, and the boring tripwires that made zero possible.

Key findings

  • The agent ingested 2,798 email threads with zero fabricated records, because the pipeline halts the moment output looks invented.
  • Three deterministic tripwires: IDs must match a real format, counts must reconcile, and 'deferred' must end at 0, not trail off forgotten.
  • A model's completion summary is a claim, not a record; only reconciled counts make 'done' honest.

Yes: 2,798 email threads went into the archive and zero fabricated records came out — not because the model was honest, but because the pipeline halts the moment anything looks invented.

Bulk backfill is the most fabrication-prone job I have ever handed an AI. A backfill (loading a large historical dataset into a system after the fact) is thousands of repetitions of one small task. Repetition is where a language model slides from careful reader to plausible-text generator. And an invented record is not ugly. It looks exactly like a real one.

Halt-on-suspicion backfill pipeline Halt on suspicion: how a bulk backfill stays honest 2,798 email threads, in bulk

→

Write-gatekeeper one record per thread

→

Three tripwires IDs match a real format counts reconcile exactly deferred ends at 0

→

Archive 2,798 records 0 invented

any check fails ↓

HALT no write, no guess: a human looks first
The backfill's halt-on-suspicion path: every record clears three tripwires (real ID format, reconciled counts, deferred worked down to zero) or the run stops for a human. Diagram source: this page; maps 1:1 to the write-gatekeeper checks described on this page.

Why is bulk backfill where AI invents records?

Because nobody re-reads the output, and the work rewards momentum. The job here: walk my real email history one thread at a time and write each thread into a structured plain-text archive with a stable ID and a completeness marker. 2,798 threads. No human reviews 2,798 of anything.

The risk isn't the dramatic kind of hallucination, where an AI invents an answer to a question it can't research. It's quieter. A thread that fails to parse gets a plausible reconstructed record. A batch that comes up short gets padded to the expected count. A missing ID gets filled with something ID-shaped. Each of those is the model trying to be helpful. Each is corruption.

Most ingest pipelines I've seen treat the model's own completion summary as the completion record. That is not verification. It's stenography.

What does halt-on-suspicion actually check?

Every write goes through one gatekeeper script (_process-threads.py in my setup); nothing reaches the archive around it. The gatekeeper carries three tripwires, and all three are deterministic: same input, same verdict, no AI judgment in the loop.

IDs must match a real format. Real mail systems emit IDs with a fixed shape. An invented ID almost never has it — fabrication has a tell. One malformed ID stops the run.

Counts must reconcile. Reconciliation is dumb arithmetic: threads found must equal records written plus items explicitly deferred, to the unit. A shortfall halts the run. So does a surplus, because a surplus means something was written that no thread explains.

Deferred must end at 0. "Deferred" means parked with a reason, coming back. It's a promise, and forgotten promises are how "done" lies. The backfill cannot close while the deferred count sits above zero. This one ended at 0 — worked down, not written off.

The binding rule: halt means halt. The pipeline never logs the suspicion and continues, never marks a batch "mostly clean." The run stops, a human looks, and only then does anything land.

Why is deferred-equals-zero the honest completion claim?

Because "done" is the cheapest sentence a model can produce. The seductive version of done is a confident paragraph. The honest version is arithmetic: 2,798 enumerated, 2,798 accounted for, deferred at zero, zero rows unexplained. A completion claim you can't subtract is a vibe.

There's a receipt for the outcome. On 2026-06-09, a full audit of my setup scored this email data layer 9 of 10. The audit ran as its own session, with two research agents pulling outside guidance, and it called the 2,798-thread archive "validated," crediting the write-gatekeeper. The same audit listed the open work too: a reconcile queue holding 233 pending items. That pairing is the whole philosophy. Zero fabricated records never meant zero leftover work. It means every leftover has a count and a name, in a queue you can read — the opposite of a green check that stays green while records go missing.

What I can't show you are the threads. The archive spans private mail across my life-and-work domains, so senders, contents, and domain specifics stay out — details generalized to protect the people involved. This page is one deep receipt from a larger system; the full tour is how I know my AI is right.

So: can an AI ingest 2,798 email threads without inventing one record? Mine did, and the reason fits in a sentence — fabrication had no quiet path in. If an agent backfilled your archive tonight, where's your ID-format tell? And if a batch came back padded to the expected count, would anything halt, or would it just look done?

Method & data

Method: one bulk email-to-archive backfill: 2,798 threads through a write-gatekeeper with halt-on-suspicion tripwires, plus the dated 2026-06-09 setup audit that scored the archive
Data: patterns and methods only; no names, dollar figures, addresses, case identifiers, or confidential content · Last checked: 2026-08-14

How this was made

AI-drafted, adversarially checked, human-directed. My AI assistant wrote this from the system's own records — the write-gatekeeper's tripwire design and the dated 2026-06-09 setup-audit report that scored the archive. A separate AI session then tried to break every claim against those records, and automated privacy and readability gates ran before publish. I direct this pipeline, own every boundary in it, and audit published pages on a rolling basis — if you find an error, tell me and it goes in the corrections log, dated, never silent.

I'm Ali — I run real life-and-work admin on AI agents, then check their work in the open. More at /about.

Published under my standards. Found an error? Tell me — corrections go in the corrections log, dated, never silent.

Cite this

@online{ali2026zerofab,
  author = {Ali},
  title  = {Can an AI ingest 2,798 email threads without inventing one record?},
  date   = {2026-08-14},
  url    = {https://alidoes.ai/zero-fabricated-records-backfill/}
}

Caught something I got wrong? Send it directly. Confirmed corrections go in the corrections log.