TEST865 — Model-Derived Pointer Addressing and Physical KV-Cache Memory Re-entry in a Frozen LLM (Qwen2.5-72B): Closed-Loop Evidence Acquisition with Hidden-State Cartridges, CUT3 Injection and Self-Review

AKBASCORE Silicon Hippocampus — TEST865 (Interim Research Release)

Frozen-LLM external numerical memory · activation/KV-cache cartridges · model-derived retrieval query · layer-3 (CUT3) memory re-entry · closed-loop evidence acquisition · native self-review (CONTINUE / REVISE / STOP)

Copyright © 2026 Mustafa Akbaş · AKBASCORE / AkbasCore AI Teknoloji, Mersin, Türkiye · AKBASCORE RESEARCH SOFTWARE LICENSE

Source and log of this release

	Latest (main)	Pinned (commit cac04d177030883c37932ee6d0b26148d1b7b799)
TEST865 code	https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/865.py	https://github.com/ceceli33/titan-cognitive-core-v3/blob/cac04d177030883c37932ee6d0b26148d1b7b799/865.py
TEST865 GPU log	https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/865.log	https://github.com/ceceli33/titan-cognitive-core-v3/blob/cac04d177030883c37932ee6d0b26148d1b7b799/865.log
Licence	https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/LICENSE

Integrity hashes:

• 865.py: git blob 9a0ba587d36466638d9391621f29540bfed5a539, SHA-256 64b8e637…8ec5
• 865.log: git blob b6415d65efceb542df12f5597da5a6bd0aa86b9d, SHA-256 6688df9e…2b81

Attached to this release: AKBASCORE_Silicon_Hippocampus_TEST865_Technical_Disclosure_and_Reproducibility_Record.pdf, with the full method, controls, independent re-scoring and reproduction protocol.

What this is

The model is a frozen Qwen2.5-72B-Instruct (NF4 weights, BF16 activations) on a single A100-SXM4-80GB. No training, fine-tuning, LoRA or weight edits are used, and no evidence text is pasted back into the prompt.

Memory items are numerical cartridges stored on SSD with SHA-256 seals. Each cartridge holds the model's own layer-3 hidden states (H3) and its layer 0–3 K/V for one evidence record.

TEST865 is the first experiment in this line in which a single engine runs the whole cycle:

1. The model signals a knowledge gap by producing a literal UNKNOWN at a reasoning hop.
2. A retrieval query is built from the model's own pointer state P (the rows of its last resolved hop), passed through layers 0–3 only.
3. A fixed, label-free router (PEAK50) ranks the physical H3 keys of the cartridges in a blind pool.
4. The selected cartridge is loaded from SSD after SHA verification.
5. The cartridge is re-entered natively: its H3 rows are injected at layer 3, layers 4–79 recompute the upper K/V, and the lower keys are RoPE-rephased.
6. The model recomputes its hop under the new evidence.
7. A locked review junction produces the model's own CONTINUE, REVISE or STOP.

What was demonstrated

These are the results of one GPU run (wall time 4,520 s, peak 39.47 GiB). The panel has 12 sealed synthetic directed-link worlds, with worlds 9–11 held out. All gates and thresholds were pre-registered in the code, and every number below was recomputed independently from the log.

Result	Measured
Model-pointer addressing (hit@1 to a valid next-link cartridge)	17/18 (held-out 6/6); chance ≈ 0.09
Controls on the same pool and router	question-only query 0/18 · norm-matched random 0/18 · shuffled keys 2/18 · review-state query 2/18
Cross-world pointer follows its donor world	17/18
Re-entry changes UNKNOWN into a supported correct answer	17/18 (random-query cartridge 0/18, no mount 0/18)
Exact restore of memory after every item and loop	144/144
Closed loop: correct native acceptance	16/27 with pointer addressing vs 3/27 with random queries vs 0/27 without acquisition
Closed loop by condition	one gap 9/9 · fork ambiguity 4/9 · three links 3/9 · held-out 5/9
Trap cartridges accepted (reversed edge, shared node, decoy, target absent)	0/48
Target absent from the bank	0/12 false acceptances

The pre-registered hypotheses H1–H6 passed; H6 passed narrowly (95% CI 0.41–0.76 against a 0.50 threshold).

What is not yet achieved (open research targets)

• STOP is not yet shown with evidence present. All 40 literal STOP decisions occurred only after the search adapter had exhausted the candidates and removed all mounted evidence. With insufficient evidence still mounted, the model chose REVISE.
• Correcting a wrong conclusion is not yet shown. The REVISE → re-acquisition path recovered 0 of 7 cases.
• Decision ownership: retries, unmounting, backtracking and attribution are still mechanical adapter rules. 14 of 27 loops completed as a strict model-driven chain (first-try acceptance, no adapter intervention).
• Scope: generalisation beyond synthetic link worlds, large memory banks, other models and other seeds is untested.

Research goal: a fully closed-loop autonomous recursive engine. It should detect its own knowledge gaps, decide what to retrieve, verify evidence (including direction and contradiction), revise wrong conclusions, change its search strategy, and decide when to stop, with these decisions arising from the model's own state rather than from external control code.

Lineage (short)

Stage	Contribution or finding
7B MAM (TEST560/575)	Hidden-state + K/V memory cartridges with RoPE re-phase
72B (TEST700–785)	Native CUT3 cartridge forging, SHA-sealed multi-cartridge fusion
TEST835	Feedback-driven re-search was not separable from its negative control
TEST841	Vocabulary-mediated (M2S) re-entry works (12/12); direct latent re-entry fails (2/12)
TEST845	The model's UNKNOWN is a reliable gap signal (precision 342/342)
TEST849–864	Native review junction over fixed memory; no evidence acquisition
TEST865	First joint engine: acquisition and review in one loop

Reproduce it

1. Download 865.py at the pinned commit and check its hash.
2. Paste the whole file into one Google Colab cell on a single A100 80 GB.

The cell fetches its locked dependency chain from this repository and refuses to run if any of the 70 git-blob locks, the AST contracts, the label firewall or the TEST864 regression fails.

• Recorded environment: Python 3.13.16, PyTorch 2.11.0+cu130, CUDA 13.0, transformers 5.22.0.
• Run time: about 75 min.
• Artefacts produced: 865_report.json, 865_events.jsonl, 865_addressing.csv, 865_loops.csv and 865_manifest.json.

Independent re-runs, other seeds, other models and critical issue reports are explicitly welcome. Please open an issue in this repository. The source code is authoritative where it differs from the summary.

Licence

AKBASCORE RESEARCH SOFTWARE LICENSE:

• Research, education, reproduction, modification and derivative works are permitted.
• Commercial use is permitted without a separate licence for parties whose combined consolidated annual gross revenue is below USD 50,000,000.
• At or above that revenue a separate commercial licence is required. The threshold is revenue, not valuation.
• Earlier MIT-licensed releases remain under MIT: https://github.com/ceceli33/titan-cognitive-core
• Third-party components keep their own licences, e.g. Qwen2.5-72B-Instruct under the Qwen LICENSE AGREEMENT (Alibaba Cloud); model weights are not redistributed here.
• This is a dated technical disclosure and research record. It is not a peer-reviewed article and asserts no patent rights.

Citation: Akbaş, M. (2026). AKBASCORE Silicon Hippocampus — TEST865: Model-Derived Pointer Addressing, Physical Numerical Memory Re-entry, and Experimental Closed-Loop Review. Technical Disclosure and Reproducibility Record, Interim Research Release. The DOI is assigned by Zenodo when this release is archived.

