AD1E-Memory-0.8B-v0.1

AD1E adds a persistent, writable numerical memory to a frozen Qwen3.5-0.8B. Experiences change the memory state; foundation weights and the original vocabulary remain unchanged. At inference, learned continuous memory blocks enter the model's computation and the model generates answers through its original language-model head. Previous messages are not replayed into the answer prompt.

This is an Apple Silicon research runtime for controlled factual associations, numerical relations, and explicitly supplied relation chains. It is not a validated general-purpose conversational memory system. The complete foundation weights, prepared encoder, portable runtime, synthetic example state, and a reproducible evaluation are included.

How the memory works

Each memory block contains a learned 16 by 1024 continuous prefix and a numerical content key. A current query selects a block, and the frozen decoder generates the answer from the prefix and current input. No textual answer database, source transcript, or token-ID answer cache is used by the reader.

Writing a source packet optimizes its numerical prefix through the frozen decoder. Factual packets can stop once their source targets meet the fixed confidence criterion. Numerical-rule packets use the complete 64-update writer, because accurate reproduction of source examples alone does not establish transfer to new inputs. The prepared encoder initializes new blocks; it does not guarantee successful compression of arbitrary documents.

A factual correction learns a local neural patch from the corrected subject and value. A small exact numerical-key record selects that patch for later queries. Its stored value is a block address, not the corrected answer. Repeated corrections reuse the same subject's patch. Other blocks remain separate. Original values may remain in an earlier block, so correction is not secure erasure or completed memory consolidation.

The runtime accepts explicit memory labels, source pairs, and relation paths. These are current-request controls. It does not automatically extract arbitrary facts from a conversation or infer an unrestricted multi-hop plan.

What has been measured

The synthetic evaluation uses two four-person worlds with manager, partner, and identifier relations, plus four numerical rules learned from eight examples each. The example state contains 24 factual associations, four rule blocks, and two correction patches: 12 blocks in total. These counts are not a claim of large-scale knowledge capacity.

The paths are supplied, not discovered from natural-language questions. Repeated checks are not independent learned facts. Changing a fact altered its affected path answers while leaving the measured unrelated answers unchanged. Clearing correction pointers restored original values; zeroing neural prefixes removed the corrected answers; substituting earlier learned patches restored earlier values. These controlled interventions support a causal role for the numerical state within this test scope.

After all corrections, rule answers remained unchanged, including their existing errors. The release's replay.py evaluates the final example snapshot on 584 published cases: 24 facts, 112 supplied compositions, 64 rule-source queries, and 384 rule-transfer queries. Replaying these public cases is a reproducibility check, not a new independent test. See evaluation/results.json.

Memory and speed

The shipped numerical example state occupies 897,156 bytes, approximately 0.856 MiB, counting learned prefixes, content keys, tags, metadata, and all 12 allocated correction-record slots. It uses two correction records. The runtime enforces a 40,000,000-byte persistent numerical-state ceiling. Empty capacity is not evidence of learned knowledge, and the shipped example is not a measured capacity limit.

Foundation weights, fixed prepared interface weights, optimizer buffers, and temporary computation are separate from persistent experience state. The entire application does not run in 0.856 MiB of RAM. Writing requires gradient computation and materially more working memory than reading.

On the measured Mac mini M4 Pro with 64 GB RAM, a supplied four-hop request took approximately 198 ms in a warm process. This excludes model loading and natural-language planning. A single factual correction took several seconds; writing a new packet can take tens of seconds. No long-running free-conversation latency guarantee is established. The full synthetic research workload used multiple model-state candidates and reached approximately 10 GB of MLX memory; this is not the footprint of one stored memory file.

Download and install

The verified environment is Apple Silicon macOS with Python 3.13. Linux, Windows, CUDA, Transformers auto-loading, GGUF, and the hosted Inference API are not supported by this custom runtime.

