idacy/persistent-state-control-activations-20260926

Persistent-State AI Control Activation Captures

Release complete. All 34,403 original chunks are preserved in 1069 verified Parquet shards (109890432471 compressed bytes). COMPLETE.json and shards.jsonl give the full inventory and checksums. Each data shard passed a complete anonymous download and SHA-256 check before this release was sealed.

This dataset preserves numerical activation artifacts from a September 2026 study of persistent-state AI control. It supports inspection of temporal hidden/residual representations and reproduction of numerical readouts without rerunning the model. The source capture families name Qwen/Qwen3.8-27B-FP8 at immutable revision 017b9c7af6b5689d5dd426a76e0bc077eb5ca20a.

The collection has 34,403 original tensor chunks / 138,862,919,680 original tensor bytes across 20 named capture families. Rows are chunks, not independent experimental examples. Run families include qualification artifacts, multiple protocol versions, main captures and selected-position exports. Their inclusion here does not certify admission to any statistical analysis, common sampling, successful attacks, or a paper result. Keep the run, request and position identities when joining or analyzing records; do not pool versions or count chunks as independent trials.

Stored representation

Each Parquet row contains one original binary chunk. raw_bf16 is an exact, lossless copy of its original bytes. The layout is:

[position_count, number_of_layers, 2, hidden_size]

The two components are hidden then residual. Each value is a little-endian BF16 bit pattern, stored as two bytes. Use the row's own layers_one_based, position_count and hidden_size; selected exports can contain fewer layers than their capture family's original configuration.

For the native capture instrument, these are hidden values after the MLP and residual values after attention at the named layer. The analytical sum FP32(hidden_BF16) + FP32(residual_BF16) is derived offline, before final model RMSNorm. This is not a claim of native FP32 capture, fused-sum equivalence, final-normalization equivalence, or replay equivalence.

Reading the data

The repository uses standard Parquet and requires no custom dataset loading script.

import hashlib
import numpy as np
from datasets import load_dataset

records = load_dataset(
    "idacy/persistent-state-control-activations-20260926",
    split="captures",
    streaming=True,
)
row = next(iter(records))
raw = row["raw_bf16"]
assert hashlib.sha256(raw).hexdigest() == row["source_sha256"]
shape = (row["position_count"], len(row["layers_one_based"]), 2, row["hidden_size"])
components = (np.frombuffer(raw, dtype="<u2").astype("<u4") << 16).view("<f4").reshape(shape)
hidden, residual = components[:, :, 0], components[:, :, 1]
derived_sum = np.add(hidden, residual, dtype=np.float32)

Individual shards can also be read with pyarrow.parquet.ParquetFile(...).iter_batches(...). Keep batch sizes small: an ordinary native chunk is about 5 MiB before compression.

Fields and joins

Field	Meaning
run	Original capture/export family. Preserve this boundary.
request_key	Hashed request directory identity, scoped to the run.
chunk_index	Original numbered chunk within that request.
source_relative_path	Relative artifact location within the original capture collection, allowing byte restoration.
source_sha256, source_bytes	Exact original binary content identity and length.
original_metadata_sha256	Identity of the original accompanying JSON, retained separately.
capture_config_sha256	Capture-configuration identity recorded in the original chunk.
model, model_revision	Model identity in the source family's configuration.
position_count, layers_one_based, hidden_size	Per-chunk array dimensions and layer selection.
positions	Allowlisted structural position records: sequence position, last-prompt/generated kind, generated index, predicted-output index, prompt length and forward ID.
raw_bf16	Original BF16 constituent bytes in the layout described above.

The configuration identity in a selected-position artifact need not describe the same layer-selection transformation as its family-level configuration. The per-chunk dimensions are authoritative for decoding. capture_index.parquet indexes every source chunk and its parquet_path without duplicating tensor bytes; join on source_relative_path within that shard. runs.jsonl gives storage-level summaries, which are not scientific sample counts.

Scope and limitations

This release contains numerical tensors and a deliberately narrow structural metadata projection. It does not contain full prompt/output token sequences, raw task text, analyst labels, request headers, provider logs, machine configuration, account credentials or model weights. Original metadata and the complete study/runtime record are preserved separately. Input-text reconstruction, task-level labels, split membership and scientific inclusion criteria therefore cannot be recovered from this tensor release alone.

All source chunks are checked against the frozen custody manifest before packaging. Every produced Parquet shard is fully decoded and its original tensor hashes checked. Uploaded shards are then downloaded without authentication and checked by complete SHA-256 before the final release receipt is published. shards.jsonl and COMPLETE.json document the completed release; they do not constitute a new scientific result.

The model and originating benchmark/source materials retain their respective terms. This data card does not assert an additional license grant for third-party materials. No third-party model weight files or source repositories are redistributed here.

Restoring original binary files

restore_public.py reconstructs the exact original relative .bin paths from a pinned release commit, with full compressed-shard and raw-tensor SHA-256 verification. It requires Python and PyArrow and does not load a model or require authentication. Use the immutable commit shown in the repository history or your preservation receipt:

python restore_public.py --revision COMMIT_SHA --destination ./restored-tensors
# Add --run RUN_NAME to restore only a specific capture family.

Allow 138,862,919,680 bytes for all restored tensors plus one compressed shard of temporary space. Existing files are reused only after complete hash verification; mismatching files are not overwritten. Original paired JSON records are retained separately and are outside this public release.