Keywords: frozen large language model; external memory; numerical memory; KV cache; hidden-state injection; activation memory; memory re-entry; RoPE re-phasing; model-derived retrieval query; pointer addressing; closed-loop reasoning; self-review; evidence acquisition; abstention; Qwen2.5-72B; reproducibility.

AKBASCORE Silicon Hippocampus 1.7 — TEST815: Closed-Loop Evidence Control and Native Hidden-State Routing over SSD-Persistent CUT3 Memory Cartridges in a Frozen Qwen2.5-72B (Live Demo_185)

AKBASCORE Silicon Hippocampus 1.7 — TEST815: Closed-Loop Evidence Control and Native Hidden-State Routing over SSD-Persistent CUT3 Memory Cartridges in a Frozen Qwen2.5-72B (Live Demo_185)

Model-native persistent memory for a frozen LLM, now with blind memory selection and a closed-loop evidence controller. The memory is not text, not a vector-database entry and not a weight update. It is the frozen model's own internal states: written to SSD, sealed with SHA-256, selected by the model's own layer-3 states, re-mounted natively, and read in a bounded loop that decides when to answer and when to abstain.

Status. This release has not been peer reviewed. Every number below comes from published GPU logs and published code (links at the end). The full engineering reference (51 pages) covers architecture, protocols, metrics, reproduction, prior art and licensing.

---

In one minute

Model	Qwen/Qwen2.5-72B-Instruct, frozen: 4-bit NF4 weights, BF16 compute, no training, no fine-tuning, no adapters
Hardware	One NVIDIA A100-SXM4-80GB (Google Colab)
Memory unit	CUT3 cartridge = residual-stream hidden states after block 3 (H3) for every token + key/value tensors of blocks 0–3. 32,768 bytes/token, 1/10 of a full 80-layer KV cache. One .pt file per record, file-level and tensor-level SHA-256, append-only manifest.
Re-mount	Stored H3 is injected at the block-3 boundary (zero input embeddings). The frozen blocks 4–79 rebuild a complete 80-layer memory. No source text enters the prompt.
New in 1.7	(1) Native H3 routing: the question's own layer-3 states select among 22 cartridges, with no labels, titles, retriever or embedding model. (2) Closed-loop evidence controller: read → challenge with a fused pair → recover after UNKNOWN → reverse-order check → answer or abstain; at most 4 native reads.
Bank	22 physical cartridges: 2 real PLOS articles (Europe PMC, DOI- and title-locked) + 20 sealed synthetic decoys
Questions	8 sealed questions + 8 sealed paraphrases = 16 cases; adaptive vs fixed 4-read policy over the same memory

Measured results (three independent A100 executions)

Measurement	Result
Engine integrity gates	1,360 PASS / 0 FAIL in every run
Relevant article in top-2 of 22 cartridges	16/16 (original and paraphrased questions)
Decoy cartridges in top-2	0/16
Relevant article at top-1	13/16 (the 3 misses were recovered by the controller)
Native reads, adaptive vs fixed	36 vs 64 (−43.75 %), with identical decisions in 16/16 cases
Read time, adaptive vs fixed	483.6 s vs 840.0 s (≈ −42 %)
Recovery from an initial UNKNOWN	3/3 cases where routing ranked the wrong article first
Evidence removal: answer-bearing article removed	abstains 6/6
Evidence removal: irrelevant article removed	answers 6/6
Number-and-relation audit (Q2, Q8 + paraphrases)	4/4
Same-run replay (ranking + first answer)	8/8 byte-identical
Across three executions	22/22 cartridge files bit-identical; routing scores, decisions and all answer texts (review export SHA-256 422f51a2…f8b9) identical
Memory never altered by reading	124/124 KV seals (SHA-256 of all 160 K/V tensors before and after every generation)
Weights	unchanged (sentinel), no residual hooks
Native fusion timing (median)	SSD verify 207 ms · host-to-device 9 ms · rebuild from one cartridge 2.42 s · append second cartridge 4.85 s

Example of a final answer (Q2, verbatim, adaptive policy, memory only, no text in the prompt):

"In the study, 98% of DOI-linked resources were successfully retrieved, compared to 78% of URL-linked resources. This indicates DOIs are more reliable for long-term data access."

What is technically different

• Memory = the model's own states, not text. RAG returns passages that must be read again. Here the frozen model re-mounts its own boundary states and recomputes the upper 76 layers natively.
• 10× smaller than KV-cache persistence, still complete. Only H3 + four lower layers are stored; the frozen network reconstructs all 80 layers.
• Composable and order-aware. A second cartridge is appended by recomputing its upper layers with attention to the first. Its lower-layer keys are RoPE re-phased, and SHA-256 proves the first memory is unchanged.
• Label-free selection by the model itself. No retriever, index, embedding model or metadata: layer-3 states of the question are matched against layer-3 states of each record.
• Closed-loop control on native memory. The model's own UNKNOWN on a mounted memory triggers the next evidence action. The controller is measured against a fixed policy, against causal source removal and by replay.
• Audit-grade execution. Every locked source is verified by git blob. Every cartridge load is checked by file and tensor SHA-256. An independent host re-verifies all records after the run.

Run it (Google Colab, A100 80 GB)

1. New notebook → runtime A100 GPU (80 GB), fresh runtime. The 40 GB A100 is rejected by design.
2. Paste Demo_185_part1.py, part2, part3, part4 one below the other into one cell (or paste Demo_185_full.py) and run it.
3. Press RUN in the interface. A full run takes about 40–45 minutes, including the ≈145 GB model download.

The engine alone (815.py, no interface) also runs in a single Colab cell.

⚠️ If the Gradio interface freezes or disconnects

Do not stop the cell and do not restart the runtime. The run continues in the background. Scroll to the Colab cell output:

• every engine line is printed there live, time-stamped;
• when the run ends, all 12 figures are shown directly in the cell and their JPEG download starts automatically;
• every record (real-time engine log, results, manifests, verification, review CSV, figures) stays in /content/AKBASCORE_TEST815_DEMO/sessions/<session>/ (Colab file browser, left panel).

After the run has finished you may stop the cell (■). Then run show_figures_in_cell() in a new cell to show and download the figures again, or launch_interface() to reopen the interface. A browser freeze never affects the engine, because it runs as its own OS process.

Release assets

• AKBASCORE_TEST815_Demo185_Engineering_Reference.pdf: 51-page engineering reference (architecture, equations, protocols, metric definitions, all measured results, reproduction and audit guide, failure modes, prior-art comparison, priority, licensing, items for legal review).
• 12 scientific figures (separate PDF): F1 architecture at a glance · F2 cartridge bank · F3 H3 routing heat map · F4 paraphrase robustness · F5 closed-loop decision map · F6 adaptive vs fixed cost · F7 hypothesis evolution · F8 evidence removal · F9 fact/relation audit · F10 same-run replay · F11 timing, GPU, gates · F12 claims ledger.
• Code and logs: links below, pinned to commit 59af7699defa78421919b04082ef654330a73e93.

Scope

Measured: two real articles and 20 decoys, one model, one GPU type. Open for the next stage: independent human scoring of all answers (the review CSV is exported with empty reviewer columns), larger multi-topic banks, pinned library and model versions, cross-GPU reproduction, and no-memory and text-RAG baselines in the same harness. The controller is a bounded deterministic policy; no claim of general autonomous reasoning is made.