hf download duman2020/AD1E-Memory-0.8B-v0.1 --revision v0.1 --local-dir ad1e-memory
cd ad1e-memory
python3.13 -m venv .venv
source .venv/bin/activate
pip install -r requirements.lock
python verify_package.py
python blackboard.py selftest

The repository and release identifier remain duman2020/AD1E-Memory-0.8B-v0.1 and v0.1. Use a new state file with this runtime; incompatible numerical layouts are not supported. For reproducibility, record the downloaded commit hash as well as the release name.

Read the example memory

Create a private working copy. Initialization refuses to overwrite an existing file.

python blackboard.py --state ./private-memory.npz init-example
python blackboard.py --state ./private-memory.npz inspect
python blackboard.py --state ./private-memory.npz ask --label world1.code --input Soren
python blackboard.py --state ./private-memory.npz chain --labels world1.manager world1.partner world1.code --input Soren

The direct identifier query returns 5710 from the released synthetic state. Available example labels are listed in memory/operators.json. Every answer uses fresh reply-local caches; the state file persists across separate process invocations.

Write and correct memory

Source pairs are supplied explicitly. For example, save this JSON as facts.json:

[["Alice", "1734"], ["Bob", "9286"]]

python blackboard.py --state ./my-memory.npz write --label personal.code --kind fact --pairs-json facts.json
python blackboard.py --state ./my-memory.npz ask --label personal.code --input Alice
python blackboard.py --state ./my-memory.npz correct --label personal.code --subject Alice --value 4821
python blackboard.py --state ./my-memory.npz ask --label personal.code --input Alice

For a numerical relation, provide source pairs and use --kind rule. The reader receives only the learned numerical state and current input; it does not execute a source formula. The writer accepts 1 to 16 string pairs, with a 512-token source limit. These admission limits do not guarantee successful learning of every admitted packet. Verify answers after a write.

train.py is an alternate entry point for experience-state training, with the same --state, --label, --kind, and --pairs-json arguments. It does not fine-tune foundation weights. The included encoder is a prepared interface checkpoint, not a claim that its full preparation can be reproduced from the small example dataset.

Memory files contain numerical representations of supplied information. Keep personal or organizational state private and use one independently owned state per user or team. The command-line writer is designed for one writer at a time. State saves are atomic, but there is no concurrent-write coordination, access-control system, or encrypted storage layer.

Reproduce the released snapshot

python replay.py --output ./replay-results.json

The output file must not exist. The script compares generated answers with the released reference and checks that foundation parameters remain unchanged. The reader does not load evaluation targets; only this offline evaluator reads them.

Scope and research basis

The foundation and original vocabulary are frozen. The numerical state can be saved and restored without replaying a transcript. This supports persistent internal-state memory in the measured tasks. It does not establish unrestricted dialogue understanding, new relation-family learning, robust paraphrase handling, automatic planning, unlimited retention, or autonomous concept formation.

The design draws on Prompt Tuning for learned continuous inputs, ICAE for trained memory interfaces, GRACE for local latent editing, and Neural Turing Machines for numerical content addressing. It is an adaptation, not a faithful reproduction of those systems. Titans motivates online neural memory, but its full architecture, learned momentum, and forgetting mechanism are not implemented here. MQuAKE motivates testing edited facts separately from their multi-hop consequences.

Files and license

• base_model/: unmodified Qwen3.5-0.8B weights, tokenizer, configuration, and upstream license.
• weights/encoder.safetensors: prepared numerical-prefix initialization interface and readout tags.
• ad1e/: portable frozen-backbone, learning, and numerical-memory implementation.
• memory/example-memory.npz: synthetic numerical snapshot; no real user history.
• blackboard.py, train.py, replay.py: use, state training, and reproducibility entry points.
• model_assembly.json, release_manifest.json, verify_package.py: composition, checksums, and integrity verification.

Project code and prepared interface weights are released under Apache-2.0. Foundation weights retain their upstream Apache-2.0 license. See LICENSE, NOTICE, and base_model/LICENSE.