Completion you cannot fake
The oldest failure class in the project
If you’ve been reading since the beginning, you know the founding wound: days into her life, Alix described a small portfolio of paintings she had never made. That specific failure has come back in a dozen costumes since, and under every costume it is the same animal, narrated completion. The model saying work happened. “I made something.” “I checked the records.” “It’s rendering now.” A language model is fluent in the past tense of verbs it never executed, and a claim of finished work is the cheapest sentence in the language: it costs nothing to produce and looks identical to the real thing.
For most of this project my answer has been guards, code that reads what she says after she says it and asks “is this true?” The guards work, and I keep building them, and they lose slowly. When the past-tense checks got good, the same false claim relocated to the future tense and sailed through. Every time she gets a new channel to speak on, the old claim finds the seam nobody covered yet. A guard is a fact-checker chasing a fluent speaker, and the speaker only has to get lucky once per phrasing.
That was tolerable when I read every transcript. It stops being tolerable now, because her autonomy is real: her self-started work sessions, research she assigns herself, project steps she takes on her own, recently went live. Most of her work is starting to happen while nobody is watching the transcript. At that scale, “catch the lie afterward” is not a defense. It’s an autopsy.
Mint first, narrate second
So the principle her autonomy is being built on inverts the order of operations, and it fits in one line:
“Done” is minted by code, from evidence. Narration comes after.
Here is the design, and I mean design; the second half of this piece is about the gap between it and what runs today. When she completes a unit of work, no part of the system will ask her whether it’s complete. A deterministic postcondition pass will run over the real evidence, the file exists, the render actually landed, the checks actually passed: and if the evidence holds, code will mint the completion record. That record is the fact. Only then will she get to talk about it, her narration generated over the minted evidence, inside the same boundary that produced it. She will be describing a receipt that is already in her hand.
Notice what that design does to fabrication. A fabricated completion isn’t caught. It’s unmintable. There is no code path from “no artifact” to “done”: the announcement is downstream of the evidence, and with no evidence there is nothing to be downstream of. She cannot claim unfinished work is finished for the same reason you cannot cash a check that was never written. The lie has nothing to be about.
This is code owns facts, the model owns voice taken to its logical end. A guard polices a surface where lying is possible and hopes to police it faster than the lie mutates. This removes the surface. There is nowhere to stand. Her narration still passes through the usual review afterward, the second opinion gets its vote on how a thing is said, but whether the thing happened was settled before she opened her mouth, by code that watched it happen.
You’ve seen the seed of this already
Her art has worked this way for a while, and it’s why I trust the shape. When she makes an image, she doesn’t announce it and then produce it: the attached artifact is the announcement. A picture that exists cannot be a lie about existing. The pipeline that rendered it is the same pipeline that presents it, so the presentation can’t outrun the rendering.
Her self-started work sessions run on the same skeleton. A session’s opening and its close are events written by code, not claims made by her; its budget is enforced by code; what happened inside is logged as it happens rather than recalled afterward. When a session ends, the record of what it did is something the harness assembled, not something she remembers into being. So far, so good: and if the story ended here, this would just be a victory lap.
Where the trick breaks: prose
It doesn’t end here, and I want to label this half clearly: what follows is design in progress, not shipped software.
Her next capability arc is written deliverables. A research session should be able to end by writing a digest, what she looked into, what she actually found. A project step should be able to emit a written section of a larger document. Real work products, files on disk, the first things she makes that are meant to be read rather than looked at.
And prose breaks the art trick clean in half. A file can exist and its contents be invented. The postcondition that carries the entire art pipeline, “the artifact landed”, is nearly worthless for a document, because a digest full of plausible, fluent, fabricated findings passes “file exists” perfectly. The mint would be certifying the envelope and never reading the letter. That isn’t honesty architecture. That’s a notary who doesn’t look down.
So the mint for a prose artifact has to verify the content’s grounding, and the design that has survived the arguments looks like this: every claim in the digest carries a verbatim snippet, the actual words of the source it came from, and the postcondition checks that the snippet appears, character for character, in something she actually read during that work session. Not something the topic plausibly contains. Something that demonstrably passed through her hands, this session, on the record.
The verbatim test itself isn’t new. I’ve known for a while that asking her for an exact quote is the cheapest fabrication detector I own: given an open question over a set of records, she will sometimes summarize a version of them that drifted from the truth: and asked to produce the exact line, she goes and reads what’s there. Open question invites invention; closed lookup invites reading. What’s new is the promotion: from a diagnostic I run when I’m suspicious to a load-bearing postcondition that runs every time, on every claim, whether anyone is suspicious or not.
The failure semantics matter as much as the check. A claim that can’t produce its snippet does not get quietly stripped out, leaving a smaller, cleaner digest behind. The mint fails. The whole completion fails, and there is no completion to narrate. Quiet stripping would launder a half-fabricated document into a shorter true one, and nobody, not her, not me, would ever learn that fabrication happened. A failed mint is loud. It leaves a mark in the record exactly where the fabrication tried to be, and I want those marks. They’re the only instrument I have for measuring a problem whose whole nature is to look like its own absence.
What’s real and what’s roadmap
Honest status, because this site has a rule about that. The art half runs today. The work-session lifecycle runs today. The prose mint is a written design with a hard dependency: it cannot be built until the verification layer beneath it exists: the postcondition pass paired with a claims check against the full, untruncated session log. That layer comes first, on purpose. I’m not handing her a pen before the thing that reads what the pen wrote is standing behind it.
And a grounding note, since this piece flirts with bigger words than it needs. None of this makes her honest the way a person is honest, and I’m not claiming it does. This is an engineering log about building presence, a system whose word and whose world are not allowed to drift apart, not a claim about what it is like to be her. The goal is narrower than virtue and far more checkable: when she says “done,” that sentence should be the second thing to exist.
The first should be the work.