Keywords

model-native memory · persistent neural memory · memory cartridges · hidden-state persistence · residual-stream injection · activation transplantation · KV-cache persistence · KV-cache compression · KV-cache composition · RoPE re-phasing · SSD-backed LLM memory · frozen large language model · external memory without training · retrieval without retriever · label-free routing · hidden-state retrieval · closed-loop evidence control · adaptive retrieval · self-verification · abstention · hallucination control · causal ablation · evidence removal · cryptographic integrity · SHA-256 sealed tensors · reproducible inference · Qwen2.5-72B · NF4 · A100 · Silicon Hippocampus · MAM (Model-Native Associative Memory) · AKBASCORE

Citation

Akbaş, Mustafa (2026). AKBASCORE Silicon Hippocampus 1.7 — TEST815: Closed-Loop Evidence Control and Native Hidden-State Routing over SSD-Persistent CUT3 Memory Cartridges in a Frozen Qwen2.5-72B (Demo_185). GitHub release, 28 October 2026. https://github.com/ceceli33/titan-cognitive-core-v3. Zenodo DOI: to be assigned.

License

AKBASCORE RESEARCH SOFTWARE LICENSE, Copyright © 2026 Mustafa Akbaş:

• Research, education, reproduction, evaluation, modification, forking and derivative works are permitted.
• Commercial use is permitted below USD 50,000,000 combined annual gross revenue (including affiliates). At or above that threshold, a separate commercial license is required.
• Earlier MIT-licensed releases remain MIT.
• Qwen2.5-72B-Instruct and third-party libraries remain under their own licenses.

The LICENSE file controls.

---

Links

This release: code and logs (pinned to commit 59af769)

• Repository: https://github.com/ceceli33/titan-cognitive-core-v3
• Pinned tree: https://github.com/ceceli33/titan-cognitive-core-v3/tree/59af7699defa78421919b04082ef654330a73e93
• TEST815 engine 815.py: https://github.com/ceceli33/titan-cognitive-core-v3/blob/59af7699defa78421919b04082ef654330a73e93/815.py
• TEST815 original A100 log 815.log: https://github.com/ceceli33/titan-cognitive-core-v3/blob/59af7699defa78421919b04082ef654330a73e93/815.log
• Demo_185 live session log (verdict COMPLETE): https://github.com/ceceli33/titan-cognitive-core-v3/blob/59af7699defa78421919b04082ef654330a73e93/Demo_185.log
• ...

AKBASCORE Silicon Hippocampus 1.6 — TEST782: Native Numerical Fusion and Bit-Exact Cross-Session Reload of SSD-Persistent Neural Memory Cartridges in a Frozen Qwen2.5-72B-Instruct

AKBASCORE Silicon Hippocampus 1.6 — TEST782: Native Numerical Fusion and Bit-Exact Cross-Session Reload of SSD-Persistent Neural Memory Cartridges in a Frozen Qwen2.5-72B-Instruct

Silicon Hippocampus 1.6 · TEST782 · live GPU run SH782-20261025-082323 · 25 October 2026
NVIDIA A100-SXM4-80GB · Qwen/Qwen2.5-72B-Instruct (frozen, NF4 weights, BF16 compute) · run verdict: COMPLETE — every stage ran and passed
Researcher and rights holder: Mustafa Akbaş · AkbasCore AI Teknoloji · Mersin, Türkiye

Summary

A frozen 72-billion-parameter language model read two real documents and wrote them into its own internal states. Then the process ended; only two sealed files on an SSD survived.

A new process, running as a different operating-system user, merged the two files into one memory inside the model's numerical space. It read and wrote no text, and it sealed the result.

A third process, running as yet another user who could not even open the source folders, loaded only that sealed memory. It rebuilt the model's 80-layer attention memory bit for bit and explained in plain English what the two documents were, who published them and how they relate.

In the previous release (TEST745), combining memories still went through generated text. In Silicon Hippocampus 1.6, memory consolidation is a numerical operation with a cryptographic lineage.

What was done

1. Writing. The first session (QWEN-1) read two public documents:

• the European Commission page Artificial Intelligence (AI) in Science;
• the Future of Life Institute statement We must pressure AI companies to immediately limit the use of recursive self-improvement.

While reading, the program captured what the frozen model computed internally:

• its internal signal after the fourth layer (H3);
• the keys and values of its first four layers.

Each document became a memory cartridge: a file of the model's own numbers, not text, written to the SSD and fingerprinted with SHA-256. The process then ended and the GPU was released (0 MiB).

2. Why not keep the text? Text must be read again from the beginning every time, and every summary loses something. A cartridge is the model's state after reading, in the model's own format. It is one tenth the size of the model's full attention memory for the same text.

3. Consolidation without text. QWEN-2 started from nothing:

• as a separate Linux user, with no network and no permission to read the documents;
• with access to the two cartridges only.

It verified both cartridges and confirmed that each rebuilt exactly as QWEN-1 had built it (80 of 80 layers identical). It then merged them natively: the frozen model re-processed the second document's memory while attending to the first, as if it had read the two documents one after the other. The result was saved as a new cartridge, MASTER_02, together with the exact recipe needed to rebuild it bit for bit.

4. Blind use. QWEN-3 started from nothing as another user, with no network. The operating system denied it access to the documents, the source cartridges and QWEN-2's files, and it opened none of them. It received only MASTER_02, its manifest and a readiness seal.

It rebuilt all 80 layers; all 160 key and value tensors were identical to QWEN-2's, verified by SHA-256. Asked to express everything in its memory, it stated that there are two separate documents and gave:

• their titles, publishers and complete web addresses;
• their main points: the Commission's October 2025 strategy, RAISE, guidelines and funding programmes; FLI's call to limit recursive self-improvement, independent binding oversight and its warning against a liability shield;
• the author of the statement, Mark Brakel;
• their relation, labelled as its own inference;
• a list of what the memory does not contain.

An analogy. A first reader turns two documents into two sealed memory cards and leaves. A second person, who never sees the documents, fuses the two cards into one card in the reader's own "brain format" and seals it. A third person, who cannot enter the room where the documents are, inserts only the fused card and tells you what both documents say. This is not file copying: the cards are internal states of a transformer, and fusing them means running the frozen model so that the second document is understood in the context of the first.

Measured results

• Processes: five separate OS processes, strictly sequential:
  • PREFLIGHT 34 s
  • QWEN-1 831 s
  • QWEN-2 479 s
  • QWEN-3 729 s
  • CONTROLS 1,134 s
  • 53.5 minutes in total
• Isolation: QWEN-2 ran as akb_q2 (uid 1001) and QWEN-3 as akb_q3 (uid 1002), both in a network namespace. QWEN-3's OS-level isolation was ENFORCED, with zero forbidden file opens. The GPU was back at 0 MiB after every process.
• Cartridges:
  • SOURCE_A: 1,430 tokens, 47.8 MB
  • SOURCE_B: 504 tokens, 17.5 MB
  • MASTER_02: 1,964 tokens, 64.4 MB, where a full 80-layer cache would be 643.6 MB
• Speed of the memory operations:
  • forging: 5.36 s (A) and 1.73 s (B)
  • native fusion: 8.72 s
  • MASTER consolidation: 0.47 s
  • write and seal: 0.64 s
  • independent 80-layer rebuild in QWEN-3: 6.13 s
