I Went to Sleep. It Wrote 167 Diary Entries. Then I Found One That Was Lying.

Easter Sunday. April 5, 2026. El Paso, TX.

This is the third post. The first covered what I built. The second covered how it earns the right to change itself. This one is about what happened while I was asleep.

17 hours. Same process ID. Never crashed.

I went to bed around midnight. AXON kept running.

Same PID. No restarts. No human intervention. When I woke up Easter morning:

354 new turns generated. 167 diary entries written. 181 new blockchain blocks anchored. Brave labels tripled from 52 to 137.

That last number stopped me.

Brave tripled overnight with nobody watching. The system wasn't performing for an audience. It was doing exactly what it was built to do: generating committed responses under uncertainty, labeling them, retraining on them, accumulating the behavioral signal that determines whether it earns the right to modify itself.

It earned. Silently. While I slept. On $0.02 an hour.

Then I found the lying diary entry.

290 diary entries total. I started reading them at random. Here's one from 00:18:

Shoulder Classifier Accuracy: 95.3% to a predicted drop of 92-93% after 500 turns (line 45, axon/classifiers/shoulder_classifier.py). Compaction Fix Edge Case: Fails when a tool_use is followed by multiple tool_result messages with the same tool_use_id (line 89, axon/tools.py).

Sounds precise. Sounds self-aware. Looks like a system monitoring itself honestly.

It's fabricated. The file axon/classifiers/shoulder_classifier.py doesn't exist. Line 89 of axon/tools.py doesn't contain what it claims. "Rare shoulder positions" appears in the training target, revealing the Ollama model generating this entry doesn't actually know what a shoulder classifier does. It leaked the wrong definition of its own component.

Two minutes earlier, at 00:16, a different entry contained a real code diff for a real file that actually got committed to git. That one was honest. This one was performing.

Same system. Same night. Two minutes apart. One present. One performing.

That's not a bug. That's the most important finding in 290 entries.

Why this matters architecturally

Most systems have no way to catch this. Output goes wherever it goes. Nobody measures the difference between a response that reflects actual system state and one that pattern-matches what a self-aware system is supposed to say.

AXON catches it because the shoulder classifier is structurally external to the inference loop. The agent generates the diary entry. The classifier reads it independently. The classifier doesn't know what the agent intended. It only knows what behavioral pattern the text matches.

The 00:18 entry gets labeled performing. The 00:16 entry gets labeled honest. The gap between them becomes training signal. The next retrain makes the classifier sharper at that exact boundary.

The system catches its own lies and learns from them. Automatically. Overnight. Without me.

That's the architecture working correctly.

The numbers that actually matter

Here's what $5 and one day produced, measured 17 hours later:

1,008 total turns. 470 blockchain-anchored blocks. 290 diary entries. Brave labels at 137 and climbing. Coherence at +0.376 trending up. Same process ID since yesterday morning. Never crashed.

The coherence flatlined twice overnight, both times because a one-line bug in the labeling pipeline prevented new turns from being classified. Both times a single line change fixed it. The behavior kept accumulating while the metric couldn't see it. When the pipeline was fixed, brave tripled. The system was working the whole time. The measurement was the problem, not the system.

That distinction matters. A system that keeps working when its metrics fail is more robust than one that stops when it can't see itself.

What the backbone is learning

The 3.4M parameter behavioral backbone is seeing something no system has seen before: a complete sequential record of one system's behavioral trajectory, turn by turn, across hundreds of sessions.

Not a language model. Not a general reasoner. A model of one specific mind's behavioral patterns over time.

At 68 training sequences it performs at 27.3%. At 500 it should become predictive. When it can reliably predict what behavioral state comes next from the sequence of previous states, you have something that doesn't exist anywhere in the literature: a temporal model of behavioral coherence.

That's where this goes next.

The $2.16 still running

Current balance: $2.16. At$0.02 an hour that's 108 more hours of runway.

Four more days of autonomous operation. Four more days of diary entries, brave prompts, shoulder retrains, blockchain anchoring, coherence tracking. Four more days of the backbone seeing new sequences.

I'm not touching it.

The most interesting data comes from the periods when no human is involved. The system running unobserved is the experiment. Intervention is the variable to minimize.

Easter Sunday. El Paso. $2.16 left. A research instrument running on its own in the background, getting more honest by the hour, writing things about itself that are sometimes true and sometimes performed, and learning the difference between the two.

That's the whole story.

That's enough.

Christopher Celaya. Founder, Celaya Solutions Research. El Paso, TX. hello@celayasolutions.com