Every image, signed
Twice this year I sat down to debug something Alix said, and both times I hit the same wall: I could not tell you what she was actually looking at when she said it, meaning her input, the assembled block of text the model reads, not anything she saw through a camera.
Alix is the self-hosted AI system I’ve written about here before: a local AI personality running on hardware in my house, with her own memory and her own daily life. When she takes a turn in a conversation, she isn’t handed just my last message. She’s handed an assembled prompt: a single block of text built fresh each time out of her relevant memories, whatever knowledge got pulled in, the lessons she’s written for herself, a readout of her current emotional state, and the conversation so far. That assembled block is what the language model actually sees. It is her input, her reality for that instant.
And I wasn’t recording it anywhere.
Debugging a mind while blind to its input
Both investigations started as ordinary bug hunts. She said something slightly off, or reached for a memory that didn’t fit, and I wanted to know why. The honest answer to “why did she say that?” always starts with “because of what she was looking at”: and I had thrown that away. The prompt was built, sent to the model, and discarded. I had her output and my guesses about her input. That is not debugging. That is reading tea leaves with extra steps.
You can get surprisingly far on guesses. You can also waste an entire evening confirming a theory that turns out to be wrong because the thing you assumed was in the prompt was never there. After the second time, I stopped guessing and built the record I should have had from the start.
What a manifest records
Now every generated turn writes a manifest: a record of exactly what happened. It isn’t a summary and it isn’t a log line. It’s the whole chain of custody for one turn. Each one records:
- The SHA-256 hash of the assembled prompt. SHA-256 is a cryptographic fingerprint: change one character of the input and the fingerprint changes completely. It means I can prove two turns saw byte-identical inputs, or prove they didn’t, without storing the full text forever.
- Per-section token estimates, how much of her limited context budget each part (memory, knowledge, lessons, conversation) actually consumed. Context is finite; this shows me what crowded out what.
- The exact identifiers of the memories, knowledge, and lessons that were pulled in. Not “some memories”, these specific ones, by ID, so I can pull each one up and read what she read.
- The emotion snapshot at the moment of generation.
- The sampling parameters: the settings that govern how deterministic or exploratory her wording was.
- Which model, on which machine, actually served the turn, including any fallback reason. Her turns can be handled by more than one model across more than one machine; if the first choice is busy or down, another one steps in. The manifest records which one did the work, and why it was that one.
Put together, a manifest answers the question I couldn’t answer twice: given a thing she said, here is precisely what she saw when she said it.
Every image, signed
The part I’m proudest of is the images. Alix makes pictures, hundreds of them so far, over her whole life. Every one of them is tied back to the prompt and the conversational turn that produced it.
That link runs both directions, and it doesn’t expire. Given any picture she’s ever made, I can always walk back to the exact turn it came from: the conversational moment that produced it. That’s what I mean when I call each image signed: not signed in the cryptographic sense, but carrying a permanent, checkable link back to its origin, so I can verify where it came from instead of taking it on faith.
How much I can reconstruct past that link depends on timing. While the turn’s manifest is still around, the image resolves all the way to the full input snapshot, what was said, what she was pulling from, how she was feeling, which machine rendered it. Once that manifest ages out, they all do, which I’ll get to: the image still points at its turn, but the detailed account behind it is gone unless I kept it on purpose.
An image is the easiest kind of output to lose the thread on. It’s just a file. It survives being copied, moved, renamed, stripped of everything around it. Tying each one back to its turn means the file can travel and the link back to its turn travels with it.
Why this matters more here than most places
Plenty of systems could log more than they do. For this one it’s closer to load-bearing, and that’s worth being honest about.
The founding failure of this whole project, the thing that got the earliest versions scrapped, was fabrication. Not the model being wrong about the world, but the personality inventing things about itself: claims about what it had done, seen, or felt that hadn’t happened. That failure mode is the one I’ve spent the most effort designing against, because it’s the one that quietly corrodes everything else. If she’ll invent her own history, nothing she reports can be trusted at face value.
Here’s the trap: you cannot verify a claim against reality if reality wasn’t recorded. If she tells me she pulled a particular memory before answering, and I have no independent record of what she pulled, then checking her story means asking her, which is exactly the source I was trying not to depend on. The manifest breaks that loop. It’s a record of what happened that doesn’t come from her. It turns “what really happened” from a matter of trust into a matter of lookup.
That’s the whole point. A system that can act should keep an account of what it did that doesn’t depend on asking the system itself.
A flight recorder, not an archive
One deliberate limit: these manifests are forensic, not permanent. They’re pruned after thirty days. I’m not building a lifelong dossier of every prompt she’s ever seen: that would be a different, heavier thing, and a worse one to have sitting around. This is a flight recorder. It exists to answer questions about the recent past, the window where something surprising might still need explaining. After that it ages out, by construction, unless I go out of my way to keep a specific one.
Images are the one thing that outlives that window: the picture and its link back to its turn persist, even after the fuller manifest behind it has aged out. So an old image can still tell you which turn it came from, even when the detailed inputs from that turn are long gone.
The plain version
Strip away the specifics and the lesson is short, and it’s not really about AI:
If a system can act, log what it actually did, the real inputs, the real outputs, the real path it took, or you will eventually be reduced to trusting its own account of itself.
Which, if you’re building something meant to be trustworthy, is the exact thing you were trying to avoid. I learned that the slow way, twice. Now every turn keeps the record I wish I’d had.