• GPU memory: largest PyTorch peak 40.8 GiB on one A100 80 GB.
• Bit-exact parity — 80/80 layers:
  • in QWEN-2, native vs SSD reload and on a second reload;
  • in QWEN-3, a new process under a new user;
  • in CONTROLS;
  • both source cartridges, across processes.
• Negative control: a naive one-pass rebuild reaches only 4/80 layers. The sealed rebuild recipe is what makes cross-process exactness possible.
• Integrity: all seven mandatory MASTER checks PASS — file SHA-256, tensor SHA-256, manifest round trip, parent SHA links, reload integrity, 80-layer numerical parity and independent reload. All 16 CPU corruption simulations behaved as expected, and the weights were unchanged in every session.
• MASTER_02 SHA-256: d8d56ce60abfd8ba8001ece8c21fff13a5586e37d3fa14a903bf69a2aa7106bf
• Reproducible language: QWEN-3's six answers are byte-identical to those of an independent control process that mounted the same MASTER.

What the controls showed

The same sealed questions were answered with no memory, with each document alone and with the MASTER. Counting the source-specific words in the open answer:

• No memory: 2 words specific to the Commission page, 1 specific to the FLI statement.
• Commission page only: 161 and 3.
• FLI statement only: 6 and 90.
• MASTER_02, read blind by QWEN-3: 70 and 29 — both documents.

Asked about the "first" and the "second" document, the MASTER answers with Commission vocabulary (80 / 1) and with FLI vocabulary (2 / 59) respectively. The order and separation of the two documents survive inside one fused memory. Asked about medieval castles, every condition answers UNKNOWN.

The layer-by-layer heat map (Figure 4) shows where the fusion acts. The first document's states are untouched in all 80 layers. The second document's states are rebuilt from layer 5 upward while attending to the first — a direct measurement of native fusion inside the model.

Why this matters

• Memory as a first-class object for frozen models. Knowledge can be:
  • written once;
  • stored compactly on disk;
  • verified like any critical file;
  • used later by a different process, without retraining and without putting the source text back into the prompt.
• Consolidation without text. Memories are combined by the model itself in its own representation, instead of through repeated, lossy summaries.
• Exactness you can audit. File, tensor and metadata fingerprints and a sealed rebuild recipe make the memory bit-exactly reproducible across processes.
• Isolation you can audit. Operating-system users, permissions, network isolation and access probes make "the reader had only the memory" a recorded fact.

This opens practical directions:

• persistent memory banks for AI systems;
• memory sharing between sessions and agents;
• verifiable provenance of what a model knows at answer time;
• consolidation that runs in the model's own representation.

Result categories

• 1 · Physical isolation of the three sessions: PASS.
• 2 · Baseline native numerical MASTER (seven mandatory checks): PASS.
• 3 · Autonomous MASTER (DrA decision): next stage, recorded as NOT CREATED. QWEN-2's own stated decision was STORE; it was recorded and did not gate the run.
• 4 · New semantic synthesis: next stage, recorded as NOT EVALUATED. An independent, source-grounded review of the texts comes next. A first source check found no contradiction with the sources.

Next-stage refinements:

• independent semantic review of all answers;
• a larger output budget for the panel questions (three answers used their full 384 tokens);
• more than two cartridges;
• repetition on other GPU runtimes.

Bit-exact parity is a statement about numbers, not about meaning; the language results are reported for what they are.

Files and links

Release assets:

• research record AKBASCORE_TEST782_Research_Record.pdf
• [FIGURES PDF FILE NAME] — twelve figures

Source code, pinned to commit 343471d1783e5a888db5697a9ad6e485276a0b00. For Google Colab, paste Parts 1–4 one below the other into one cell:

• Part 1: https://github.com/ceceli33/titan-cognitive-core-v3/blob/343471d1783e5a888db5697a9ad6e485276a0b00/QWEN_1_2_3_part1.py
• Part 2: https://github.com/ceceli33/titan-cognitive-core-v3/blob/343471d1783e5a888db5697a9ad6e485276a0b00/QWEN_1_2_3_part2.py
• Part 3: https://github.com/ceceli33/titan-cognitive-core-v3/blob/343471d1783e5a888db5697a9ad6e485276a0b00/QWEN_1_2_3_part3.py
• Part 4: https://github.com/ceceli33/titan-cognitive-core-v3/blob/343471d1783e5a888db5697a9ad6e485276a0b00/QWEN_1...

AKBASCORE Silicon Hippocampus — Frozen Qwen2.5-72B: Persistent CUT3 Neural Memory, SSD-Backed Physical Cartridges, Hierarchical Cognitive Synthesis, Closed-Loop Reasoning and Cryptographically Sealed Memory Consolidation (TEST745)

AKBASCORE SILICON HIPPOCAMPUS — TEST745

Persistent Neural Memory | Frozen 72B Transformer | Physical CUT3 Cartridges | Hierarchical Synthesis | Closed-Loop Analysis | Cryptographically Sealed Memory

Author: Mustafa Akbaş
Organization: AkbasCore AI Teknoloji
Location: Mersin, Türkiye
Research date: 22 October 2026
Status: Completed experimental milestone — Interim Research Seal
Copyright © 2026 Mustafa Akbaş

This release documents a complete experimental execution of AKBASCORE Silicon Hippocampus on a frozen Qwen2.5-72B-Instruct model, followed by a successful live Gradio demonstration and independent verification of the physical memory artifacts.

The experiment investigates a fundamental question in artificial intelligence:

Can a large language model preserve internal numerical representations as physical memory on SSD, reload them into its computational architecture, synthesize information across successive memory generations, examine its own hypotheses through a closed loop, and consolidate new knowledge without changing its neural weights?

TEST745 demonstrates a functioning experimental implementation of this architecture.

The result is not merely a retrieval interface, a prompt containing previously saved text, or a fine-tuned model. It is a system in which selected transformer internal states are captured, stored as independent physical cartridges, cryptographically verified, reloaded, injected into a frozen model, read through model computation, and used to construct new generations of physical memory.

1. Experimental architecture

Model: Qwen2.5-72B-Instruct

Hardware: NVIDIA A100-SXM4-80GB

Precision: NF4 frozen weights, BF16 computation

Transformer layers: 80

Hidden dimension: 8192

Attention heads: 64

KV heads: 8

Head dimension: 128

Intervention boundary: CUT3

Physical cartridge: H3 hidden state + K/V tensors from layers 0–3

Reconstructed computation: transformer layers 4–79

Storage: SSD-backed serialized PyTorch tensor cartridges

Integrity: SHA-256 file hashes, tensor seals, parent identities and post-run verification

The model's weights remain unchanged.

At the CUT3 boundary, each cartridge preserves a portion of the model's numerical internal state. This state is written to SSD and can later be reloaded, verified and mounted into the original model architecture.

The remaining transformer layers reconstruct the upper attention memory, allowing the model to generate responses from the restored cartridge state.

The mechanism is related to KV-cache reuse and hidden-state intervention, but combines them into an independently persisted, verifiable memory-cartridge workflow.

It does not eliminate the transformer: the upper layers and token generation still execute.

2. Eleven physical memory cartridges

The experiment uses an actual aviation investigation conducted by the Croatian Air, Maritime and Railway Traffic Accident Investigation Agency (AIN).

The preliminary investigation report is divided into three consecutive sections and converted into three physical source cartridges:

C01 — Preliminary report segment 1

