---
license: cc-by-4.0
pretty_name: Strange loop in J-space
language:
- en
tags:
- interpretability
- self-model
- strange-loop
- global-workspace
- j-space
- language-models
- representation-geometry
- attention
- qwen3
- qwen2.5
size_categories:
- 1K<n<10K
---

# Strange loop in J-space — data

Data for **Strange loop in J-space** (Wiktor Tomasik, 2026): what happens inside a language model when a description
of its own state is fed back into it, when it is trained to predict and then follow its own next state, and whether a
compact representation of its own processing can come to steer what the model takes in. Code, report and figures:
**[github.com/Pixedar/jspace-strange-loop](https://github.com/Pixedar/jspace-strange-loop)**. This work builds on my
earlier writing on self-models and latent loops: [medium.com/@pixedar](https://medium.com/@pixedar).

Three systems inside language models whose own weights stay fixed. The first two use the model's J-space (Gurnee et
al., 2026) — a way to read an internal state as a weighted mix of words — in Qwen3-8B with a Qwen3-14B replication:

* **The frozen J-space loop.** The model's state at the answer position of a short scenario is read as 25 words,
  written back into an earlier layer, and read again; nothing is trained. The loop settles into many locally stable
  states selected by self-reproduction: discourse and stance words and an answering frame survive, names and the
  evidence fade, and every context drifts toward a casual persona. Perturbed while thinking, the model refers to a
  previous conversation that never happened. A forecaster that learns while its forecasts drive the loop keeps up with
  the process it changes.
* **The trained self-describing loop.** The model's own thinking is cut into 8 chunks that cannot see each other; a
  32-number state is the only memory between them; a self-model predicts the next state, and its forecast can be
  written back. Under pressure to be predictable to its own self-model (when prediction means telling states apart),
  the state turns by a fixed step from chunk to chunk — a time code that follows the stages of reasoning — or becomes a
  persistent identity code; a fed-back forecast is enacted — the system makes its prediction of itself come true. Mild
  pressure keeps both the enactment and the state's content.
* **A state that decides what the model reads** (Qwen2.5-0.5B and 3B, Qwen3-1.7B). The model tracks one animal's colour
  through a stream of short updates; which animal matters is said only once; a learned 32-number state is the only
  memory between pieces of text. When the state chooses which update the model takes in, it comes to represent which
  animal matters and steers the reading through that representation: editing it redirects the reading (99.6 %), through
  the reading alone, specifically and in proportion, and the loop then keeps following the edited target. It also
  learns to read again when its own read failed. When the model instead reads everything as ordinary text, the state
  learns to switch on the model's own attention to whatever the text names, but not to carry the target itself.

## Contents

| path | what |
|---|---|
| `v5/` | **the frozen J-space loop** |
| `v5/loop_inputs/` | the loop's scenarios (`contexts.json`), calibration (`calib/calib.npz`) and provenance for Qwen3-8B (`qwen3-8b/main`) and Qwen3-14B (`qwen3-14b/rep`), needed to re-run the causal experiments |
| `v5/spec/`, `v5/geom/` | settled states in 16- and 32-bit arithmetic, local stability, perturbations; geometry of the loop trajectories (8B, 14B) |
| `v5/transport/`, `v5/transport14/` | the 3,000 × 3,000 write-to-read word transport matrix (8B 32-bit, 14B 16-bit) and its words |
| `v5/axis/`, `v5/axis14/` | the shared self-amplification direction and the persona axis (40 role prompts × 16 questions) |
| `v5/stance/`, `v5/deflate/`, `v5/speech/` | stance words and readiness to revise; the loop without its own leading patterns; the loop during the model's own thinking (references to a previous conversation) |
| `v5/q/`, `v5/qm/`, `v5/p/`, `v5/e/` | the private-state test (without and with memory), the forecaster written into the loop, its online learning |
| `phaseB/loopb/` (8B), `phaseB/loopb14/` (14B) | **the trained self-describing loop**: `data.npz` (the model's own thinking as token ids, with category and split), `prompts.json`, `ref.npz` (reference values), `stats.npz` (natural statistics, readers), `eval/<variant>.npz/json` (states, forecasts, losses, interventions, free generations), `ckpt/<variant>/` (trained reader, writers and self-model, configuration, training curves), `reader_words.json` (the state's axes and its rotation in J-space words) |
| `selection_loop/restricted/` | **the state that decides what the model reads, restricted access** — per model: `eval_<variant>.npz/json` (states, queries, reads, answers on 512 held-out streams; interventions), `edits_<variant>.json` (edit controls), `ckpt/` (trained loop and training record), `records.pt` (the encoded updates), `prep.json` |
| `selection_loop/own_read/` | reads that can fail, second read decided after or before the first: `evalr_<variant>.npz/json`, `ckpt/` |
| `selection_loop/open/` | open access (0.5B, 3B): `eval_open_<variant>.npz/json` (states, answers, the model's own attention), `ckpt/`, `stats.pt` |

The folder names `v5/` and `phaseB/` come from the working tree (`frozen_loop/` and `trained_loop/` in the code
repository); `selection_loop/` matches the code repository.

Variant names in `phaseB/`: `<channel>_<reader>_l<λ>[_c|_cx|_n][_s<seed>]` — channel `const` (plain loop), `state`
(the previous state again: matched memory control), `fcst` (the self-model's forecast: the strange loop) or `cut` (no
state passed on); reader `learned` or `J` (fixed to J-space); λ the pressure on the system to be predictable to its own
self-model; loss suffix none (cosine), `_n` (variance-normalised), `_c` (contrastive with the thought's own other
moments among the candidates), `_cx` (contrastive with other thoughts at the same moment only); `_s1` the second seed.
Variant names in `selection_loop/`: `sel-<query>_l<λ>[_s<seed>]` with the read's query from the `state`, a constant
(`const`), the current instruction only (`instr`), the self-model's forecast (`fcst`) or the right update (`oracle`);
`retry`, `blind` and `single` for reads that can fail (`_ws`: started from a trained loop; `_nonull`: the read's own
"nothing new" weight not passed on); `open_z32` for open access (`_more`: longer training).

The full trajectories of the frozen loop (21 GB) are available on request. Data of earlier experiments, published with
release v1.0 of the code, remain available at revision `47090026` of this dataset.

Models: Qwen/Qwen3-8B @ b968826d, Qwen/Qwen3-14B @ 40c06982, Qwen/Qwen2.5-0.5B-Instruct @ 7ae55760, Qwen/Qwen3-1.7B @
70d244cc, Qwen/Qwen2.5-3B-Instruct @ aa8e7253; Jacobian lenses neuronpedia/jacobian-lens @ 9fa267f8; instructions for
the model's thinking: databricks-dolly-15k (instructions without context).

## Citation

```bibtex
@misc{tomasik2026strangeloop,
  author = {Tomasik, Wiktor},
  title  = {Strange loop in J-space: what a language model builds when a description of itself is looped back into itself},
  year   = {2026},
  url    = {https://github.com/Pixedar/jspace-strange-loop}
}
```

Licence: CC BY 4.0.