Binding + cleanup

Things inside things,
held as one.

Meaning lives in how things connect: a thing made of parts made of parts, nested as deep as you like. One mechanism, binding, folds that whole shape into a single memory you can reach into at any depth, and rebuild from the numbers alone.

How it works, why it didn’t before, and what it unlocks.

01 · Binding

Tie things together, inside one vector.

Hand the substrate two ideas and it can bind them, fusing them into a single vector that stands for the pair, the way capital and Paris fuse into “the capital is Paris.” Bind a few of those and you have a record. Let a record be one part inside a bigger record and you have structure: nesting, as deep as you like.

This is an old idea, Holographic Reduced Representations (HRR): keep symbols and their relationships in fixed-size vectors and do algebra on meaning. The catch was always what happened when you tried to go deep.

A bind is a single math step (circular convolution). Fold a hundred things in and the result is still one vector, the same size as one thing. That fixed size is the point, and the problem.

02 · The wall

Past three levels, it dissolved.

Every fold adds a little noise. Unfold a few levels to read something back and the noise piles up until, in practice, the answer is gone after about three levels. Deep structure was easy to write and impossible to recover.

So nobody built on it. For thirty years, binding stayed a party trick: great in a paper, useless past a couple of levels deep.

03 · Cleanup

A memory that resets the signal.

HeatherDB is an associative memory: hand it a noisy vector and it snaps to the nearest thing it has stored, a cleanup. Put that cleanup between every level of unfolding, and the noise never gets a chance to accumulate. Each step starts clean.

That one change moves the wall from three levels to well past fifteen. Binding stops being a party trick and becomes a foundation you can actually build on.

2–4

levels deep with binding alone, before it falls apart

11–16

levels deep with cleanup in the loop, live on the engine

exact

a five-layer structure rebuilt from one vector, every part

The cleanup loop is a resonator: unfold one step, snap to the nearest stored shape, unfold again. The numbers above are measured against the running engine, not a simulation. Read the paper →

04 · What you can do with it

Fold it. Reach into it. Rebuild it.

Fold

A whole nested shape, however deep, becomes one fixed-size memory. It doesn't grow as the structure does. A table would scatter it across a dozen joined rows; here it's a single thing.

Reach in

Point at anything, however deeply buried, and the part is recalled by association against the memory, not fetched from an address or an index. No path to walk, no rows to join.

Rebuild

Erase every label and the shape itself, leaving only the raw memory. The whole structure unfolds back out, exactly. It's recovered from the numbers, never stored anywhere as a schema.

05 · What it unlocks

A pile of things that weren’t possible.

Once structure nests without limit and comes back whole, a lot follows: a whole class of things no database can do.

Memory that doesn’t forget

An agent keeps its whole history, deep and compact, and recalls any moment of it, instead of dropping it out of a context window.

Knowledge graphs you walk

Facts that link to facts. Follow a chain of relationships at read time, with no joins and no separate graph database.

Plans and playbooks

A goal split into steps split into steps, held as one thing and reached into at any level. A whole behaviour tree in a single memory.

Language and code, by shape

The nested structure of a sentence or a program, parsed into memory and queried by its form, not its words.

Scenes and world-models

A place holds things that hold things: what’s where, nested as deep as the world is, recalled by association.

Records inside records

Documents, contracts, and configs, the entire nesting kept whole and asked by field at any depth, with no schema to flatten it.

Reasoning you can replay

A chain of decisions stored with the reason under each, walked back one step at a time. Auditable thought, not a black box.

Analogies across structures

Match the shape of one thing to another and carry an answer across, the kind of leap a lookup can’t make.

One substrate, not a stack

Records, graphs, sequences, and trees all live as the same kind of memory, with no separate engine bolted on for each shape.

What it powers

See it fold, reach, and rebuild.

Binding is one mechanism: tying things together so structure nests. It’s behind two demos: Answer a question you never stored and Hold structure, however deep, a plan five layers deep, questioned and rebuilt in front of you.

Open the live demo →Things a memory that thinks can do Download HeatherDB