Products / 01 — Substrate
A 7³ hologram holding 342 data voxels — every memory a cell with a unique address and six indexed faces. The 343rd cell is reserved: it is the portal the structure descends through when the level fills. The longest-running demonstration in the portfolio.
Why not a vector database
A vector store answers one question well: what is close to this? It cannot tell you where a memory lives, why it surfaced, what it is connected to, or what the system chose not to recall. For a consumer chatbot that is fine. For a clinician, an underwriter, or an incident commander it is unusable.
The lattice keeps the embedding — but puts it inside a structure. Each memory is a cell with a coordinate. Each cell carries a centroid (its intent) plus six faces, one per remaining explanatory arc, bound to x±, y±, z±. Each face carries its own magnitude and answer text, so the cell states what it is rather than merely occupying a point.
That means a retrieval can be replayed. You can name the address, read the faces, and show exactly which cell produced the answer — a year later, unchanged.
The unit of memory
Most memory systems store a blob and an embedding. Ours stores a legible object. The centroid holds intent; each of the six faces holds one explanatory arc. A human can read a cell and know what it is — which is the whole point.
| Centroid | Intent — what this memory is for |
|---|---|
| Face x− | Essence — what it fundamentally is |
| Face x+ | Function — what it does |
| Face y− | Frame — the context it sits in |
| Face y+ | Relation — what it connects to |
| Face z− | Value — what it is worth, and to whom |
| Face z+ | Form — how it is structured |
Each face carries its arc's magnitude, alignment, polarity and answer text. The same axis pairing is used by the valence field, so a voxel's geometry and its valence are addressed identically — one of a set of seven-arc invariants held under test across the codebase.
Illustrative shape of a real export. Full traces are available under NDA.
Live mechanisms
Storage is the easy half. What makes the lattice a memory system rather than a filing cabinet is what happens to a cell between writes.
A project-wide, monotonic write cursor fills a level one voxel per turn. When it passes the last data cell it descends through the portal: depth increments and the path gains a segment. Capacity is unbounded, addresses stay unique and human-readable.
Voxels decay on a turn-based clock rather than a wall clock, so an idle system does not forget. Recall lifts the decay floor — a memory that gets used persists longer than one that does not, within bounded limits.
Each completed plane of the level triggers a consolidation pass that writes an episodic-to-semantic gist for that batch. Consolidation is a generative view: it never overwrites the voxels it summarises.
Output is measured against an acceptance cone around the declared intent. Deviation beyond the cone is banded by severity and by how many consecutive turns it has persisted, escalating from a quiet UI pulse to a visible correction to a hard abort. A pure function of three numbers, so its behaviour is fully testable.
Co-activation edges are written by a single owning process, so the graph has exactly one writer and cannot race. The retrieval-side consumer is disabled by default and is enabled deliberately — we do not want an unmeasured signal quietly steering recall.
Retrieving a memory and using one are different events. The trace records both, separately. A system that retrieves and never injects is a dashboard, not a memory — so we measure it.
Retrieval
Because a voxel has a coordinate, it can be fetched by lookup rather than by resemblance — and lookups compose into operations a similarity index simply cannot express.
Stated plainly, because it is the first thing a good technical reviewer will probe. The coordinate is an identity handle and timeline index. It is not a semantic signal. Placement is sequential — a base-7 odometer over the level — so two related memories do not land near each other by virtue of being related. They land where the cursor was when they were written.
The semantics live in the voxel's contents — the seven arc scalars and their faces — not in its (x, y, z). Any claim of semantic proximity in the current path would be false, and we do not make it.
Identity, replay and unbounded growth. An address written a year ago still resolves and still means the same cell; the structure deepens instead of rebalancing, so nothing that pointed into it is ever invalidated. That is a different and more durable property than "similar things are nearby" — and unlike similarity, it does not decay as the store grows.
Direct addressing is real and is a genuine lookup on the addressed paths. The live per-turn path is hybrid — it also runs embedding search with diversity reranking — so it is not a pure coordinate lookup in the hot path. Flat retrieval cost as conversations grow is a design property of the fixed per-tier context budget, not a benchmarked measurement, and we quote no cost curve until one is measured.
The addressing
The whole growth story reduces to one mechanism, and it is small enough to state completely. A level holds 342 data voxels. The 343rd is the portal. When the cursor passes the last data cell, the address gains a portal segment and depth increments.
Read the last two rows again, because they are the entire architectural claim in miniature. At sequence 342 the system did not get bigger — it got deeper. The outer extent is identical. Every address written before that moment still resolves, unchanged, forever.
Allocation and insert run inside a single transaction, so the project-wide cursor cannot race two turns onto one address. The write cursor never resets per session; it is monotonic across the life of the deployment.
This is why we do not have a capacity conversation. There is no fill level to monitor and no rebalancing event to fear. There is only depth, and depth is free.
| Addressing suite | 741 assertions, all passing. Every position on a level tested individually in both directions — not sampled — plus portal guards, out-of-range refusal, depth boundaries and all seven layer boundaries |
|---|---|
| Arc invariants | The face-to-arc mapping is verified to agree with every other arc map in the codebase |
| Schema integrity | Storage columns exist and are typed as specified |
| Field integration | Tensor-field reads verified over the flat face values |
| Metabolism | Decay clock and access-count floor confirmed live |
An off-by-one in an odometer is silent, so the addressing suite is exhaustive by design rather than statistical. Full suites available under diligence.
Deployment
| Runtime | Runs against a local model server; no dependency on a hosted frontier API |
|---|---|
| Persistence | On-disk lattice store on the deploying machine |
| Model coupling | Model-agnostic; scoring calibrates itself per embedding model |
| Data egress | None required for core cognition or memory |
| Operator surfaces | Cockpit console (live pipeline stages) and a standalone audit panel with document export |
| Inspection | 3D lattice viewer whose coordinates are read from the live backend, not illustrated |
For a regulated buyer, "the reasoning substrate never leaves the building" is often the difference between a pilot and a procurement.