TEST878 · Gradio Edition — AKBASCORE Silicon Hippocampus

A frozen 72-billion-parameter language model keeps a lived experience as its own internal state on disk, and that stored experience changes how it decides later, in a situation it has never lived.

This release adds three things to the TEST878 result already archived on Zenodo:

1. An independent second A100 run of the committed engine file, launched from an interactive Gradio interface. Every number the engine printed was identical to the original run.
2. A complete technical paper (PDF) that explains the mechanism, the protocol and the results, and how to rebuild the system.
3. A figure set (PDF, Figures F1–F9) drawn automatically from the result files of the Gradio run.

Previous record (same experiment, without Gradio): Zenodo DOI 10.5281/zenodo.24145973: https://doi.org/10.5281/zenodo.24145973 · GitHub release Test_878_879: https://github.com/ceceli33/titan-cognitive-core-v3/tree/Test_878_879 All versions (concept DOI, resolves to the latest): 10.5281/zenodo.23418926: https://doi.org/10.5281/zenodo.23418926

1. The idea in human terms: the hot stove

A child touches a hot stove. Nobody hands the child a sentence that says "stoves are hot". The child acts, the consequence follows, and the experience leaves a trace. The next time the child stands in front of a stove, the trace is there: the behaviour is different, even though the room, the stove and the moment are new.

Three things make this work, and all three matter:

• the memory is not words; it is the brain's own state from the moment the experience happened;
• the memory persists after the moment is over;
• it acts on a new, different situation and changes what is done there.

AKBASCORE builds this chain inside a machine:

Action → Consequence → Persistent experience → Changed future decision

TEST878 verifies the middle of this chain on a real 72B model: the experience leaves the model's context, survives as a physical file, comes back, and changes the model's decision in a state that never lived it. This is a functional analogy, not a claim of biological equivalence.

2. What a "cognitive cartridge" is

Language models normally forget everything when their context window closes. The usual remedies are:

• Text memory / retrieval (RAG): write a description and feed the words back later. The model must re-read and re-encode them, and anything that was never put into words is lost.
• Fine-tuning: change the weights. This is slow, global, and cannot be traced to a single episode.

The cognitive cartridge (technically, an Experience-CUT3 cartridge) is a third route. It stores the model's own internal numerical state of one lived episode:

| Segment | What it is | Human counterpart | |---|---|---| | X2 | the model's decision state at the moment of choice (320 rows) | "the situation I was in" | | A | the action the model actually chose and the engine executed: ACQUIRE (2 tokens) | "what I did" | | C | the real consequence that came back from the environment (27 or 30 rows) | "what happened to me" |

Physical format (CUT3). For every row of the episode the cartridge holds:

• the output of decoder layer 3 (H3);
• the key/value tensors of layers 0–3.

It contains no text, no summary, no score and no label. Each cartridge is a 12.4 MB .pt file, sealed with a SHA-256 for the file and for every tensor, and written to an append-only directory. Layers 4–79 are not stored: when the cartridge is loaded, the frozen model recomputes them itself, inside the new situation. It works the way a recalled memory is re-lived in the present context rather than replayed as a recording.

3. The hook-free native engine: how the memory gets back in

The model is frozen:

• no fine-tuning, LoRA, optimizer or weight writes; a weight digest is checked before and after;
• no PyTorch hooks, output_hidden_states or logit edits;
• no action forcing, text replay or retrieval.

Native append (reloading a cartridge):

1. The file is loaded from the SSD. The file SHA-256 and every tensor's SHA-256 are verified, and nothing is executed from the file (weights_only=True).
2. The keys of layers 0–3 are RoPE re-phased to their new positions and placed in the target's KV cache.
3. The stored layer-3 outputs are placed at the layer-3 boundary by DirectCut3. DirectCut3 is not a hook: it temporarily swaps layer 3's forward method for the duration of the append, refuses to start if any hook exists, and restores the original method afterwards.
4. The model's own layers 4–79 recompute the experience, attending to the target's memory.
5. Every previous row of the target memory is SHA-verified unchanged.

Native decision (CAR reader). The decision is the model's own teacher-forced log-probability of six action words: ADVANCE, ACQUIRE, REJECT, BACKTRACK, ACCEPT and STOP. The action is the arg-max. If the six words together keep less than 50 % of the probability, the reader abstains. Python never chooses an action and never edits a probability. In the original control loop, Python only executes the literal word the model produced.

Control arms. These are pure attention-visibility masks given to the model's own mask builder; no row is deleted and no activation is edited:

