This is the third article in a research series about trying to build something adjacent to — and in some ways alternative to — large language models, rather than a wrapper around one. Part 1: "My Synthetic Eval Said 30/30. LoCoMo Said 0.13." Part 2: "Can You Build an Alternative to LLMs? 8 Months, ~200 Failed Experiments, One Wall." The code that survived is open source in AuraSDK.
In the previous part I showed the wall: every knowledge carrier I tried failed at transferring causal binding. This part is about a different, narrower, and more useful question that remained after the failures:
If so many containers died and some loops survived — what exactly separates the two?
The answer turned out to be one sentence. And it killed half my designs on the whiteboard, before the first run:
storage preserves an event;
knowledge must change the next action.
It sounds trivial. The consequences are not.
1. The Trap Almost Every Memory System Falls Into
The default answer to "give the system knowledge" is always the same:
- store facts;
- build a graph;
- add embeddings;
- add typed edges;
- retrieve relevant chunks.
All of these store a statement. A statement is a container. It sits there and waits for someone to retrieve it.
Here is what dead knowledge looks like:
"windows(0) causes a panic" ← a fact. a dead number. a container.
It looks like knowledge. But it is a string that can lie on a new input. It does not know WHERE it came from, it does not know WHEN it no longer applies, and it changes nothing about the system's next action — until some separate layer (an agent, a prompt, an inference step) decides what to do with it.
And here is the same thing as a lived consequence:
state: calling slice.windows(window_size)
action: set window_size = 0
consequence: the world returned panic "size > 0"
conclusion: this transition refutes the route for the boundary/window-guard class
links: guard, invalid-parameter, runtime-invariant, panic-before-assert
The difference is not cosmetic. The first is what SOMEONE described. The second was born from EXECUTION: the world returned a panic the author did not know in advance.
2. The Core Prohibition: A Unit of Knowledge Is Not a Container
After ~200 failures, I formulated a prohibition that became filter #1:
A universal unit of knowledge must not be a container.
Because the moment it becomes a container, it is a JSON / graph / table again, and we get dead numbers again. This has been falsified many times: storing links between empty symbols does not produce knowledge.
A unit has to be operational. Three actions must work on it:
1. SELECT — it can be used to choose an action in a new situation
2. COMPARE — it can be matched to a new situation by consequence, not by surface
3. VERIFY — it can be confirmed or refuted by a new consequence (it mutates)
If a unit cannot be (1) used to choose, (2) compared by consequence, and (3) updated by a new consequence — it is a container, not knowledge.
3. The Falsify-Tooth: One Test That Separates Alive From Dead
The problem with prohibitions is that during implementation the unit quietly slides back into a container. So I reduced everything to one test — the irreversibility-into-form tooth:
TEST: can this unit be generated WITHOUT executing in the world?
yes → it is a FORM (someone described or filled it) → CONTAINER → dead
no → it could only be born from a lived collision
(the world returned a consequence we did not know in advance) → ALIVE unit
It is a sharp, almost brutal criterion. But it works.
windows(0) → panic passes: this consequence is born from execution, the world returns the panic, and you cannot honestly write it from your head without running it.
A co-occurrence graph, a summary, a typed-edge table, an embedding — all fail: they can be filled by hand or by an LLM with no collision with the world at all. So they are containers in disguise.
One sentence worth a whole section: a real unit of knowledge contains a consequence the author did not know until they took the action.
4. The Zero-Action Law: Knowledge Without Action Is Guessing
The most useful result was negative, and it put everything else in its place.
I wanted a carrier that "knows" the correct answer to an unseen situation immediately, with no action at all. Zero-probe transfer. One gate tested this directly:
0-probe unseen transfer:
no given role -> selection WRONG, hidden verifier fails
with given role -> read-path selects RIGHT
with shuffled role -> selection WRONG, hidden verifier fails
Reading that table honestly: the read mechanism works only if the role has already been lived or supplied. Without an action that produces or projects the role, the system does not "know" the unseen answer. Transfer = 0.
This is not a defect. It follows from the nature of the thing:
knowing the answer without action = guessing
guessing without verification = a consensus machine / an LLM
a consequence machine, therefore, needs a consequence to know
This is exactly the line to an LLM. An LLM answers without action because it guesses the most probable continuation. A consequence machine honestly says "I don't know" or performs a minimal check. So abstain is not a weakness — it is the core of its honesty.
5. What This Changes About the Carrier's Goal
The zero-action law inverted the goal itself:
NOT: a carrier that knows the right answer without action
YES: a carrier that minimizes the action needed for an honest consequence-check
Route-state, role-equivalence, scars, cheap-check — these are not "magic 0-probe knowledge." They are organs of cheapening the check. They prune the search, rank, block lies, turn an expensive full probe into a cheaper partial probe. But they do not cancel the principle itself: new knowledge is born from consequence.
The practical criterion I now apply to every experiment:
If a gate shows only fewer probes / cheaper probes / wrong=0 via abstain —
that is NOT a carrier that knows, it's an organ of optimized verification.
That's good if the goal is truthful action at minimal cost.
It must NOT be inflated to "the system knows the unseen without a check."
6. Container Died, Loop Survived — With Numbers
Now the specifics, because this series is held together by numbers, not by morals.
The container (zero-probe) — died. A carrier required to know the unseen without action gave transfer = 0. With a given role, reading works; shuffle the role as a control and the selection is wrong again, the hidden verifier fails. So there was no "knowledge" there; there was a dependence on an already-lived / supplied role.
The loop (cheap-probe) — survived, but only on real overlap. Here is the most important honest story of a single gate. The first version of transferring the selection to unseen cases gave:
2/4 ← a coin flip
The temptation is to declare failure. But the diagnosis was more precise: the unseen situations had been constructed so that they were NOT genuinely related to the trained ones. And the carrier honestly said "I don't know" on 50%, instead of guessing at random. When I rebuilt the unseen cases as normalized mixtures of trained situations — i.e. gave them REAL distributed overlap — the result was:
4/4
The key point: selection generalizes where there is real overlap, and honestly does NOT where there is none. On the genuinely-new, the carrier does not hallucinate a selection — it stays silent. That is exactly the behavior an LLM does not give you.
The difference between the two sides:
container that claims to know without action -> 0 transfer
loop that cheaply checks by consequence -> 4/4 on real overlap,
honest coin flip (2/4 = abstain)
on fake overlap
7. The Honest Boundary
This does not solve the whole knowledge-carrier problem. How these units compose, how they transfer to the genuinely-new, how they scale — all still open (the wall from part 2 has not gone anywhere). And I'll name the boundary myself, before it gets named for me: this is one person, eight months, a CPU, not a lab. There may be a container I never tried.
But the most important thing is done: I finally named precisely WHAT the carrier has to carry. Not data. Not facts. Not semantics. A unit of a lived causal transition that can be selected, compared by consequence, and refuted.
And from there followed the single question I now use to judge every experiment:
Does it create a unit of lived consequence —
or just a prettier container?
That question saves months. Because a prettier container always looks like progress — right up until you ask it to transfer.
8. Conclusion
The eight-month post-mortem produced a less glamorous but more useful thesis than the one I was chasing:
containers store statements that can lie;
loops store consequences the world has already confirmed;
knowledge without action is guessing;
a cheaper honest check > a confident answer with no check.
Every container I built died at transfer. Every loop tied to a consequence survived exactly as far as it honestly stayed silent where there was no overlap.
The final number:
zero-probe unseen transfer: 0
cheap-probe on real overlap: 4/4
the same cheap-probe on fake overlap: 2/4 = honest abstain, not guessing
The mechanisms that survived (append-only memory, scar logic, cheap-probe consequence checks) are open source: AuraSDK on GitHub. If you have seen a unit of knowledge that passes the falsify-tooth from section 3 and is still not a container — tell me in the comments, I genuinely want to see it.
Top comments (0)