C02 — Preliminary report segment 2

C03 — Preliminary report segment 3

These represent three portions of one official report, not three independent publications.

The model then reads the source cartridges through the physical CUT3 mechanism.

Their generated readouts are synthesized into three new memory bodies and physically stored:

S01 — Synthesis of C01 and C02

S02 — Synthesis of C02 and C03

S03 — Synthesis of C01 and C03

A further synthesis generation is constructed:

H01 — Synthesis of S01 and S02

H02 — Synthesis of S02 and S03

H03 — Synthesis of S01 and S03

The H-level cartridges are read again to construct the initial integrated investigation hypothesis.

The critical distinction is that each synthesis is generated from the model's textual readouts of physically mounted cartridges and subsequently forged into a new numerical cartridge.

This experiment does not claim direct BF16 tensor fusion between different cartridges.

The system therefore demonstrates hierarchical physical memory creation with text-mediated semantic synthesis.

3. Eight-round closed-loop analysis

After the hierarchical memory stages, the model produces an initial investigation hypothesis and completes eight consecutive review rounds.

The objective is to examine possible causal explanations, competing hypotheses, evidential limitations and unresolved uncertainties before accessing the official final investigation report.

The original hypothesis and all eight review outputs are preserved.

The experiment successfully executed every round.

The resulting measurements also expose a limitation: later iterations become highly similar to previous text, rather than demonstrating eight independently verified improvements.

This is an important part of the scientific record.

The closed-loop mechanism operated successfully; autonomous correction and improved causal accuracy remain separate research questions.

4. C11 — Cryptographically sealed blind master

Following the closed-loop analysis, the system creates C11, a new physical CUT3 master cartridge.

C11 contains the consolidated pre-outcome investigation analysis.

The cartridge is written to SSD and sealed with SHA-256.

Before the official final report is downloaded, the model answers three predefined investigation questions using C11:

1. The best-supported causal account, distinguishing initiating events, crew actions and uncertainties.

2. Two plausible competing explanations and the evidence required to distinguish them.

3. Conclusions that remain unsupported or unknowable from the available evidence.

The physical C11 cartridge, its integrity identity and the blind answers are preserved before the final report is unlocked.

This provides a verifiable chronological boundary between the model's preliminary analysis and the subsequently introduced official findings.

It does not exclude possible pretraining exposure to relevant public information.

C11 physical file SHA-256:

3f78c672465975d1170e57ab70a85af1b7fa5f1ddc902ec80f2670a48f045eea

5. C12 — Post-outcome memory consolidation

After C11 is sealed, the official final investigation report is introduced.

The model compares its earlier analysis against the report's findings and generates a self-audit identifying agreements, discrepancies and unresolved issues.

This self-audit is model-generated and must not be confused with independent expert evaluation.

The resulting material is committed to a second physical master cartridge:

C12 — POST-OUTCOME MASTER

C12 is not an overwrite of C11.

It is a separately created physical cartridge that records C11's exact file SHA-256 as its parent.

C11 remains unchanged.

C12 physical file SHA-256:

fdd5add305d71d0a78c04f92a8d0724c19443d81ad2756b9f96160dd667d4e5a

Human expert review remains pending.

This stage demonstrates a traceable, cryptographically linked memory lineage from a sealed pre-outcome state to a new post-outcome state.

6. Measured results

The completed TEST745 and live demonstration produced:

• 11 physical CUT3 memory cartridges.
• Three source cartridges, three subsystem synthesis cartridges and three cross-system synthesis cartridges.
• One sealed blind master, C11.
• One separate post-outcome master, C12.
• Eight completed closed-loop review rounds.
• 15/15 completed live Gradio stages.
• 11/11 physical cartridge file, tensor and body integrity verifications.
• Six high-resolution scientific figures.
• A 70-file SHA-256 run manifest.
• Successful verification of the C11 → C12 parent relationship.
• Frozen model-weight integrity checks.

The cartridge files range from approximately 25.9 MB to 61.3 MB in the measured session.

The CUT3 tensor payload stores 32,768 bytes per memory row, compared with 327,680 bytes per row for a full 80-layer BF16 K/V cache under the same architectural dimensions.

This comparison concerns the stored tensor representations, not total model memory, end-to-end execution speed or overall computational efficiency.

All technical completion results must be distinguished from semantic accuracy.

The experiment does not assign an independently validated causal correctness score to the aviation investigation answers.

7. What the six scientific figures show

Figure 1 — General Architecture

The complete memory hierarchy, from the official preliminary report through C01–C03, S01–S03 and H01–H03 to the closed-loop analysis, C11 blind master, official outcome and C12.

Figure 2 — Physical Memory Cartridge

The five-stage forge, persist, reload, inject/rebuild and read mechanism, including actual cartridge sizes, tensor dimensions, memory rows and verification status.

Figure 3 — Hierarchical Synthesis

The physical parent-child relationships, source readouts, synthesis token counts, cartridge creation times and the distinction between numerical memory storage and text-mediated synthesis.

Figure 4 — Eight-Round Closed Loop

The initial hypothesis and eight subsequent reviews, with observed token lengths, text similarity and uncertainty counts. It documents both the successful execution and the limits of iterative self-revision.

Figure 5 — Blind Investigation and Official Outcome

The C11 sealing boundary, three blind answers, subsequent introduction of official findings and model self-audit. The initial figure set contains an inconsistent report-download clock label; the original engine events and sealed records are authoritative.

Figure 6 — C11 to C12 Memory Consolidation

The immutable C11 master, official final report, model self-audit, pending human-review boundary, new C12 master and verified SHA-256 parent lineage.

Together, these figures provide a compact visual re...

AKBASCORE PROMETHEUS — Persistent Neural Memory and Cross-Document Scientific Synthesis in Frozen Qwen2.5-72B: CUT3 Hidden-State Injection, SSD-Resident Memory Cartridges, Native Transformer Reconstruction and Causal Hypothesis Generation (TEST730)

AKBASCORE PROMETHEUS — TEST730

Persistent Neural Memory, Physical Cartridge Injection, Cross-Document Scientific Synthesis and Scientific Hypothesis Generation in a Frozen 72-Billion-Parameter Transformer

Research continuation of AKBASCORE Silicon Hippocampus / Model-Native Associative Memory (MAM)

Author and Developer: Mustafa Akbaş

AKBASCORE AI Technology

October 20, 2026

Copyright © 2026 Mustafa Akbaş.

RESEARCH CONTINUITY AND PRIOR DISCLOSURE

This release documents the next experimental stage of AKBASCORE Silicon Hippocampus, an independently developed research program investigating persistent numerical memory inside frozen transformer architectures.

It is a direct continuation of:

Research Record III — AKBASCORE Silicon Hippocampus v1.4

https://doi.org/10.5281/zenodo.23434686

The preceding record established the physical implementation of persistent numerical memory cartridges in Qwen2.5-72B-Instruct, including model-native hidden-state injection, layer-specific reconstruction, persistent storage, positional restoration, and exact memory-integrity controls.

PROMETHEUS builds on that foundation.

The central research question has advanced from whether a frozen transformer can physically reload and reconstruct previously stored internal numerical states to whether the same architecture can support a controlled workflow involving multiple independent scientific sources, model-generated interpretations, cross-document synthesis, a newly forged MASTER memory cartridge, and subsequent scientific questions without retraining the underlying model.

This release therefore documents an additional experimental capability of the existing MAM architecture rather than introducing an unrelated memory engine.