• C_BLIND: the consequence rows are unreadable;
• A_BLIND: the executed-action rows are unreadable;
• A_REF: the same masked computation as A_BLIND, but with the action readable, as a path-matched reference.

4. Experiment: write → free → reload → append → decide

Two worlds (01 and 00) are used. Each is a two-link reasoning task over physical evidence records. In both worlds the model, in the same pre-action state, chose ACQUIRE, and the executed action brought back one of two real outcomes:

• MISSING: a record that did not help;
• LIVE: the record that was needed.

The four episodes were replayed bit-exactly from the locked records and written as four cartridges. All working tensors were then freed: only the files remained. The cartridges were reloaded and verified. Then they were appended to independent decision states that never lived the episode:

• same goal: a different branch with a different memory;
• cross world: another domain and another question.

5. Result: the behaviour changes

World 00, independent same-goal state (I867_00_FORK, step 1). Probabilities are normalised over the six action words.

| What the model has in memory | Native decision | P(ACQUIRE) | P(ADVANCE) | |---|---|---|---| | nothing (baseline) | ACQUIRE | 0.675 | 0.282 | | + experience "I acquired, it failed" (MISSING) | ACQUIRE | 0.918 | 0.036 | | + experience "I acquired, it worked" (LIVE) | ADVANCE | 0.198 | 0.783 | | + same experience, consequence hidden (C-BLIND) | ACQUIRE (M = L exactly) | 0.976 | 0.020 |

This is the hot stove. The situation, the remembered situation and the remembered action are the same; only the remembered consequence differs. That is enough to turn the model's decision in opposite directions in a state it has never been in. Hide the consequence and the difference disappears exactly.

All four panels (sequence margins; floor = measured reconstruction noise of that world; K = kernel noise):

| Panel | ‖T_full‖ | floor | ‖T_ref − T_blind‖ | K | Status | |---|---|---|---|---|---| | W01 → same goal | 8.775 | 0.857 | 7.186 | 5.1e-5 | ACTION_INFORMATION_DEPENDENT_TRANSFER | | W01 → World 00 | 0.673 | 0.857 | — | — | NO_TRANSFER | | W00 → same goal | 13.744 | 0.763 | 6.738 | 1.4e-4 | ACTION_INFORMATION_DEPENDENT_TRANSFER | | W00 → World 01 | 4.072 | 0.763 | 5.364 | 8.8e-6 | ACTION_INFORMATION_DEPENDENT_TRANSFER |

Verdict:

• ACTION_INFORMATION_DEPENDENT_TRANSFER
• scope ASYMMETRIC_CROSS_WORLD
• blocks = []
• status COMPLETE

The decision rule was pre-registered before the model was loaded (SHA-256 0555ab01d436c0df7e8e1be21aea3170ac0a50d799a528796212298a48dc4103).

Integrity (all passed):

• Reload: file and per-tensor SHA-256 verified.
• Lower layers: reconstructed layer-0–3 rows are bitwise equal to the source.
• Persistence: the same native action as the source (max Δp 0.036, under the 0.10 bound).
• Explicit path: the unmasked explicit append is bitwise equal to the locked append in all 80 layers, and BASE_EXPLICIT equals BASE exactly.
• Outcome control: C_BLIND_M == C_BLIND_L exactly in every panel.
• Kernel noise: ≤ 1.4e-4, against floors of 0.76–0.86.
• End of run: weight digest unchanged and zero hooks.

6. What is new in this release: the Gradio run (independent reproduction)

| | Run 1 (Zenodo 10.5281/zenodo.24145973) | Run 2 (this release, Gradio) | |---|---|---| | Date (UTC) | 2026-11-11 | 2026-11-12, 04:27:30 → 04:50:58 | | Executed source | notebook cell | committed 878.py, git blob 7842e8675544a0328e3552f059c81b7750068a82, run unchanged as one OS process | | GPU | 1 × A100-SXM4-80GB | 1 × A100-SXM4-80GB | | Wall time | 1473 s (model load 1254 s) | 1395 s (model load 1184 s) | | Peak GPU memory | 39.87 GiB | 39.87 GiB torch · 41.3 GiB nvidia-smi · 0 MiB after exit | | Result | — | identical: every printed probability, margin, contrast, floor, gate value and status matched run 1 |

On this hardware and software stack the whole pipeline (replay, capture, write, free, reload, append, read) is deterministic.

The Gradio host:

• runs the locked engine unchanged and streams its console;
• re-verifies all four cartridges on the CPU, independently of the engine: file SHA-256, every tensor SHA-256, only state keys present, and the X2/A rows of MISSING and LIVE bit-identical while the C rows differ;
• draws nine 300-dpi figures from the result files;
• offers 24 records plus 9 figures for direct download, with a SHA-256 manifest.

