| --- |
| 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. |
|
|