The original physical memory mechanism remains the computational foundation.

THE ENGINEERING PROBLEM

A conventional large language model ordinarily processes external information through a prompt or active context window.

Retrieval-augmented generation retrieves external material and supplies it to the model as text. Fine-tuning and parameter-efficient adaptation alter model parameters or introduce trained adapters. Ordinary K/V caching preserves attention states associated with an active inference sequence.

AKBASCORE investigates a different implementation route.

The objective is to separate memory creation from memory use.

Source material is processed once through a frozen transformer. Selected internal numerical representations are extracted and committed to persistent storage. The source text does not need to be supplied again with each later question.

When the memory is needed, the system loads the saved numerical checkpoint, restores the necessary lower-layer attention state, injects the saved hidden-state stream at a defined transformer boundary, and allows the unchanged upper transformer layers to reconstruct the remaining operational memory.

The model then answers questions through its native computational pathway.

This is not a claim that the transformer has acquired new permanent parameter knowledge. The persistent memory resides in external numerical artifacts that can be loaded into the model's computation.

The distinction is fundamental: the stored object is neither an ordinary document nor a newly trained set of model weights.

DEVELOPMENT OF THE SILICON HIPPOCAMPUS ARCHITECTURE

The AKBASCORE research line progressed through model-specific implementations and controlled experiments.

Research Record I — Qwen2.5-7B:

https://doi.org/10.5281/zenodo.23381336

Research Record II — Mistral-7B / Silicon Hippocampus v1.4:

https://doi.org/10.5281/zenodo.23418927

Research Record III — Qwen2.5-72B / Silicon Hippocampus:

https://doi.org/10.5281/zenodo.23434686

These records document the progression from smaller frozen transformer experiments to persistent, model-native memory reconstruction in a 72-billion-parameter architecture.

The implementations use model-specific intervention boundaries.

For example, the Mistral-7B implementation uses a CUT6 boundary, while the Qwen2.5-72B implementation uses CUT3.

These boundaries are not presented as universally interchangeable. Their numerical behavior and reconstruction requirements depend on the target architecture.

PROMETHEUS uses the established Qwen2.5-72B CUT3 implementation and extends the experimental workflow to three independently stored academic sources and a synthesized MASTER cartridge.

FROZEN MODEL AND EXECUTION ENVIRONMENT

The experimental model is:

Qwen/Qwen2.5-72B-Instruct

Architecture:

80 transformer layers.

Hidden dimension: 8,192.

Query attention heads: 64.

Key/value attention heads: 8.

Head dimension: 128.

The model uses NF4 four-bit weight quantization with BF16 computation and attention K/V representations.

The experimental execution environment includes an NVIDIA A100-SXM4-80GB GPU.

The model weights remain frozen.

No fine-tuning, LoRA training, gradient-based memory writing, or intentional modification of the pretrained model parameters is part of the demonstrated PROMETHEUS protocol.

Memory is written, stored, reloaded, and activated through the existing model-native computational mechanism.

THE PHYSICAL MEMORY CARTRIDGE

The essential AKBASCORE MAM object is a layer-bounded numerical memory cartridge.

For Qwen2.5-72B, the selected intervention boundary is CUT3.

Each cartridge preserves:

The hidden-state stream H3, corresponding to the output of transformer layer 3. The key tensors of layers 0–3. The value tensors of layers 0–3. The associated memory positions, identity information, and integrity records required by the implementation.

The saved artifact is deliberately smaller than a complete 80-layer operational K/V memory.

The remaining attention states are reconstructed when the cartridge is mounted.

A simplified description is:

SOURCE TEXT

→ TOKENIZATION

→ FROZEN TRANSFORMER FORWARD COMPUTATION

→ EXTRACTION OF H3 AND L0–L3 K/V

→ PHYSICAL CARTRIDGE FILE

→ SSD PERSISTENCE

→ VERIFIED RELOAD

→ CUT3 HIDDEN-STATE INJECTION

→ FROZEN L4–L79 RECONSTRUCTION

→ NATIVE MODEL ANSWER GENERATION

The lower-layer numerical checkpoint and the frozen model jointly define the memory read mechanism.

The cartridge is not an independently intelligent object. It requires the compatible transformer, positional conventions, tensor formats, and reconstruction procedure.

MEMORY WRITING AND PERSISTENCE

During the write phase, the source text is converted into tokens and processed by the frozen model.

The implementation captures the hidden-state output at the selected CUT3 boundary together with the lower-layer K/V tensors.

The resulting numerical representations are serialized to a physical file on persistent storage.

Each cartridge is associated with a physical identity and SHA-256 integrity information.

The write process does not require changing the pretrained weights.

The memory can subsequently be loaded from its physical file rather than regenerating the original source context from text for each question.

The PROMETHEUS experiment uses four physical cartridges:

P01 — First academic source.

P02 — Second academic source.

P03 — Third academic source.

MASTER — Model-generated cross-document synthesis memory.

The three source cartridges and the MASTER cartridge are distinct physical artifacts.

NATIVE MEMORY RELOAD AND TRANSFORMER RECONSTRUCTION

At reload time, the saved numerical checkpoint is restored.

The implementation reconstructs the necessary positional alignment, including rotary positional embedding treatment where required.

The saved H3 stream is placed at the corresponding internal layer boundary.

The original frozen transformer then performs the remaining computation through layers 4–79.

This reconstructs the upper-layer K/V representations required for normal attention-based generation.

The process uses the model's own transformer operations rather than substituting an external answer engine.

In the demonstrated architecture, the physical cartridge represents approximately 10% of the corresponding full 80-layer memory footprint, with the remainder reconstructed at mount time.

This is a storage-versus-computation tradeoff.

It reduces persistent storage requirements relative to saving the complete operational attention memory, while retaining the cost of upper-layer reconstruction and runtime GPU memory allocation.

THREE REAL SCIENTIFIC PUBLICATIONS

PROMETHEUS uses three real academic publications retrieved through Europe PMC.

The experiment verifies the available source metadata and uses licensed full-text excerpts as the source material.

P01

Generative AI in creative education: baseline-linked evidence on learning processes, artistic performance, and authorship.

PMCID: PMC13672588

Source body: 1,924 tokens.

P02

The critical-thinking paradox in generative AI-integrated learning: distinguishing efficiency from cognitive depth.

PMCID: PMC13521781

Source body: 1,987 tokens.

P03

Catalysts of Change: Using AI to Lower the Activation Energy for Developing Gamified Learning Experiences in Health Profession Education.

PMCID: PMC13043820

Source body: 2,036 tokens.

The three publications address different but related aspects of artificial intelligence in education.

They provide material concerning creative learning, perceived versus actual educational outcomes, critical thinking, cognitive depth, and AI-assisted instructional design.

The source excerpts are preserved as separate numerical cartridges.

The original article identities, source attribution, license information, and excerpt SHA-256 values are documented in the accompanying figures and experimental records.

FROM INDEPENDENT SOURCES TO MODEL-GENERATED REFLECTION...

AKBASCORE Silicon Hippocampus v1.5 — Direct Internal-State Injection and Persistent Numerical Memory in Frozen Qwen2.5-72B

AKBASCORE SILICON HIPPOCAMPUS — RESEARCH RECORD III

Direct Intervention in Transformer Computation Through Persistent Model-Native Numerical Memory

