← Back to Research

When meaning becomes
something you can
compute with

Relationships stop being data the machine looks up and become values it can do arithmetic on

Edwin NguthiruAphorion Labs[email protected]

Computers have always computed on numbers, and on symbols that stand in for things. They have never computed on meaning itself. A database can store the sentence "Paris is the capital of France," but the relationship inside it — capital-of binding Paris to France — is just text to the machine. It can match those words. It cannot hold the relationship as a thing and do anything with it.

That gap is the reason so much software feels brittle. The meaning lives in your head; the machine only juggles the labels. This post is about closing the gap, and about what we measured when we tried.

Start with the smallest version. Take a role and the thing that fills it: capital and Paris. A certain kind of memory can fold them into a single pattern that means "the capital is Paris." Hand that pattern the word capital and it gives back Paris. Hand it Paris and it gives back capital.

BINDING — TWO MEANINGS, ONE PATTERN
capital
⊛
Paris
=
one patternsame size as either word
cue: capital→Paris·cue: Paris→capital
Nothing sat in a row or a cell. The relationship became a value you can add, scale, and transform.

Nothing sat in a row or a cell. The relationship became a value, the same size and shape as the words it relates, and you can do arithmetic on it. Add two such patterns and you get a memory that holds both facts at once. Apply one transformation to all of them and every relationship inside bends the same way, together.

That is what we mean by computing on meaning: the relationship is no longer something the machine looks up. It is something the machine operates on.

A trick is one example that works. An algebra is a set of operations with laws you can rely on every time. So we tested the laws directly, thousands of times over, against the live engine.

They hold. Folding distributes over adding, exactly. A folded relationship is unlike either of the things that went into it, so it does not get confused with its own parts. And a shared transformation preserves the angles between meanings, so "king is to queen as man is to woman" survives the math instead of dissolving in it. These are not vibes. They are measured invariants, stable to four decimal places.

MEASURED INVARIANTS — LIVE ENGINE
bind(a, x + y) = bind(a, x) + bind(a, y)distributes over additionerr < 1e-4
⟨ bind(a, b), a ⟩ ≈ 0unlike its own partserr < 1e-4
king − queen ≈ man − womanangles preservederr < 1e-4
kingqueenmanwoman
Once the laws hold, the operations compose: chain relationships into a path and walk it, pose an analogy as an equation and solve for the missing term — none of it trained.

Here is the honest part. Every one of those abilities runs on a single budget, and the budget is smaller than the textbook promised.

A single memory pattern holds only so much meaning before the answers blur. The old papers put the ceiling at roughly a third of the pattern's size. What we measured, on the running engine, is that the usable ceiling is about an order of magnitude lower: a memory the size of a thousand numbers reliably holds only a couple dozen relationships, not a few hundred. Push past that and recovery falls off a cliff. At sixteen relationships the engine is perfect; by a few hundred it is at zero.

THE CAPACITY WALL — RECALL vs LOAD (dim ≈ 1000)
Perfect to ~16 relationships, then recall falls off a cliff. The textbook ceiling (~⅓ of dimension) sits far to the right of where it actually holds.

This one wall explains everything that looked like a separate limit. How many reasoning steps you can chain, how deep an analogy can run, how tall a hierarchy you can climb: all of it is the same budget, seen from different angles. There is one law, not five.

The instinct is to fight the wall by building a bigger memory. That is the wrong move, and the measurement says so.

The budget is per memory, not global. So you split the meaning across many small memories and route each question to the one that holds its answer — the way you open a folder instead of scanning the whole disk, the way the brain has regions instead of one undifferentiated mush. Each lookup then competes against a handful of candidates instead of thousands.

ONE BIG MEMORY vs MANY ROUTED — SAME TOTAL MEANING
one big memorymany small, routed
One big memory collapses to nothing under load. Many small routed memories hold essentially perfect recall to 2,000 relationships and show no sign of stopping.

We ran both side by side on the live engine, same settings, same total amount of meaning. Total capacity becomes the number of memories times the budget of each — unbounded in the number of memories. So the architecture inverts. You scale not by storing bigger meanings, but by keeping many small memories and knowing where to look. Capacity stops being a ceiling and becomes a matter of organization.

When meaning is a first-class value — something you compose, transform, and recover with reliable laws — a pile of hard problems turn into ordinary operations.

An agent's memory stops being a transcript it re-reads and becomes a structure it reasons over: fold an episode into one engram, hand it a cue, get the episode back. Analogy turns into an equation you solve for the missing term, instead of a prompt you keep tweaking and hoping. A knowledge base is no longer rows you query; it's relationships you can walk across, bend, and recombine. The machine is finally working in the same currency you think in.

None of this needs a model the size of a city, or a training run that boils a lake. It needs a memory whose primitive is meaning, and the discipline to keep its pools small and well-routed. The laws are simple, the budget is real, and the way around the budget is to organize, not to inflate.

That is the quiet shift. For decades, meaning was the thing software pointed at from the outside.

It is starting to become the thing software is made of.