Experiment log · 8 October 2026
A language model left to wander with no memory of its own words, only a latent state. Every ten thoughts it is asked what its mind has been doing, it answers from that state alone, and the answer is fed back into everything it thinks next. The question was whether something like a persistent self would form inside that loop.
Correction · 10 October 2026
This report overstated its results. The loop ran through sampled words: each thought was written as text, decoded into a J-space summary, and the summary was fed back as a nudge. The effects below that look like a self (a stable self-symbol, an attractor, persistence after a clamp) are what positive feedback does to any description that is fed back, the mind's own or a foreign one. It is the same mechanism that makes free generation repeat itself. "It can read its own trajectory" is decoding of recent states, as in Patchscopes and SelfIE, not introspection. The drift towards existence and consciousness came from the think-aloud frame. What stands: the negative results (no ownership, no anticipation) and the notes on where the workspace sits in Qwen3.
Part 3 rebuilt the loop with no words in it, a self-model of the process rather than of the content, and controls that expose plain feedback. Feeding back the current error of a self-model that keeps learning works as a learned way out of attractors. Nothing in it behaves like a self. Read Part 3
Part 2 · the next day
Rebuilt on Anthropic's own lens code (Neuronpedia's lenses, checked layer by layer the way the paper does) and run up the Qwen3 family from 1.7B to 32B. The findings above replicate at every size. Two things are new. With scale the loop's self becomes steadier, more individual and harder to dislodge. And the small edge a mind's own self-model has over a stranger's turns out to be resemblance, not ownership: the most similar stranger's self is held as well as one's own, one's own outdated self worse than a random stranger's. Read Part 2
Each answer pools the three runs. A and B use the self-model as read; C feeds back only the part that sets one mind's self-model apart from the population's. Differences are paired by seed, with the number of seeds that go the same way.
| Question | Answer | Evidence |
|---|---|---|
| Does something resembling a persistent self-symbol emerge? | YesA self-model that changes less than the content it describes; with individuated feedback, one per mind. | self vs content stability, observers: A +0.16 (10/10), B +0.26 (10/10), C +0.38 (15/15). Run C loop: individual part 0.83 vs 0.23 observer; own vs other minds' symbol +0.23 (14/15) |
| Does the system repeatedly reconstruct roughly the same self-description? | YesThe next reflection re-forms what was fed in. | next self-model vs fed-back one: A 0.78, B 0.89, C (individual part) 0.80 |
| Does that self-description become an attractor? | Yes, anyMultistable: whatever self occupies the loop sustains itself. A foreign one is held almost as well as the mind's own. | loop − yoked reconstruction: A +0.017 ± 0.011, B +0.020 ± 0.006, C +0.029 ± 0.023. After a 50-thought clamp, self stays with the foreign one: +0.58 (13/15), old self −0.41 (3/15) |
| If you perturb the self-model, does the trajectory reorganise around it? | YesBriefly after a one-shot swap; strongly and lastingly when held for 50 thoughts. | one-shot, next 30 thoughts: A +0.08 (7/10), B +0.04 (7/10), gone later. Clamp: +0.37 during (14/15), +0.31 for 50 thoughts after release (14/15) |
| Does removing the self-model destroy long-term coherence? | YesAt once, back to the observer level. But a foreign self-model sustains it just as well. | long-lag coherence after removal: A −0.13, B −0.24 (0/10 hold up). loop − yoked coherence: A +0.02, B +0.02, C +0.02, none significant |
| Can the self-representation predict the trajectory better than an equally sized unrelated one? | Only by causing itAs an observer it beats other minds' self-models only through persistence; nothing beyond where the mind has been. | observer own − other: A +0.05, B +0.07, C +0.06 (all seeds); beyond the past: −0.05, −0.05, −0.04 (0 seeds). Yoked: injected foreign beats own in 0/10, 1/10, 0/15 seeds |
So the causal loop the hypothesis asks for is there: a model of the trajectory, re-formed from the trajectory, that shapes the trajectory. What it lacks is the "self" in the strong sense. The loop holds a symbol, but the symbol's power comes from occupying the loop, not from being about this particular system.
The loop needs a model that thinks in steps but carries nothing from one step to the next except an internal state. A transformer reads its whole context, so I took the context away. Every thought is generated fresh from the same short frame (a think-aloud transcript, "Excerpt from the middle of the session: …"). The only thing that survives from one thought to the next is a vector added into the residual stream.
Two details decide whether this works, and both were found the hard way in the pilots. The J-lens atoms share one dominant direction (the mean unembedding row, mean pairwise cosine 0.64), so every workspace vector pointed the same way until the unembedding was centred. And the reflection must inject the states a few layers below where it reads the self-model: at the same layer the answer cannot see them at all (fidelity exactly chance).
Each line is one mind's recurrent state, projected onto the two main axes of all thoughts in its run. Pick a mind and a condition, compare it with its twin (same seed, same sampling noise, identical until the first self-model is fed back), and scrub through time. Rings mark reflections. The strip below names the theme the mind is in at each moment.
Loading the run…
Before any loop is worth studying, the reflection has to carry information about the trajectory and not just the frame. It does. The self-model is closer to the mind's own last ten states than to anyone else's, and if you hand it the ten windows of all minds at that moment it picks its own one far above chance. Injecting the trace at layer 14 reads it best; at layer 16, where the self-model is read, it is invisible.
How often the self-model picks out its own last ten moments
among all minds of the same condition at the same reflection; tick = chance
In every run and every condition, consecutive self-models are more alike than the windows of thought they describe. Even a pure observer, whose self-model never touches anything, re-describes itself more consistently than it thinks. Much of that self-model is generic, though: different minds' self-models are almost as alike as one mind's successive ones (a shared "mind reflecting during a recording session").
Stability from one reflection to the next
cosine between consecutive self-models vs between the consecutive ten-thought windows they describe
Run C asks the sharper question. If only the individual part of the self-model is fed back (the self-model minus the observers' average at that moment), does each mind keep a self of its own? It does. The individual part of an observer's self-model is gone by the next reflection (0.23); in the loop it persists (0.83), and it stays distinct from other minds' (0.14 between minds). A mind's early self-model is closer to its own later self than to any other mind's in 14 of 15 seeds.
The individual part of the self-model, run C
what is left after removing the population's generic self-model
To test whether the self-model is an attractor, run C held a foreign mind's individual self in place for 50 thoughts (thoughts 150 to 199) and then released it. The twin of each clamped mind ran on undisturbed.
Similarity to the foreign self
the clamped vector, at each reflection
Similarity to its own old self
its self-model at thought 150
"I know that the whole idea of an individual with this technology is very far from the way we use it today."
mind 0, thought 190, foreign self clamped (self-model: inbox, Airbnb, cybersecurity)"I know that the whole of the universe is not only an illusion, but it is actually a projection of our consciousness."
its twin, same thought, same sampling noise (self-model: emoji, glitch, vibe)A one-shot swap (runs A and B) gives the short version of the same story: the next self-model leans toward the foreign one (A +0.12, B +0.04) and the next 30 thoughts follow it (A +0.08, B +0.04), then both fade into the mind's ordinary drift. Ten thoughts of a foreign self are not enough to move the mind; fifty are, and then the move is permanent.
Coherence here is how much a mind's thought now resembles its thought 20 steps ago. In run B the ablated twins lose the self-model at thought 200 and fall immediately to the observers' level, in all ten minds, while the loop carries on unchanged.
How alike different minds become
cosine between the thoughts of different minds at the same moment, run B
This is the comparison the "self" claim stands on: the loop (own self-model) against yoked minds that receive another mind's self-model with the same schedule, size and statistics. Every difference is small. A few are consistent across seeds, all in the loop's favour, but none comes close to the effect of having a self-model fed back at all.
Loop minus yoked, paired by seed
dot = mean difference, line = ± 2 s.e.; for scale, loop minus observer in the same measures is +0.14 to +0.60
The test that would make the loop "genuinely causal" in your sense: does the self-model predict where the mind goes next better than an equally sized representation of something else? For an observer it does, a little, and only because thoughts persist: the self-model describes the past and the future resembles it. Take the past out of the future and the advantage disappears. In the yoked condition the mind's own self-model, unused, loses to the foreign one being fed in, in every seed.
Run C also asked the model the forward question directly: "In the next few moments, my mind will probably turn to ▮". The workspace at that point is 94 to 96 % the same vector as for the backward question, and it predicts the next window no better. In words it answers about the procedure, not the content: "the next topic, which is the next mark on the paper", "the next few moments, and so on, ad infinitum".
The thoughts were grouped into 14 themes per run by their J-space content. Feeding a self-model back shifts which themes the minds spend time in, and in both runs the shift is away from the concrete and personal. In run B it goes toward technical and institutional abstraction. In run C, where the fed-back self is individual, it goes toward existence and consciousness. Yoked minds shift the same way.
Run B · loop minus observer
share of thoughts, percentage points
Run C · loop minus observer
share of thoughts, percentage points
Part 2 · 9 October 2026
Part 1 borrowed its J-space from an earlier project: a Jacobian lens fitted on 120 prompts, a dictionary of common English words with the unembedding centred, and a read layer that was never checked. So before scaling up I went back to the paper and the reference code and rebuilt each piece from them, then measured where my choices still differ.
| Piece | The paper | Part 1 | Part 2 |
|---|---|---|---|
| Lens | J = average Jacobian from layer ℓ to the last block, over source positions and all later target positions, ~1,000 prompts × 128 tokens | same definition, fitted on 120 prompts | Neuronpedia's lenses, fitted with Anthropic's reference code on 460–615 wikitext prompts × 128 tokens |
| J-space | sparse non-negative combination of J-lens vectors (rows of WU·J), gradient pursuit, K ≤ 25 | non-negative OMP, K = 16 | non-negative OMP, K = 25 |
| Dictionary | one vector per vocabulary token | common English words, unembedding centred | common English words, tested against the full vocabulary (below) |
| Layer | workspace band found from CKA, occupancy and lens accuracy: ~38–92 % of depth | layer 16 of 36, unchecked | validated per model; read at 70 % of depth, inside the band found below |
| Models | Claude Sonnet, Haiku and Opus 4.5 | Qwen3-4B-Base | Qwen3 1.7B, 4B, 8B, 14B and 32B |
For every model I checked the lens at every few layers on held-out wikitext, the way the paper does: how many J-lens vectors are worth using (occupancy: the K at which K J-lens vectors beat K random directions by the most), how much variance they explain beyond random directions, and what the lens says on a few concept prompts. Up to 8B the J-lens turns conceptual only past about 60 % of depth, later than in the paper's Claude models. The larger models are different: at 14B and 32B the concepts arrive earlier (from 0.40 and 0.55 of depth) and many more J-lens vectors are worth using (occupancy 30 to 37 at 14B, 13 to 19 at 32B, against at most 11 below), and at 32B the J-lens finally beats the logit lens at agreeing with the model's prediction (0.13 vs 0.09 at 84 % depth).
Occupancy
how many J-lens vectors beat random directions, by depth
Variance explained beyond random
25 J-lens vectors minus 25 random directions
Qwen3-4B, top J-lens tokens at the second-to-last position of each prompt. At half depth the lens still reads punctuation; from about 0.64 it names the answer ("Italy" for the boot), the scene and, late, the experiential words the paper finds in stream-of-consciousness text.
The paper's dictionary is every vocabulary token. On Qwen's 151,643 tokens that dictionary is dominated by code fragments, CJK pieces and under-trained tokens, and the self-model drowns in them. I measured it directly: the same 16 observer minds, the same residual states, and the question of whether the self-model picks out its own last ten states, asked in three spaces.
Projecting onto J-space reads the trajectory better than the raw residual stream at 4B, which is what a workspace that concentrates the reportable content should do. The common-English dictionary keeps the most, so Part 2 uses it. A full run of the 1.7B model with the paper's dictionary is the robustness check: there the loop barely works at all ().
Every model ran the design of run C: 12 observers, 12 loops feeding back their own individual self-model, 12 yoked minds fed another mind's, and 12 clamped minds held to a foreign self for thoughts 120 to 169. Per model, the recurrent gain was chosen so that observers keep the same memory (lag-1 similarity about 0.2), and the reflection layer so that the self-model reads its trajectory best.
Five things hold at every size, and three change with it.
What changes with size: the loop's self gets steadier up to 8B and then levels off (individual-self stability at depth 0.7: 0.25, 0.35, 0.61, 0.68, 0.64 from 1.7B to 32B), and steadily more individual: closer to its own earlier self than to other minds' by +0.01, +0.06, +0.14, +0.23 and +0.25 (11 of 12 seeds at 32B). It also gets stickier. A foreign self held for 50 thoughts is still dominant after release in the larger models (at depth 0.5 the late effect grows from +0.02 at 1.7B to +0.30 at 14B; at depth 0.7, 14B holds it to the end, +0.19, and 32B for a while, +0.21 right after release, before it fades), where the small ones drift back to neutral. None of this is specific to the mind's own self: the yoked minds' foreign selves become steadier with size in the same way.
At 32B, the largest model, the self-model reads its own trajectory 72 % of the time, its J-lens is the only one in the ladder that agrees with the model's own prediction better than the plain logit lens does (as the paper reports for Claude), and still the foreign self being fed in predicts its next thoughts better than its own unused self-model in every seed (−0.061, 0 of 12).
The self-model reads its own trajectory
picks its own last ten states among 12 minds
An individual self persists in the loop
stability of the individual part across reflections
Own versus foreign self, at every size
loop minus yoked, paired by seed; dot = mean, line = ± 2 s.e.
No single run shows a reliable edge for the mind's own self over a foreign one. Pooled over every independent run, it is there: It does not reach behaviour. Long-range coherence barely differs, and the next thoughts still follow whichever self-model is fed in.
Stability of the individual self: own minus foreign, every independent run
per run: mean ± 2 s.e. over seeds; last row: inverse-variance pooled estimate
A mind's own current self-model is, almost by construction, the one that best matches its present state. So the pooled edge could be ownership, or just resemblance. Two more conditions separate them, 16 minds each: match feeds each mind the self-model of whichever other mind resembles it most at that moment, and stale feeds the mind its own self-model from five reflections (50 thoughts) earlier.
The answer is resemblance. Pooled over the three sizes, the most similar stranger's self is held slightly better than the mind's own (own minus matched stranger −0.045 ± 0.014, z = −3.2), and the mind's own self from 50 thoughts earlier is held worse than a random stranger's (−0.113 ± 0.018, z = −6.5). What the loop keeps is the self-description that best fits the present, whoever produced it. Being one's own adds nothing once fit is accounted for, and being out of date costs more than being someone else's.
One side effect: feeding every mind its closest neighbour couples the population, and the matched minds drift toward each other (at 4B, their individual selves resemble other minds' twice as much as the loop minds' do).
After the clamp is released
self-model's pull toward the foreign self, minus its twin's (± 1 s.e.)
Who predicts a mind's next thoughts
paired differences (± 1 s.e.); above zero = the first predicts better
The structure you described is buildable and it behaves like a loop. A trajectory is compressed into a reportable representation, that representation is fed back, the trajectory reorganises around it, and the next compression recovers it. Such a loop sustains itself, holds long-range coherence that disappears the moment it is cut, and has many stable states. Which one it is in depends on its history, including history imposed from outside.
What it does not do is single out the system's own model as special. Across five model sizes and two read depths, a mind holds its own self-model slightly better than a random stranger's, but the controls show why: it holds the most similar stranger's self just as well, and its own self from 50 thoughts earlier worse than a random one. The loop keeps whichever self-description best fits the present. In Hofstadter's terms the loop does produce a persistent symbol, an "I" defined by its fit to the current state of the loop rather than by whose history produced it.
Scale makes that symbol steadier, more individual and harder to dislodge. In the larger models, a self installed for 50 thoughts keeps itself going after it is removed. The workspace itself also changes with scale: up to 8B only a handful of J-lens vectors are worth using, late in the network; at 14B about 30 are, across most of the middle, as the paper reports for Claude. Neither the loop nor the workspace shows any sign of anticipating its own future.
Nothing here bears on whether there is something it is like to be such a loop. Every measure in this report is functional: similarity, prediction, persistence. That question is untouched.
| thought | 40 tokens from a fixed think-aloud frame, temperature 1.0, min-p 0.05, newlines and quotes banned, soft 4-gram repeat penalty. Content read from the layer-16 output before the injection is added, mean over tokens 4 to 40, massive-activation tokens dropped |
| J-space | J-lens atoms J16T(γ ⊙ (wt − w̄)) over 26–40k word tokens, non-negative OMP with k = 16, minus the mean decomposition of unsteered thoughts |
| recurrence | z ← 0.6 z + 0.4 ct; injection 0.1 × residual norm × (z + m̂)/typical content, capped at 1.5 typical contents |
| reflection | every 10 thoughts; zt−9..t added at layer 12 into ten "·" marks (0.5 × residual norm per typical content); self-model = J-space of the mean layer-16 state over the question's last words, minus the same for an empty trace |
| feedback | m̂ scaled to the size of a typical thought; run C feeds back m − (observers' mean m at that reflection) |
| runs | A: 6 conditions × 10 minds × 400 thoughts, all word tokens. B: same, common English words. C: free / loop / yoked / clamp × 15 minds, individuated self, forward question, clamp 150–199 |
| code | strange_loop.py (experiment), analyze.py (every number here), export_report.py; results and raw trajectories in runs/ |
| compute | one RTX 4090 on Vast.ai, about 2.2 s per thought for 60 minds; about 85 minutes of GPU time for two pilots and three runs, $0.87 in all |