01 · Hypothesis

If a language model is wired into an architecture that hands it identity, memory and attention from outside itself — so it's invoked only as a "cognitive processor" on content that has already won its way into working memory, never as the seat of continuity — it should be able to act like a component with a genuine stake in finishing what it starts, rather than a chatbot answering whatever's in front of it.

02 · Experiment

Omega ACA's core principle is explicit about this division of labour: identity, memory, attention and executive function exist independently of any single inference call. Working memory, spreading activation, goal competition — all of it runs as ordinary computation. The model is only ever called in, on content the architecture has already decided is worth its attention.

The first version of this was purely experimental — built, then extended once it showed early signs of working, by going back through the established literature on cognition and re-deriving each mechanism from a named theory instead of an invented one. That rebuild wasn't where the real problem showed up, though.

03 · Result

Once the architecture around the model was solid, the model itself wouldn't behave like a component in it. It kept acting like a standalone chat bot — answering, then stopping, then waiting to be spoken to again — regardless of what the surrounding architecture handed it.

"I needed to shape the prompt in ways that would stop the LLM behaving like a standalone chatbot and more like a processing node in a cognitive system."

That reshaping is a prompt-level shunt, not a structural fix — a workaround sitting on top of a model that was never trained to occupy this role. And it's the hardest thing encountered in the whole build so far, for a reason that has nothing to do with the theory:

"I have never built a system that I need to convince to want to perform an action. It is quite a departure from my usual engineering."

04 · What I Currently Believe

Will isn't something that emerges from model scale, and it isn't something the architecture alone can supply either. The architecture can make a system persistent, continuous, and coherent between calls — but the moment it hands something to the model, it's handing it to a component that has to be talked into wanting it, every time. Right now that talking-into is done with prompt engineering, and it's a stopgap. A model actually trained for this role — as a cognitive processor operating inside something else's continuity, not as the thing the conversation is happening with — is the version of this that would hold up without the shunt. That's unbuilt, for lack of resources to pursue it, not for lack of a plan.

05 · What Would Falsify It

Two tests are already running against the broader architecture, and both bear on this directly:

• Self-awareness as a litmus test — if the system can't recognize its own prior states or output as its own, the will problem is moot; there's no persistent "it" to have one.
• 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. Genuine synthesis would mean something is actually accumulating and reasoning between calls, not just being re-fed context.

The sharper test for this specific claim: if a model trained for the cognitive-processor role — not prompted into it — still showed the same reluctance and inertia the prompted version does, that would falsify "this is a prompting problem" and point at something less fixable underneath.

Status: System operational — attention tuning and pipeline stability ongoing. The system is public and testable: anyone can download the release and run it against their own input.

Editor's note: this entry was assembled from a short interview about the Omega ACA project (E:\AI\omega-aca), cross-referenced against specs.md v0.2. It has not been reviewed by Derek beyond that interview. Treat it as a first draft of the Hypothesis / Experiment / Result / Belief / Falsification format, not a finished lab entry — the next pass should tighten the claims and add whatever detail didn't come up in the first round of questions.

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.