01 · Hypothesis

If a router-style, multi-model agent design was hitting its limits, the fix was better engineering on the same foundation: one strong executive brain instead of routing between models, autonomy candidates so nothing acts unsupervised, an idle-reflection loop for self-generated improvement, strict backward-compatibility discipline so the plugin ecosystem never had to be rebuilt. Mature the architecture enough, and something closer to genuine independence should follow.

02 · Experiment

Omega Observer is that architecture, built out fully: an executive-first intake that decides answer/ask/bucket-work/tool-call/plugin-call/delegate before anything else happens; autonomy candidates as the sole gate to action, including the ideas the system generates about itself; a thought loop with a throttled idle-reflection turn that reviews recent thoughts, failures, and capability gaps when nothing else is pending; a Nova-compatibility harness enforced by its own regression test, specifically so old plugins never had to be rewritten to keep working.

The move away from router-style design wasn't a reaction to router-style design failing — it was a reaction to the field catching up to it. By the time other projects (open-claw among them) had converged on the same well-beaten router pattern, there was more to learn from testing the components in a different configuration than from refining the one everyone else was now also running. Part of that different configuration paid off directly: with the right infrastructure around them, 9B models were producing responses at a quality comparable to 20B models — not something seen done successfully elsewhere.

03 · Result

The engineering matured. The system didn't. Omega Observer kept falling back into familiar patterns — a more capable agent framework, but still a short memory, still limited reasoning, still no free will. Two specific mechanisms show exactly where the ceiling sits:

• Autonomy candidates work, but only partly. The mechanism is genuinely successful at making autonomy useful rather than useful-sounding — but it isn't clear it fully does even that job yet. It's an honest partial success, not a finished answer.
• Idle reflection is mechanical, and that's the tell. It files, sorts, and cleans well — a good system for an agent with strict, bounded responsibilities. But for an agent meant to have something like free will, it falls short: it's a framework that lets the agent act alone, not a process that resembles the agent wanting to.

Neither failure is a bug. Both are the architecture doing exactly what it was built to do, and that turning out not to be enough.

04 · What I Currently Believe

Memory and will are the two most critical, least understood components of autonomy — and memory is the harder of the two to even get a foothold on, because it's poorly understood in the available literature, not just poorly implemented here. That's exactly why it became the highest priority to work out first: everything else can comply with its methods once it exists, but nothing else can substitute for it.

Continuing to refine a conventional agent framework — better routing, better candidates, better reflection — was not going to close that gap on its own. The next step required departing from that architecture altogether, toward biological mimicry: taking memory, attention, and executive function from models of cognition rather than from software-engineering convention. That departure is where Omega Observer paused and Omega ACA began.

05 · What Would Falsify It

The same two tests already running against Omega ACA's broader claim about will apply here, for the same reason: both are ways of checking whether something is actually accumulating and reasoning between calls, rather than just executing a mechanical loop that looks autonomous from the outside — which is precisely the distinction Omega Observer's idle reflection failed to cross.

• Self-awareness as a litmus test — if Omega ACA can't recognize its own prior states or output as its own, the architecture hasn't crossed from mechanical to something more, no matter how biologically-motivated its memory model is.
• Cross-conversation synthesis — feeding related content into separate, unrelated conversations, then later asking the system to synthesize new information out of connections it was never shown directly. If it can't, the memory model has changed how things are stored without changing what kind of thing is doing the storing — which would mean the departure from Omega Observer's architecture didn't actually close the gap it was meant to close.

Editor's note: built from a follow-up interview about Omega Observer, cross-referenced against its README. Section 05 uses the same falsification tests already established for the broader "will" claim in log 001, rather than a new one invented for this entry — Derek confirmed this is the right fit rather than a separate test.

Every attempt at it back then met the same fate. All logic had to be hard-coded, by hand, rule by rule — there was no way for the system to generate its own new logic, only to run the logic it had already been given. So nothing ever compounded. No snowball effect. Each experiment was a dead end for the same underlying reason, regardless of how it was designed.

AI-assisted development is what finally removed that ceiling. A solo developer can now cover enough ground, quickly enough, for the old idea to be worth trying again — not because the idea changed, but because the thing that was blocking it did.

Where this shows up

This isn't the origin story of any one project — it's the reason several exist:

• Terminus is the first attempt built after the ceiling lifted: the smallest possible test of a validated self-editing loop, deliberately scoped down to "does the mechanism even work."
• Omega Observer → Omega ACA is the same underlying instinct — systems that change their own structure rather than just executing fixed logic — applied to memory and cognition instead of code.
• Why an LLM Doesn't Have a Will is arguably the same question again, one level up: not "can the code rewrite itself" but "can the system generate its own reasons to act" — a system that isn't just running rules it was given.

A twenty-plus-year-old idea, tried repeatedly and abandoned repeatedly for one consistent, structural reason, isn't the same thing as an idea that was wrong. It just needed a precondition that hadn't arrived yet.