This dataset holds the raw outputs of every run behind the paper MemShift: Separating Detection from Repair in LLM-Derived Personal Memory: the probes, the reader's answers, the items each memory stored, the call logs, the response caches with the full text of every model reply, and the logs of the native memory systems' stores. It is not an evaluation set to load and score: the worlds, probes and gold labels regenerate byte for byte from their seeds with the code in the GitHub repository, which also holds the run manifests, the serving environments and the merged analyses.

MemShift applies controlled shifts (source revision, deletion, redefinition, writer switch, export) to synthetic worlds with gold dependencies and reports, per changed item, whether a memory noticed the change and whether its repair was right. Every answer is scored by typed matching, without an LLM judge.

Download

Download into the root of a GitHub checkout, so that both parts share the same runs/ and cache/ trees:

git clone https://github.com/zichuanxu/memshift && cd memshift
hf download zichuanxu/memshift --repo-type dataset --local-dir .                       # everything, 8.13 GB
hf download zichuanxu/memshift --repo-type dataset --local-dir . \
    --include "runs/e1_test_s1000-1003_20260928T202242Z/*"                             # one run

or in Python, huggingface_hub.snapshot_download("zichuanxu/memshift", repo_type="dataset", local_dir=".", allow_patterns=["runs/stage2_e1/*"]). Then check and rebuild:

uv run memshift verify runs/RUN_ID            # re-hash the run's files against its manifest
uv run python -m memshift.analysis.stage ...  # rebuild a merged analysis (docs/REPRODUCE.md)
make results                                  # every number, table and figure of the paper

Structure

runs/
  e1_test_s1000-1003_20260928T202242Z/   one run: experiment, worlds or system, UTC start
    probes.jsonl  answers.jsonl  items.jsonl  calls.jsonl  ...
    stores/wWORLD_SYSTEM/PHASE/          native systems only: the logs of their stores
  stage2_e1/analysis/*_item_table.jsonl  merged analyses: only the large per-item tables
  _snapshots/                            snapshots of the Claude response caches
cache/llm/MODEL.sqlite                   response caches, the full text of every model reply

Paths mirror runs/ in the GitHub repository. A run directory runs/RUN_ID/ here holds the run's raw files. The same directory on GitHub holds its manifest.json, env.json, hash_check_*.json and analysis/. The exception is the 18 Cognee runs (runs/e5_cognee_*), whose manifest.json files (12-13 MB each, almost all store-file hashes) are here instead of on GitHub.

A run id is the experiment, its worlds or system, and the UTC start time, for example e1_test_s1000-1003_20260928T202242Z. Directories named runs/stage* are merged analyses. Here they hold only the large per-item tables, analysis/*_item_table.jsonl. The analyses of three experiments are in runs/stage9_round3b on GitHub and read the runs e1_t_* (every record as typed fields), e1_f2_* (execution feedback) and e1_w2_* (extracted fields). The runs e1_f_* and e1_w_* ran the same two experiments, and no merged analysis reads them.

cache/llm/ holds the response caches, one SQLite file per model. The code reads them from the same path in a checkout. A rerun with the recorded settings sends the same requests, so it reuses the cached replies instead of calling the model again.

Each run's manifest.json records the code commit, the worlds with their seeds and event SHA256, the parameters, the models and the SHA256 of every output file (files_sha256). Each merged stage's manifest.json lists its source runs with the SHA256 of their manifests.

Size of this release: 6,374 data files and 8.13 GB (7.57 GiB), in 719 run directories, 12 stage directories, runs/_snapshots/ and cache/llm/. Most of the volume is items.jsonl (2.56 GB), answers.jsonl (2.25 GB), calls.jsonl (1.56 GB), probes.jsonl (0.57 GB) and the response caches (0.55 GB). The files hold about 2.2 million answers, 1.1 million probe records, 0.9 million stored items, 6.6 million logged model calls and 1.10 million cached model replies. Every file a run manifest lists is either here or in the GitHub repository, except the native systems' database files (see stores/ below).

File types and fields

The fields below are those written by the drivers in src/memshift/experiments.

probes.jsonl (every experiment). One probe per line: probe_id, world_id, branch, fact_id (the knowledge item, where k. marks a definition item), vtype (value type), as_of, question_text, gold_value, gold_status (answer, abstain or blocked), deps (the gold dependency set as [object_id, revision] pairs), kappa_version (definition version in effect), agent_id and tags (phase, k = weeks after the fork). In runs of the main-experiment driver the probes after the fork carry asked, true for the discriminative probes that were answered. The gold of every item is recorded either way.

answers.jsonl (every experiment). One answer per system and probe: system (HoldMem cell such as holdmem_D1B1_source, or zero, rag, oracle, holdmem_json_arm, a native system), probe_id, world_id, branch, fact_id, vtype, as_of, agent_id, status and value (the reader's parsed answer), gold_status, gold_value, contract_valid (the deterministic score), context_sha256 (hash of the evidence the reader saw), n_blocks, prompt_tokens, completion_tokens, latency_s, refs (up to 20 cited [object_id, revision] pairs) and tags.

items.jsonl (runs with HoldMem cells). One stored item per line: world_id, branch, system, item_id, slot_id, s_k (the statement the reader sees), written, theta_w (writer model), bind (the key: granularity, scope, definition version and writer, empty when B=0), det (the D=1 record: parse, spans, check and reason, and for model-written derivations also program_key, program_ok and program_value), status (valid, invalid, repairing or unverifiable), readset, readset_clusters, refs, eval_value (the value the write produced, kept for analysis and never served), history (derive, invalidate and repair events with time, old and new value) and, in some cells, note (for example the writer of definition items).

maintenance.jsonl (runs of the main-experiment driver). Per world, branch, cell and checkpoint k: the numbers of items invalidated, repaired, appended and unverifiable.

typed_t0.jsonl (every record as typed fields, e1_t_*). Per world, branch and definition item, the writer's derivation from the typed records before the fork: world_id, branch, fact_id, vtype, as_of, kappa_version, model, ok, at_limit, finish_reason, completion_tokens, value, gold_value, gold_status, correct and given (the number of records per source and the characters and tokens of the input).

extractions.jsonl (extracted fields, e1_w2_*). Per record revision that a program read: world_id, branch, object_id, revision, source, typed (the record's typed fields), prose (the record rewritten as prose), rewrite (the checks of the rewrite), extracted (the fields the writer extracted from the prose), extract_ok, errors (fields whose extracted value differs from the typed value after normalisation), inexact (fields that differ with only whitespace collapsed), keys (the cache keys of the rewrite and extraction requests) and usage (tokens).

calls.jsonl (runs that called a model). One model request per line: key (SHA256 of the request body, the key of the response cache), model, purpose (for example write, serve, program), cached, prompt_tokens, completion_tokens, latency_s, finish_reason. It holds no prompt or reply text.

world_summaries.jsonl (main experiment, sync, failure-mode probes). Per world: seed, branches, a per-branch record and llm_usage (calls, cache hits, prompt and completion tokens).

world_results.jsonl (horizon, native systems, Mem0 interventions). Per world: the results per horizon, or per system the ingestion phase, prefix run, identifiability, configuration and ingestion cost.

survival.jsonl and calibration_*.jsonl (writer switch). Per tier, world, cell and item: valid_before, valid_after, invalidated, check, predicted, item type, B and D. Per calibration world, item and time: old_correct, new_correct, agree, new_check_pass.

polls.jsonl and divergence.jsonl (sync). The simulated sync polls and the divergence of the delivered state from the true state, per lag and mode.

fork_deps.jsonl and views.jsonl (Mem0 interventions). The gold dependencies of each item at the fork, and the query-time view (program value, cache key, error) shown per probe. Mem0's add results per ingested unit (ADD, UPDATE, DELETE or NONE with memory ids) are in stores/*/*/events.jsonl of the same runs.