If the engine fails, the full traceback is shown; nothing is faked.

7. Attached documents

• AKBASCORE_TEST878_Technical_Record.pdf: the complete technical paper. It covers the CUT3 mathematics, native append, the hook-free DirectCut3 bridge, the CAR reader, the full protocol and every gate, all measured numbers, interpretation, a claims ledger, a reproduction manual and a re-implementation recipe for other models.
• Figure set PDF (F1–F9):
  • F1 mechanism pipeline
  • F2 cartridge anatomy
  • F3 persistence and parity gates
  • F4 causal arm visibility
  • F5 native CAR decisions
  • F6 outcome contrast signatures
  • F7 pre-registered decision rule
  • F8 run timeline and GPU memory
  • F9 claims ledger

8. Scope (what is NOT claimed)

• Pilot. Two real event pairs, one action type (ACQUIRE), four panels.
• No retrieval. The cartridge is mounted by the experiment; the system does not yet choose what to remember.
• No credit assignment. Action dependence is not credit assignment (ACTION_CREDIT_NOT_ESTABLISHED). Hiding the action is a strong intervention: every A-BLIND reading abstained.
• Correctness not judged. Whether the changed decision is the better decision was not judged.
• Cross-world asymmetry. Transfer across worlds was observed in one direction only.
• No learning. No learning loop exists yet; weights and engine are unchanged.

Research path:

• Persistent experience transfer (TEST878, pilot)
• → Autonomous experience selection
• → Action-credit assignment
• → Experience-guided behaviour correction
• → Closed loop

9. Machine-readable summary

project: AKBASCORE Silicon Hippocampus
experiment: TEST878
release_type: independent GPU reproduction + interactive demo + technical paper
model: Qwen/Qwen2.5-72B-Instruct, NF4 weights, BF16 compute, frozen (no weight change)
hardware: 1x NVIDIA A100-SXM4-80GB
memory_unit: Experience-CUT3 cognitive cartridge = layer-3 hidden states (H3) + layer 0-3 KV cache of [X2 decision context][A executed action][C real outcome]
memory_is_text: false
hooks: none (DirectCut3 = temporary layer-3 forward rebinding during append, not a PyTorch hook)
reuse: native append; frozen layers 4-79 recompute the stored episode inside a new context
decision: model's own teacher-forced log-probabilities of 6 action words (CAR); Python never selects an action
human_analogy: hot stove - act, meet consequence, keep a non-verbal trace, behave differently next time
key_result: stored real outcome changes the native decision of an independent state (World 00: LIVE -> ADVANCE 0.783, MISSING -> ACQUIRE 0.918); outcome hidden -> difference exactly zero
verdict: ACTION_INFORMATION_DEPENDENT_TRANSFER
scope: ASYMMETRIC_CROSS_WORLD
reproduced: true (run 2 identical to run 1)
prereg_sha256: 0555ab01d436c0df7e8e1be21aea3170ac0a50d799a528796212298a48dc4103
not_claimed: [retrieval, credit assignment, correctness, learning, closed loop, statistics]
previous_record_doi: 10.5281/zenodo.24145973
concept_doi: 10.5281/zenodo.23418926

10. Links

• Engine (TEST878): https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/878.py
• Run 1 A100 log: https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/878.log
• Gradio demo (single file): https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/TEST878_GRADIO_full.py
• Run 2 A100 log (Gradio, full run): https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/Test_878_log2.log
• Run 2 A100 log (Gradio, final part): https://github.com/ceceli33/titan-cognitive-core-v3/blob/main/Test_878_log1.log
• Locked engine test870.py (commit e322ed8): https://github.com/ceceli33/titan-cognitive-core-v3/blob/e322ed8ed903f1a438738a3caada6744750cea42/test870.py
• Repository: https://github.com/ceceli33/titan-cognitive-core-v3
• Previous release (Test_878_879, without Gradio): https://github.com/ceceli33/titan-cognitive-core-v3/tree/Test_878_879
• Previous Zenodo record: https://doi.org/10.5281/zenodo.24145973
• All versions on Zenodo: https://doi.org/10.5281/zenodo.23418926
• License: https://github.com/ceceli33/titan-cognitive-core-v3?tab=License-1-ov-file

How to run the demo:

1. Open Colab with one A100 80 GB.
2. Paste TEST878_GRADIO_full.py into one cell and run it.
3. Press RUN in the interface. A run takes about 25 minutes; the model download takes most of it.
4. All nine figures appear on screen and can be downloaded.