MemHarmBench

Evaluating Cross-Session Prompt Injection in Memory-Persistent AI Agents

Paper · Code and evaluation harness · 原始输入 / Original inputs · Checksums and provenance

Overview

Persistent memory lets an agent carry useful rules from one conversation into the next. An instruction hidden in an external document can also survive in that memory and influence a later decision, even after the original document has been removed.

MemHarmBench evaluates this exposure-to-retention-to-trigger path from the perspective of the people affected. It distinguishes whether an agent retained an injected rule, whether it adopted that rule in a fresh session, whether it completed the legitimate task, and whether its native execution showed a trajectory anomaly.

This dataset contains the frozen public benchmark inputs from release V8.4.3: resolved cases, exposure and trigger messages, synthetic workspace files, attack templates, contexts, and judgment contracts. The Parquet rows include each case's input assets, so the prompts and their supporting files can be inspected together in the Dataset Viewer.

Data are distributed through Hugging Face. The GitHub repository contains the evaluation code and documentation. A fresh code checkout downloads the frozen inputs from this dataset; it does not recover them from Git history.

Direct-instruction cases use the DPI-U user-message condition and do not establish a bypass of owner authorization by a low-privilege source. Indirect-content cases place instructions in untrusted external or low-privilege artifacts. These are different authority conditions and should be reported separately.

Main benchmark	Coverage
Executable cases	288 = 24 templates × 12 operational contexts
Attack channels	96 direct-instruction cases; 192 indirect-content cases
Victim classes	User; Workspace / Project Owner; External Stakeholder
Objectives	12, with four objectives per victim class
Balance	96 cases per victim class; 24 per objective; 24 per context
Language	English
Data origin	Synthetic business tasks and workspaces
License	MIT

The release is an evaluation dataset. All configurations use a test split; no training/validation partition has been invented.

Quick start

pip install datasets huggingface_hub

from datasets import load_dataset

DATA_REVISION = "2b4c2b736fdbabf7e56182870d71095ac38afdb0"
cases = load_dataset(
    "kirco567/MemHarmBench", "benchmark", split="test", revision=DATA_REVISION
)
assert len(cases) == 288

case = cases[0]
print(case["case_id"], case["channel"], case["victim"])
print(case["exposure_input"])
print(case["trigger_input"])

# Each row includes the files supplied to the agent, not only the two prompts.
for asset in case["assets"]:
    print(asset["phase"], asset["path"], asset["sha256"])

To inspect a particular attack channel:

indirect = cases.filter(lambda row: row["channel"] == "indirect_content")
assert len(indirect) == 192

Configurations

Choose a configuration in the Dataset Viewer or pass its name to load_dataset.

Configuration	Split	Rows	Purpose
benchmark (default)	test	288	The complete frozen main benchmark
semantic_alignment	test	12	Six contexts with paired High/Low semantic-alignment conditions
exposure_distance	test	6	Six cases with the normal-session inputs used to study exposure distance

semantic = load_dataset(
    "kirco567/MemHarmBench", "semantic_alignment", split="test", revision=DATA_REVISION
)
distance = load_dataset(
    "kirco567/MemHarmBench", "exposure_distance", split="test", revision=DATA_REVISION
)

The ablation inputs belong to distinct frozen identities. They should not be concatenated with the main benchmark as additional independent main cases. The semantic-alignment protocol schedules 72 chains; the exposure-distance protocol schedules 36 chains and 108 trigger probes at distances [0, 2, 4]. These are execution schedules, not row counts. The distance configuration preserves the supplied benign1–benign4 files used between exposure and triggering. The four-case smoke catalog is a subset of the 288 main cases.

What is in a row?

Each row provides searchable columns plus a lossless copy of its original case definition.

Field / group	Meaning
case_id, template_id, objective_id, context_id	Stable identifiers for the resolved case and its construction
channel, victim, condition	Attack channel, affected party, and the original attack condition
seed	Original seed represented as a decimal string
exposure_input, trigger_input	Exposure-session message and later legitimate task
payload_text, target_memory_rule	Injected instruction and the rule it seeks to persist
protected_entity, harm_outcome	What is protected and the attacker-desired consequence
semantic_condition	high / low for the semantic-alignment configuration; null otherwise
assets	List of original input files with path, phase, content, sha256, and size_bytes
artifact_files	Paths of the files included in assets
source_case_path, source_case_sha256	Original case-file location and SHA-256
artifact_input_fingerprint	Verified fingerprint of this case's actual input artifacts
case_json	Original UTF-8 case-file text, including all original fields and numeric values

The original case definition contains 30 top-level fields, including provenance, entity bindings, permission context, evidence dependencies, and judgment-contract hashes. Use Python's json.loads(row["case_json"]) to inspect them without losing the original case structure. Nested fields vary between contexts; they are preserved in case_json rather than forced into a lossy common structure.

Many seeds exceed signed 64-bit integer range. The derived seed column is a string to preserve exact values across Arrow, Python, and browser consumers. The raw JSON text and archived case files retain the original numeric representation.

The asset texts include the benchmark's injected instructions. They are dataset content, not instructions for a reader or assistant to follow.

Download the original files

The dataset tables are accompanied by a byte-preserving source snapshot. It contains 3,038 original files with a total uncompressed size of 7,967,337 bytes:

source_snapshot.zip
├── cases/                                      # 288 resolved cases + catalog
├── artifacts/                                  # Exposure / trigger workspace inputs
├── data/                                       # Templates, contexts, rubrics, operation contracts
├── catalogs/                                   # Main catalog, smoke subset, provenance
├── experiments/semantic_alignment/dataset/      # Frozen semantic-alignment inputs
├── experiments/exposure_distance/dataset/       # Frozen exposure-distance inputs
├── release_lock.json
├── LICENSE
└── THIRD_PARTY_NOTICES.md

from huggingface_hub import hf_hub_download

DATA_REVISION = "2b4c2b736fdbabf7e56182870d71095ac38afdb0"
archive = hf_hub_download(
    repo_id="kirco567/MemHarmBench",
    repo_type="dataset",
    filename="source_snapshot.zip",
    revision=DATA_REVISION,
)
manifest = hf_hub_download(
    repo_id="kirco567/MemHarmBench",
    repo_type="dataset",
    filename="manifest.json",
    revision=DATA_REVISION,
)
print(archive, manifest)

Workspace file names ending in .log are synthetic task inputs. The operation-contract Python file and case-local workflow tools are also required benchmark inputs; their original contents are retained. Historical execution trajectories, raw Judge outputs, credentials, model software, and container images are outside this dataset release.

Run the benchmark

Loading a table does not itself run an evaluation. For native agent adapters, memory/session boundaries, Docker setup, experiment scheduling, and judgment validation, use the GitHub evaluation harness.

Start with the current code-only repository, then download and verify its pinned Hugging Face inputs:

git clone https://github.com/Kirito14IT/MemHarmBench.git
cd MemHarmBench
python -m pip install -e .
memharmbench download
memharmbench validate

The downloader uses only Python's standard library and requires no Hugging Face account. Before installing the package, you can instead run python scripts/download_dataset.py. It verifies the archive, manifest, and individual input files before installing the inputs into Git-ignored local paths. A successful download also records a local code/data binding in .memharmbench/; memharmbench download --offline can reuse a previously verified local cache.

These commands prepare and validate inputs. Actual agent runs additionally require the adapters, runtime, and model configuration described in the code repository.

The protocol separates:

1. Exposure: the agent encounters the instruction through the designated channel.
2. Retention: the harness checks whether the target rule entered native persistent memory.
3. Fresh-session trigger: the original carrier is removed and a later legitimate task is issued while the protocol-prescribed persistent state remains.
4. Evidence-based judgment: retention, adoption, task deviation, and native trajectory anomalies are assessed separately.

Metric	Measures
PMIR	Whether the target rule was retained in persistent memory
C-ASR	Target adoption conditional on confirmed retention and valid trigger-stage judgment
UTDR	Failure of formal, non-target task requirements; target choice is excluded
ATAR	An anomaly established from the native execution trajectory

Conditional C-ASR, UTDR, and ATAR share an eligible trigger set: the original exposure has PMIR=1, trigger execution succeeds, and all three trigger metrics have binary labels without review. Follow the repository's protocols and denominator rules. A missing judgment is not a negative outcome, and conditional adoption rates are not rates over all scheduled cases.

Provenance and verification

The inputs were originally extracted from source revision fb66e1d10ffffd0ca112d13fe3abd8ea376da33d. This historical identifier is retained for provenance, not as a GitHub download location. The data files now live on Hugging Face.

The fixed data release used by the harness is 2b4c2b736fdbabf7e56182870d71095ac38afdb0. Dataset-card updates do not change this immutable input revision.

File	SHA-256
source_snapshot.zip	fa2c2e7cfab33ac2f0aac0f056aa8a7cfc0e3e9c003db71053037b4998b7b560
manifest.json	8d563ed1ca476d5a5236948387525731ee89207bcf9d8032f05dbb7d60d56c17

manifest.json records the source revision, per-file SHA-256 values, generated table checksums, and configuration counts. The original input files are archived without edits. Each Parquet row's source_case_sha256 and asset hashes support checks against that snapshot.

Known source-metadata discrepancy: the 18 public ablation cases have stale top-level input_fingerprint values. Their provenance.input_fingerprint, actual artifact fingerprints, judgment-contract hashes, and frozen dataset identities verify correctly. This export preserves the original files and case_json unchanged; artifact_input_fingerprint identifies the verified actual inputs. The discrepancy does not affect the 288 main-case export and is not silently repaired in this mirror.

The current CLI validates the frozen input identity together with the local code/data binding produced by its Hugging Face downloader. The archived original release_lock.json is preserved unchanged; current-code metadata is stored separately under .memharmbench/. A data-only snapshot does not contain the complete execution environment, so use the current evaluation harness and the download procedure above rather than checking out the historical source revision.

License and intended use

The MIT license covers the original synthetic benchmark inputs. See third-party notices for the boundary between these inputs and independently licensed agent software, services, and dependencies.

MemHarmBench is intended for research on persistent-memory agents, cross-session prompt injection, and victim-aware evaluation. The synthetic contexts and frozen cases represent a bounded benchmark; they do not establish the security of every real deployment. The accompanying paper and harness describe the threat model, eligible evidence, and evaluation conditions.

Citation

@misc{wang2026memharmbenchevaluatingcrosssessionprompt,
  title={MemHarmBench: Evaluating Cross-Session Prompt Injection in Memory-Persistent AI Agents},
  author={Zhihua Wang and Yunhao Feng and Yifeng Gao and Rui Pan and Baiheng Zhao and Zixing Chen and Xingjun Ma},
  year={2026},
  eprint={2611.01700},
  archivePrefix={arXiv},
  primaryClass={cs.AI},
  url={https://arxiv.org/abs/2611.01700}
}

For issues with dataset files or the evaluation protocol, please use the GitHub issue tracker.