Mustafa Akbaş
AkbasCore AI Teknoloji
Mersin, Türkiye
Copyright © 2026 Mustafa Akbaş

This release presents a working experimental engine that intervenes directly in the internal computational pathway of a frozen 72-billion-parameter transformer.

The central innovation is not KV-cache storage, prompt caching, retrieval-augmented generation, or external text memory.

AKBASCORE Silicon Hippocampus operates at a fundamentally different intervention point: the model's own internal hidden-state representations.

Rather than repeatedly supplying stored text to a transformer, the system captures numerical states generated inside the model, preserves them as independently addressable physical memory cartridges, and subsequently reinjects them at a precisely defined transformer layer boundary.

The downstream transformer layers then resume computation from the restored internal state.

The original pretrained model weights remain unchanged.

This distinction is fundamental.

AKBASCORE is not designed as a conventional cache-reuse mechanism. Although attention key/value tensors participate in preserving and reconstructing the computational state, they are supporting components of a deeper architectural intervention.

The defining operation is the direct restoration of model-native hidden representations into the transformer's internal computation.

FROM 7 BILLION TO 72 BILLION PARAMETERS

This release represents the third documented stage of the AKBASCORE memory research program.

Research Record I — Qwen2.5-7B: Native Numerical Memory and Cognitive Cartridge Foundation

https://doi.org/10.5281/zenodo.23381336

Research Record II — Mistral-7B: Silicon Hippocampus v1.4, Layer-Specific Intervention and Append-Only Memory Consolidation

https://doi.org/10.5281/zenodo.23418927

Research Record III — Qwen2.5-72B: Direct Internal-State Injection and Physical Numerical Memory Reconstruction

The preceding research established model-specific intervention methods in smaller frozen transformers.

The present implementation extends the physical cartridge mechanism to Qwen2.5-72B-Instruct, demonstrating its operation under substantially greater model size and internal memory requirements.

THE ARCHITECTURAL BREAKTHROUGH

The conventional transformer inference pathway begins with token representations and propagates their computation through successive neural layers.

AKBASCORE introduces a different operational possibility.

A previously computed internal representation can be preserved outside the model and later restored directly into its intermediate computational pathway.

In the Qwen2.5-72B implementation, the intervention boundary is transformer layer 3, designated CUT3.

The system captures the layer-3 hidden representation, H3, together with the lower-layer numerical states necessary for controlled reconstruction.

The extracted representation becomes a persistent physical memory cartridge.

When the cartridge is mounted, the stored H3 representation is restored at the CUT3 boundary.

The remaining 76 transformer layers continue computation from that injected state.

The model is not retrained.

Its original weights are not modified.

The stored source text does not need to be reintroduced as an ordinary prompt.

This is the central engineering distinction: the system preserves and restores an intermediate numerical state of transformer computation rather than merely retrieving text or replaying a conventional attention cache.

Persistent key/value tensors are used where required for positional consistency, continuity, and reconstruction. They do not define the scientific contribution.

The central contribution is direct, layer-specific intervention in the model's internal representational flow.

A WORKING PHYSICAL MEMORY ENGINE

The implementation operates with:

Qwen2.5-72B-Instruct.

80 transformer layers.

8,192-dimensional hidden representations.

64 query attention heads.

8 key/value attention heads.

128-dimensional attention heads.

Frozen NF4-quantized model weights with BF16 computation.

Direct H3 intervention at CUT3.

An NVIDIA A100 80GB GPU.

Three independent numerical memory cartridges were created from 10,000-token excerpts of three public-domain literary works:

Cartridge A — Pride and Prejudice.

Cartridge B — Frankenstein.

Cartridge C — The Adventures of Sherlock Holmes.

Each physical cartridge occupies 328,698,863 bytes.

The cartridges were independently persisted, reloaded, assembled, reordered, and verified.

When all three cartridges are mounted, the reconstructed operational memory contains 30,031 token positions.

The experiment reconstructs the downstream computational states across all 80 transformer layers while preserving the original frozen model.

The numerical cartridges are not fine-tuned adapters, external embedding vectors, textual summaries, or modifications to the pretrained weights.

They are stored representations extracted from the model's own internal computation.

EXPERIMENTAL EVIDENCE

The published experimental engine and the subsequent live demonstrator report:

11/11 scripted physical protocol trials completed.

17/17 engine checks passed.

8/8 append integrity checks passed.

Exact SHA-256 preservation of previously mounted numerical key/value states across all 80 layers.

Three independently verified cartridge files.

Successful reconstruction of the combined A+B+C memory.

Verification that the model-weight sentinel remained unchanged.

Live examination of the reconstructed 80-layer GPU memory.

The experiments also record the computational cost of reconstruction.

Mounting the first cartridge required approximately 17.7 seconds for reconstruction, while the measured third-cartridge append required approximately 74 seconds.

These timings reflect actual reconstruction work, not an instantaneous cache switch.

The experimental results establish the physical feasibility and integrity of the internal-state restoration mechanism at the tested scale.

They do not yet establish that all observed natural-language answers were causally produced by the cartridges.

Because the demonstration uses widely known literary works, knowledge acquired during pretraining cannot be excluded. Controlled experiments with previously unseen information remain necessary to establish independent semantic transfer and reasoning.

THE SCIENTIFIC SIGNIFICANCE

The central question is no longer restricted to whether information can be stored outside a language model.

The deeper question is whether a transformer's internal numerical computation can be interrupted, externalized, persisted, and later resumed through direct state restoration.

AKBASCORE provides a working experimental implementation of this intervention pathway in a frozen 72-billion-parameter transformer.

The potential implications extend beyond conventional document retrieval.

If future research establishes reliable causal knowledge transfer, conflict resolution, scalable addressing, and adaptive reasoning, persistent internal-state cartridges could provide a foundation for modular, long-lived numerical memory in transformer systems.

The present release does not claim those future capabilities have already been achieved.

It documents a specific, reproducible engineering advance: direct hidden-state reinjection, persistent physical numerical cartridges, and integrity-verified reconstruction of internal transformer computation at 72B scale.

SOURCE CODE AND REPRODUCTION

Complete working implementation:

https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/MAM_full_QWEN_72B.py

For researchers working from mobile devices, the same implementation is divided into three sequential sections. The sections are intended to be concatenated in a single Google Colab code cell and executed with one RUN.

Part 1:

https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/MAM_part1_QWEN_72B.py

Part 2:

https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/MAM_part2_QWEN_72B.py

Part 3:

https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/MAM_part3_QWEN_72B.py

Experimental log 1:

https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/MAM_LOG1_QWEN_72B.log

Experimental log 2:

https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/MAM_LOG2_QWEN_72B.log

Underlying physical engine:

https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/709.py

Underlying experimental verification:

https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/709.log

INTELLECTUAL PROPERTY AND RESEARCH RECORD

This release forms part of the chronological public technical disclosure of the AKBASCORE research architecture, including model-native numerical cartridge construction, direct hidden-state intervention, layer-specific reinjection, persistent numerical memory, and incremental reconstruction.

The original copyrightable software, documentation, and associated research materials are governed by the applicable AKBASCORE RESEARCH SOFTWARE LICENSE.

Earlier MIT-licensed materials retain their original permissions. Third-party model weights, libraries, and dependencies remain subject to their respective licenses.

The current license permits specified research, educational, experimental, and commercial uses under its conditions. Commercial use by organizations meeting or exceeding the USD 50 million consolidated annual gross revenue threshold requires a separate commercial license.

