We built a memory architecture in which a frozen language model can write its own internal attention states to disk, find them later through a RAM-based recall engine, and use them to answer questions without reading the original information again.
Not a saved conversation. Not a text database. Not fine-tuning.
A physical memory system built around the model's own internal representations.
We call it AKBASCORE MAM v1.3.0 — The Silicon Hippocampus.
The basic idea is straightforward: the model forms the memory, the SSD stores it, RAM finds it, and the frozen model recalls it.
The four figures above document the complete process, from memory formation to measured retrieval.
Fig. 1 — The Silicon Hippocampus: the complete memory architecture
Figure 1 shows the relationship between three components.
WRITE converts information into the frozen model's own attention key/value states.
SSD preserves those states as independent physical memory cartridges.
READ uses a geometric addressing engine in RAM to locate the appropriate cartridge and restore it to the model's attention cache.
The distinction matters. The SSD does not hold a collection of text passages waiting to be pasted into a prompt. It holds the model's previously generated K/V states. RAM does not need to load all 1,453 cartridges into memory; it maintains the address index and native representations required to find the relevant file.
Think of the SSD as a long-term memory archive: it preserves experiences even when the model is no longer actively processing them. The RAM-based engine plays the role of associative recall — given a cue, it finds which stored memory should be brought back into active use. In this implementation, roughly 399 MB of index and native-vector data support that search across 1,453 physical memories. This is a functional analogy, not a simulation of brain anatomy.
The model's weights remain unchanged throughout.
Fig. 2 — WRITE: turning information into a physical memory cartridge
This is where the memory is formed.
The frozen Qwen2.5-7B-Instruct model reads a fact once. Its lower-layer attention states are captured, and the layer-3 hidden state is used in a second forward pass to construct the remaining K/V states.
The resulting CUT3 cartridge contains 56 bfloat16 tensors across 28 transformer layers.
Each cognitive cartridge is the computational equivalent of a stored memory trace: not a sentence to reread, but a preserved internal state that can be reactivated. In the human-memory analogy, the cartridge is the memory trace, while the SSD is the archive that keeps it.
That cartridge is saved as an independent .pt file, with a SHA-256 entry in the storage manifest.
In the published experiment, the system created 1,453 physical cartridges occupying 3,973,450,961 bytes, approximately 3.97 GB.
Figure 2 also shows something important: during the live demonstration, the system reconstructed one cartridge from its original fact and compared the resulting 56 tensors against the previously stored file.
All 56 tensors matched bit for bit.
The model reproduced the same physical memory representation without modifying its weights.
Fig. 3 — READ: RAM finds the memory, SSD supplies it, the model answers
Now comes the other half of the architecture.
The model receives a question, not the original fact.
Its native layer-3 question representations are projected into a PCA128 address space. FAISS IVF128 searches the indexed positions, TOP2 narrows the candidates, and the locked PEAK50 rule selects the best cartridge.
In the live example:
1,453 physical cartridges → 103 touched cartridges → 16 candidates → one selected file.
The selected cartridge is verified against its SHA-256 manifest, loaded from the filesystem and installed into the frozen model's attention cache.
This is the recall moment: a question acts as the memory cue, the RAM engine identifies the relevant trace, and the SSD supplies it for reactivation inside the model. The system does not search for a written answer; it searches for the internal state from which the frozen model can generate one.
The model then answers using the question template and the restored K/V state. The original fact text is not inserted into the prompt again.
Figure 3 shows the actual ranking of all 16 candidates, including the winning cartridge #0292.
A negative control was also performed: the same question was answered using the second-ranked cartridge instead. It did not produce the expected answer.
This demonstrates that the selected memory state matters to the observed response, rather than the question alone being sufficient in that test.
The live run measured 27.9 ms for addressing, 19.4 ms for verified loading and 249 ms for answer generation on an NVIDIA A100 40 GB. These are separately measured stages, not a claimed end-to-end latency.
Fig. 4 — RESULTS: what the system actually achieved
Figure 4 separates three different evidence sources: the current runtime's startup acceptance, the archived TEST627 record and the newly executed live demonstration.
The startup acceptance evaluated 48 synthetic facts with two question formulations:
Original wording: 48/48 correct cartridge selections and 48/48 correct answers.
Alternative wording: 48/48 correct cartridge selections and 48/48 correct answers.
96/96 correct selections and answers across the two formulations.
The live demonstration independently re-executed the WRITE operation for its selected case, verified the physical cartridge, reproduced the READ selection, loaded the correct file and generated the expected answer.
The complete audited live pipeline took 2.787 seconds, including integrity verification, memory reconstruction and a negative control. This is not a normal inference-throughput measurement.
The panel is a confirmation test using two formulations of the same 48 synthetic facts, not an independent blind holdout. PEAK50 was selected after the preceding calibration experiment. New-fact blind validation is the next research step.
Why this architecture matters
Most retrieval systems store information outside the model as text and return that text to the prompt when needed.
AKBASCORE MAM explores a different boundary.
The persistent object is the model's own K/V state.
The retrieval address is derived from the same frozen model's internal representations.
The selected memory is restored directly to the attention cache.
This separates memory formation, persistent storage, associative addressing and memory-conditioned generation into distinct operations.
The architecture does not require modifying the model's learned weights, training an external embedding model or running a separate vector-database service. It does use an in-process FAISS index and native-vector data in RAM.
The current implementation is a measured proof of this architecture on Qwen2.5-7B-Instruct, not a claim that all forms of AI memory have been solved.
Reproduce the experiment
The complete implementation, live logs and technical report are public.
(DOI: https://doi.org/10.5281/zenodo.23311350)
AKBASCORE MAM v1.3.0 — The Silicon Hippocampus
[Complete Source Code (Single-Cell Version):
https://github.com/ceceli33/titan-cognitive-core-v2/blob/main/HIPPOCAMPUS_full.py
Original Execution Log:
https://github.com/ceceli33/titan-cognitive-core-v2/blob/main/Hippocampus.log
Three-Part Version (For Users Running the Demo from a Phone):
Part 1:
https://github.com/ceceli33/titan-cognitive-core-v2/blob/main/HIPPOCAMPUS_part1.py
Part 2:
https://github.com/ceceli33/titan-cognitive-core-v2/blob/main/HIPPOCAMPUS_part2.py
Part 3:
https://github.com/ceceli33/titan-cognitive-core-v2/blob/main/HIPPOCAMPUS_part3.py
The report contains the mathematical definitions, physical cartridge construction, storage measurements, retrieval algorithm, source integrity checks and the four technical figures.
The next experiments will address preregistered blind retrieval, additional fact types, consumer hardware and larger cartridge pools.
The central engineering result is already observable: a frozen language model formed a physical memory, the system stored it outside the model, located it through RAM-based associative addressing, and restored it to answer a question without replaying the source text.