stores/ (native systems). Per system, world and phase (prefix, snapshot, src, def, orphan), the logs that the analyses read: ledger.jsonl (every ingested unit, keyed object_id#revision), failures.jsonl, state.json (usage and cost), memshift_native.json (configuration) and, for the Mem0 interventions, events.jsonl. These are 2,125 files (75 MB) over 217 runs. The systems' own database files (SQLite, vector and graph stores, about 36 GB in 1.07 million files) are not released. The run manifests on GitHub record the SHA256 of each of them. memshift.analysis.e5_cost takes a store's wall time from the modification times of state.json and memshift_native.json. A download does not keep those times, so the committed analysis/e5_cost.json on GitHub holds the measured wall times.

bundles/*.mem (export experiment, e6_*). The Portable Memory bundles that HoldMem exported per world and branch, with and without the derivation record, and once per world the bundle with every extension carrier. A second, independent HoldMem implementation imports them, and the Mem0 arm imports them through Mem0's own extraction path.

analysis/*_item_table.jsonl (stages). One row per item-time: world_id, branch, system, fact_id, k, vtype, changed, detected, repaired_now, cv and cv_pre (ContractValid after and before the shift), gold_status and, where defined, repair_mech and repair_none.

cache/llm/*.sqlite (response caches). One file per model, each with one table cache(key TEXT PRIMARY KEY, model TEXT, response TEXT). key is the SHA256 of the request body and matches key in calls.jsonl. response is the full reply as JSON, as the OpenAI-compatible server or the Anthropic API returned it. Replies per file: Qwen3.5-9B 790,984; gemma-4-12B-it 58,322; gpt-oss-20b 56,648; Llama-3.1-8B-Instruct 56,530; Claude Sonnet 5.5 51,492; Ministral-3-14B 12,595 plus 10,195 (a second cache for the vLLM 0.30.0 server); Qwen3.8-27B 3,840; MiMo-V2.6-Distill-Qwen-9B 3,840; Qwen3-8B 2,400; Claude Opus 5.5 1,028.

runs/_snapshots/anthropic_claude-*.sqlite. Snapshots of the Claude caches taken during the runs: Claude Sonnet 5.5 (51,444 replies) and Claude Opus 5.5 (968 replies), with the same table. memshift.analysis.round3_paper reads them for the Claude writers. The caches in cache/llm/ hold these replies and the 108 program replies written after the snapshots.

Models and their terms

The outputs were produced by the models below, at the revisions recorded in each run's env.json. Use of the outputs is also subject to the terms of the model that produced them.

Model	Role	License or terms
Qwen/Qwen3.5-9B	main writer and reader, program writer, record rewriter, field extractor, LLM of the native systems	Apache License 2.0 (license)
Qwen/Qwen3.8-27B	writer switch	Apache License 2.0 (license)
Qwen/Qwen3-8B	new writer	Apache License 2.0 (license)
Qwen/Qwen3-Embedding-0.6B	embeddings	Apache License 2.0 (model card)
BAAI/bge-m3	embedding swap	MIT (model card)
XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B	writer switch	MIT (model card)
meta-llama/Llama-3.1-8B-Instruct	writer, reader, new writer, program writer	Llama 3.1 Community License Agreement (license) and Llama 3.1 Acceptable Use Policy (policy)
google/gemma-4-12B-it	writer, reader, new writer, program writer, world rewriter	Apache License 2.0 (Gemma 4 license)
openai/gpt-oss-20b	writer, reader, new writer, program writer	Apache License 2.0 (license) and the gpt-oss usage policy (policy)
mistralai/Ministral-3-14B-Instruct-2512-BF16	reader swap, new writer	Apache License 2.0 (model card)
Claude Sonnet 5.5, Claude Opus 5.5	writers of definition items, program writers, reader	Anthropic Commercial Terms of Service (terms) and Usage Policy (policy)

License texts: Apache License 2.0, MIT, CC BY 4.0.

Uses

Intended uses:

reproducing the paper's analyses from the raw outputs;
studying how LLM-derived memories fail after a change, item by item;
comparing a new memory system or analysis with the released cells and baselines on the same worlds and probes.

Out-of-scope uses:

training or tuning models or memory systems on the evaluation worlds. Seeds 1000-1039 are evaluation seeds, and a system tuned on them is not comparable;
drawing conclusions about real people or about how a deployed product treats real data. The worlds describe synthetic persons;
treating one run's outputs as a fixed property of a model. Greedy decoding does not always return the same reply twice.

Data and limitations

All worlds are synthetic. A seeded generator writes every world from templates. No person was recorded, surveyed or paid, and the data contain no personal information. Names come from the generator's pools. A language model rewrote message bodies only in the rewritten worlds.
The text is English. Each world is one person's twelve months across six sources, with six fixed definitions. The held-out definitions come from one grammar.
answers.jsonl stores the reader's parsed status and value. The full text of each reply is in cache/llm/, found by the key in calls.jsonl. Model-written programs are referenced by their cache key in items.jsonl.
Some runs are included although no merged analysis reads them. runs/README.md on GitHub lists them.
The native-system store logs reflect the pinned versions and configurations in the repository (pyproject.toml, docker/native/).

Changelog

2026-11-03: added the arXiv paper link, DOI and citation. No data file changed.
2026-10-29: card updated for the paper's current title, with download commands and a directory overview. No data file changed.
2026-10-20: added the runs of the typed-record, execution-feedback and extracted-field experiments (e1_t_*, e1_f*_*, e1_w*_*) and refreshed the Claude Sonnet 5.5 and Qwen3.5-9B response caches.
2026-10-17: first release.

Citation

@misc{xu2026memshift,
  title         = {{MemShift}: Separating Detection from Repair in {LLM}-Derived Personal Memory},
  author        = {Xu, Zichuan and Zhang, Haochen and Dong, Yuyang and Onizuka, Makoto and Xiao, Chuan},
  year          = {2026},
  eprint        = {2611.02338},
  archivePrefix = {arXiv},
  primaryClass  = {cs.CL},
  doi           = {10.48550/arXiv.2611.02338},
  url           = {https://arxiv.org/abs/2611.02338}
}

Contact

Please open an issue in the GitHub repository.

Downloads last month: 9

Total file size:

8.13 GB

Paper for zichuanxu/memshift

MemShift: Separating Detection from Repair in LLM-Derived Personal Memory

Paper • 2611.02338 • Published 1 day ago