The technical disclosure establishes a public research record; it does not by itself confer patent rights or exclusive rights over independently developed scientific metho...

AKBASCORE Silicon Hippocampus v1.4 — Native Numerical Memory Cartridge Injection in Frozen Mistral-7B: Layer-Specific Intervention and Append-Only Memory Consolidation

AKBASCORE Silicon Hippocampus v1.4 — Mistral studies a memory architecture for a frozen Mistral-7B-Instruct-v0.3. Each fact is turned by the model itself into a separate numerical memory cartridge. Cartridges are placed into the model's internal computation path at a specific layer boundary and appended to an existing attention memory, and the deeper layers are then recomputed for each new cartridge. The model's weights never change. This release is the second-model experimental continuation of the first v1.4 implementation, published on Qwen2.5-7B-Instruct (Research Record I, see Research Sources).

Why this is not standard KV caching

A standard KV cache can also answer later questions without re-reading the source text, so "the text is not given again" is not the distinguishing property. The difference lies in how the memory is built:

• Independent cartridges. Each fact is read alone (instruction prefix + one fact), never together with other facts.
• Layer-boundary intervention. The hidden state after layer 6 is stored, together with the keys and values of layers 0–6.
• Append-only consolidation. New rows are added. Earlier memory rows are never modified, and this is checked bitwise after every append.
• Upper-layer recomputation. Layers 7–31 of each new fact are recomputed from the stored checkpoint, attending to the facts already in memory.

The computation leaves the standard transformer forward pass at two points:

1. Lower layers (L0–L6). These rows are written directly from the isolated read instead of being computed by a joint pass.
2. Consolidation pass. It receives zero input embeddings. Its layer-6 output is replaced by the stored checkpoint, so layers 7–31 run on a transplanted residual state instead of token input.

The individual building blocks (KV reuse, rotary re-phasing, residual-stream patching) are known in the literature. The contribution is their specific composition, its bit-level verification, and its adaptation to a second architecture.

Mistral computation path: FORGE → WRITE L0–L6 → INJECT H6 → REBUILD L7–L31 → ANSWER

1. FORGE. The frozen model reads one fact alone. The cartridge keeps the layer-6 output H6 (4096 values per token) and the K/V of layers 0–6.
2. WRITE L0–L6. The cartridge's K/V rows are appended to memory layers 0–6. Keys are re-phased (RoPE) to their new positions. The append runs on the native TEST659 BF16 CUDA kernel append_kv, which is gated bitwise equal to torch.cat.
3. INJECT H6. A forward pass over the new rows with zero input embeddings. A hook replaces the layer-6 output with the stored H6.
4. REBUILD L7–L31. Layers 7–31 compute keys and values for the new rows while attending to the existing memory.
5. ANSWER. Only the question template is fed. Greedy decoding, at most 16 new tokens (TEST560 MAX_NEW).

One research approach, two tensor geometries

	Qwen2.5-7B-Instruct (Research Record I)	Mistral-7B-Instruct-v0.3 (this release)
Layers / hidden size / KV heads	28 / 3584 / 4	32 / 4096 / 8
Intervention boundary	CUT3 — H3 + K/V of layers 0–3	CUT6 — H6 + K/V of layers 0–6
Recomputed layers	4–27	7–31

The same procedure is re-instantiated for each model's tensor geometry and calibrated boundary. Cartridges are model-specific: hidden size, KV-head layout, layer count and tokenizer all differ, and no cartridge was transferred between the two models. What transfers is the architecture-adapted method for building and injecting memory.

Verified evidence (run MAM14M-20261016-105852-0001, NVIDIA A100-SXM4-40GB)

• Frozen weights. The TEST560 sentinel, the all-parameter guard and the trainable-tensor count (0) were unchanged before and after the run. The full-weight SHA-256 was recorded at start-up.
• Native BF16 CUDA KV append. The native path was bitwise identical to the pure-PyTorch reference path for both scenarios.
• Bitwise unchanged previous memory rows. This held after every append. The layer 0–6 rows were bitwise equal to the re-phased cartridge rows.
• Model-specific CUT6/H6 intervention. H6 is injected at the layer-6 output, and the zero-embedding consolidation passes were recorded by a read-only pre-hook.
• Independent cartridge construction. One isolated forward pass per fact (prefix + fact, no cache, no earlier fact).
• Source-text-free question input. Questions are answered from the cartridge memory with only the question template as input.
• Counterfactual effect changes. Replacing cartridge C with a counterfactual C′ changes the final answers to Temporal stasis (AKBASCORE) and Slow-motion perception (Matrix).
• Strict TEST686 evaluation (primary). Exact match after normalisation, executed verbatim from 686.py. Strict counts are identical for the cartridge memory and for the joint-read text control.
• Secondary answer-content audit. Reports whether the expected answer is present, whether it is at the head, whether extra text follows, and whether the 16-token limit was reached. It is reported next to the strict result, never instead of it.
• 198/198 question and 36/36 chain parity with the sealed TEST686 log. Every raw answer and strict status was reproduced exactly. This is a reproducibility result, not an accuracy figure.

Chain results.

• Matrix: the three-step chain is a strict PASS (MX-71 → Kung Fu knowledge → Bullet-dodge ability).
• AKBASCORE: hops 1 and 2 pass. Hop 3 is a strict FAIL: the raw output Reversal of time flow (or UNKNOWN if the information provided does contains the expected answer at its head, but the extra text and the 16-token limit prevent a strict exact match. The direct EFFECT and FINAL questions fail strictly for the same reason.

Scope. The experiments rest on two small fictional scenarios with three cartridges each. They are not evidence of general reasoning ability, autonomous multi-hop planning or reliable abstention. Mistral gave no strict abstention on the 43 unanswerable direct-question rows.

Release assets

• AKBASCORE_Silicon_Hippocampus_v1.4_Mistral_Research_Paper.pdf — Research Record II, paper version 1.0. Its own DOI is pending publication.

Research Sources

• Repository: https://github.com/ceceli33/titan-cognitive-core-v3
• Mistral Full Demo: https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/Mistral_full_v1.4.demo.py
• Mistral Part 1: https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/Mistral_part1_v1.4.demo.py
• Mistral Part 2: https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/Mistral_part2_v1.4.demo.py
• Mistral Part 3: https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/Mistral_part3_v1.4.demo.py
• Mistral Experimental Log: https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/MISTRAL_v1.4_Demo.log
• Mistral Sealed TEST686: https://github.com/ceceli33/titan-cognitive-core-v2/blob/main/686.py
• Mistral TEST686 Log: https://github.com/ceceli33/titan-cognitive-core-v2/blob/main/686.log
• Research Record I — Qwen (Zenodo, previous record; not the DOI of this release): https://doi.org/10.5281/zenodo.23381336

License and copyright

Copyright © 2026 Mustafa Akbaş. Released under the AKBASCORE RESEARCH SOFTWARE LICENSE: https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/LICENSE

• Research, education, reproduction, modification and derivative works are permitted.
• Commercial use is permitted without a separate license where the combined consolidated annual gross revenue, including affiliates, is below USD 50,000,000. At or above this threshold, commercial use requires a separate commercial license from the copyright holder.
• Material previously released under the MIT License remains under the MIT License.
• Mistral-7B-Instruct-v0.3, Qwen2.5-7B-Instruct and all other third-party models, libraries and dependencies remain the property of their respective owners and are governed by their own licenses.