Priver Engram is the non-volatile array where the event-graph actually lives — and does its own arithmetic. Decay, growth, and reinforcement happen inside the storage, so a memory never has to be shipped out to a processor just to age. It's the substrate beneath Priver GTX-1, and the reason recall fits in a milliwatt budget.
The bottleneck was never the math. It was moving the data to where the math happens.
Walking a memory graph means chasing pointers — jumping to wherever the last hop pointed, over and over. In the usual design, every link and its weight has to be hauled out of storage, updated by a separate chip, and written back. That shuttling — not the arithmetic — is where the power and the time actually go. Accelerating the math alone doesn't fix it, because the math was never the expensive part.
Engram does the arithmetic where the data already sits. A link's decay, growth, and reinforcement are computed in the array and written in place. The links never cross a memory boundary to be maintained — which is what makes milliwatt-scale, all-day recall physically possible, and keeps the graph's contents from ever being exposed in transit.
Every associative link is stored alongside everything needed to evolve it, with the arithmetic fabricated right next to the cells that hold it.
A stored weight is combined with elapsed time through a decay function chosen by its profile id — computed inside the array, so the current, decay-adjusted weight is produced without fetching the link out.
Recurring associations are reinforced; idle ones decay; new ones grow — each written back within the sub-array. No link, and none of its fields, traverses the memory interface to be updated.
Rather than write on every tick of time, Engram computes accumulated decay at the moment a link is next touched. Writes are bounded by how often you use a memory — not by the clock — protecting non-volatile cell lifetime.
Because maintenance and recall arithmetic complete inside the array, the graph's contents aren't exposed across a bus or in a separate processor — reducing the surface where personal memory could be read or copied.
Together they're the memory engine inside Priver Core. Engram stores and maintains; GTX-1 queries across a request-result interface and a dedicated memory link, and Engram returns only what's asked for — decay-adjusted weights and candidate nodes — keeping elements near the active frontier close at hand.
The split is deliberate: keep the heavy, repetitive arithmetic in the storage where the data lives, and let the accelerator handle traversal logic, sorting, and candidate selection. Each is independently licensable; co-packaged, they're the lowest-power path from a question to a recalled memory.
Stores the typed event-graph; ages, grows, and reinforces links in place; returns decay-adjusted weights.
Walks the graph, sorts candidates by weight, and selects what the inference layer sees next.
The dominant energy cost of sparse traversal — shuttling links across a bus — largely disappears.
Deferred, access-driven decay bounds writes to non-volatile cells, extending endurance.
Personal memory isn't laid bare on a bus or in a separate processor just to be maintained.
Non-volatile cells hold the graph and its weights across power-off — no battery-draining refresh.
Engram is host-independent and milliwatt-scale, ready for wearable, mobile, embedded, vehicle, home, clinical, industrial, and chip-vendor contexts.
A standalone compute-in-memory integrated circuit for board-level designs.
An Engram chiplet beside a GTX-1 chiplet in one package — the memory engine, dropped in.
Instantiated inside a chip vendor's system-on-a-chip alongside their own processor.
Take Engram on its own, pair it with GTX-1 as the memory engine, or license the full Priver Core platform it belongs to.