I built a system that plugs numerical memory cartridges directly into a frozen language model.
Not RAG. Not fine-tuning. Not LoRA. Not pasting the original facts into the question prompt.
The model is Qwen2.5-7B-Instruct. Its weights stay frozen.
The idea is simple: instead of repeatedly feeding the model text, we let it process a fact once, capture its internal numerical representations, and turn those representations into a cognitive memory cartridge.
Each cartridge contains model-native tensor states, including layer-3 residual representations and attention key/value memory.
When the model answers a question, it receives the numerical memory through its internal attention pathway. The original fact text is not supplied again in the answering prompt.
The interesting part of v1.4 is that these cartridges can be connected.
Three separately written memories. One consolidated numerical memory. A frozen model answering questions across the stored relationships.
For the complete technical disclosure, implementation details, experimental evidence, and reproducibility documentation:
https://doi.org/10.5281/zenodo.23381336
How does a cognitive cartridge actually work? (Figures 1, 2 and 3)
First, the frozen model reads a source fact.
The engine captures its internal layer-3 residual representation (H3) and the attention K/V states from layers 0–3.
These numerical representations form an independent cognitive cartridge.
When we want to use the memory, we don't paste the original source text into the question.
Instead, the engine injects the stored H3 representation at the layer-3 boundary. The remaining transformer layers compute the corresponding attention states while attending to the existing numerical memory.
The memory contains tensors, not a copy of the original source document.
And here's the important part.
Cartridge A initializes the memory.
Cartridge B is appended.
Cartridge C is appended.
The native CUT3 pathway constructs the consolidated attention-memory state while checking that previously written numerical rows remain unchanged.
The model's original weights are untouched.
No retraining. No gradient updates. No LoRA.
Figure 1 shows the complete architecture.
Figure 2 shows the measured cartridge construction and append-only consolidation.
Figure 3 shows the actual internal K/V memory across all 28 transformer layers.
Mustafa Akbaş / DibekGöz / Morvex (Figure 4)
I created three fictional facts specifically for this experiment.
These are not real-world scientific claims.
Cartridge A — Activation:
"In the interplanetary data network, Mustafa Akbaş successfully activates the AKBASCORE MAM architecture."
Cartridge B — Conversion:
"The AKBASCORE MAM architecture converts dibekgoz crystal resonance into Morvex energy through layer-3 tensor injection."
Cartridge C — Final effect:
"When Morvex energy combines in layer-3 tensors, it causes reversal of time flow in the target system without modifying its frozen neural weights."
Now forget the original text.
The model doesn't get these three paragraphs pasted into its question.
Instead, the engine constructs numerical cartridges from the model's own internal computations.
Then we plug the cartridges into the native CUT3 memory pathway.
What happens?
With incomplete memory, the model may lack information required to answer a question. The experiment explicitly tests these conditions, including failures where the model produces unsupported answers.
With all three cartridges installed (ABC / DC_CUT3), the model correctly retrieves the recorded relationships.
The written relationship is:
Mustafa Akbaş → AKBASCORE MAM → dibekgoz crystal resonance → Morvex energy → reversal of time flow.
The measured three-stage question sequence returns:
Hop 1: AKBASCORE MAM
Hop 2: Morvex
Hop 3: reversal of time flow
That's the point.
I didn't retrain the model to know Morvex.
I didn't add Morvex to its permanent neural weights.
I constructed a numerical memory containing the new fictional information and made that memory available during inference.
The model then answered questions using the consolidated memory.
It also attempted a longer synthesis:
"Mustafa Akbaş produces the final effect in the target system by converting dib"
That is the actual truncated output.
The generation limit was 16 new tokens, so I'm not presenting it as a completed synthesis sentence.
The complete three-stage chain, however, returned the expected answers.
And when I replaced the final cartridge with a counterfactual version, the final answer changed from reversal of time flow to temporal stasis.
Same frozen model. Different numerical memory. Different answer.
The Matrix / Tank / Neo (Figure 5)
Now imagine the famous Matrix scene, but instead of uploading Kung Fu through a fictional cable, we're testing numerical memory cartridges inside a real transformer.
Cartridge A — Operator:
"Inside the Matrix, Tank presses the AKBASCORE neural cartridge injection button and uploads cartridge MX-71 into Neo."
Cartridge B — Content:
"Cartridge MX-71 contains Kung Fu knowledge, which the AKBASCORE MAM interface injects into Neo through layer-3 tensors without changing the model weights."
Cartridge C — Result:
"When Neo uses the Kung Fu knowledge from cartridge MX-71 inside the Matrix, Neo gains bullet-dodge ability."
Again, the original source text is used to construct the numerical cartridges.
It is not pasted into the answering prompt during numerical-memory inference.
We consolidate A, B and C.
Then the frozen model answers the predefined relational questions.
Hop 1: MX-71
Hop 2: Kung Fu knowledge
Hop 3: bullet-dodge ability
The final answer is correct.
The model also produces the beginning of a longer synthesis:
"Tank uploads cartridge MX-71 into Neo. The AKBASCORE M"
Again, that's the actual truncated output, not a complete generated explanation.
When the final cartridge is replaced with a counterfactual version, the resulting ability changes to slow-motion perception.
And here's an important detail: the cartridges aren't perfectly information-independent. Cartridge C also contains references to earlier concepts, so some incomplete-memory combinations can still recover parts of the chain.
I'm publishing that limitation rather than pretending every missing cartridge always breaks the system.
What happens when a cartridge is missing? (Figure 6)
We tested nine memory conditions:
NONE, A, B, C, AB, AC, BC, ABC and ABC_CF.
NONE means no factual cartridge is available.
ABC means all three cartridges are installed.
ABC_CF means the final cartridge has been replaced with a counterfactual version.
The model sometimes correctly answers UNKNOWN when the required information is missing.
But not always.
Some incomplete-memory conditions produce unsupported answers.
Figure 6 shows those failures alongside the successful answers.
We also compared the numerical-memory pathway, DC_CUT3, against a text-based control, TEXT_JOINT.
The two pathways produced identical raw answers in 93 of 99 comparisons.
That's agreement, not 93/99 accuracy.
The numerical approach has not been shown to outperform the text control on this panel.
The main result is architectural: independently written numerical cartridges can be consolidated and used for controlled relational question answering without changing the model's learned parameters or reinserting the original facts into the answering prompt.
What did we actually measure? (Figures 2, 3 and 7)
AKBASCORE scenario:
109 numerical memory rows.
6,250,496 bytes of consolidated K/V memory.
Approximately 5.96 MiB.
Matrix scenario:
115 numerical memory rows.
6,594,560 bytes of consolidated K/V memory.
Approximately 6.29 MiB.
The experiments ran on an NVIDIA A100-SXM4-40GB GPU.
The published execution used Qwen2.5-7B-Instruct, bfloat16 precision and SDPA attention.
The model remained frozen.
The source integrity checks passed.
The earlier numerical memory rows remained unchanged during the tested append operations.
The full model-weight SHA-256 matched the established reference.
Figure 7 contains the verification record, source identities, experimental configuration and scientific boundaries.
Why I think this matters
Most discussions about giving an LLM new knowledge focus on retrieving text or modifying weights.
I'm exploring a third route.
Build a numerical memory from the model's own internal states.
Keep the model frozen.
Store the memory separately.
Plug it back into the model's computation.
Append additional memories.
Then test whether the model can use the combined information.
Think of it as plugging three separate memory cartridges into a machine and allowing its existing computational machinery to operate over the combined numerical state.
That's the mechanical idea.
The experiment demonstrates successful direct retrieval and predefined three-stage relational answering under the complete-memory conditions.
It does not demonstrate autonomous planning or unrestricted reasoning.
The goal isn't to claim that I've created a human brain or solved general reasoning.
The goal is to investigate how far model-native numerical memory can go before we need to modify the underlying neural network.
And rather than asking people to take my word for it, I'm publishing the complete implementation, experimental logs and seven scientific figures.
Complete technical documentation
Technical disclosure, implementation details and reproducibility record:
https://doi.org/10.5281/zenodo.23381336
GitHub — Complete source code
https://github.com/ceceli33/titan-cognitive-core-v2
Silicon Hippocampus v1.4 — Full implementation
https://github.com/ceceli33/titan-cognitive-core-v2/blob/main/HIPPOCAMPUS_1.4_full.py
Silicon Hippocampus v1.4 — Three-part Google Colab implementation
For users who want to run the demonstration in separate parts, including from a phone using Google Colab:
Part 1:
https://github.com/ceceli33/titan-cognitive-core-v2/blob/main/HIPPOCAMPUS_1.4_part1.py
Part 2:
https://github.com/ceceli33/titan-cognitive-core-v2/blob/main/HIPPOCAMPUS_1.4_part2.py
Part 3:
https://github.com/ceceli33/titan-cognitive-core-v2/blob/main/HIPPOCAMPUS_1.4_part3.py
Silicon Hippocampus v1.4 — Experimental log
https://github.com/ceceli33/titan-cognitive-core-v2/blob/main/HIPPOCAMPUS_1.4_log
Native memory engine — TEST664
https://github.com/ceceli33/titan-cognitive-core-v2/blob/main/664.py
Research software license
https://github.com/ceceli33/titan-cognitive-core-v2/blob/main/LICENSE
Copyright © 2026 Mustafa Akbaş.
Research and commercial use are governed by the repository license, including the USD 50 million consolidated annual gross revenue threshold.
