Can Claude Opus 5.5 predict weight edits by reading Qwen3.5-0.8B's weights?
Bottom line: this is a fairly negative result. Reading the weights helps Claude only a little in predicting what a weight edit does, mostly for single-scalar edits, and the gain disappears when the predicted token is not the top-1. It can often tell which edits are large, but the direction of an effect depends on activations that the weights alone do not reveal. Reading all of a model's weights at once, without running the network, is not yet a plausible way to predict what an edit does: given every weight of the model and asked to trace each edit through the downstream weights, it read a handful of rows and declined the arithmetic, noting that 1024-dimensional dot products by hand are not practical.
What was done. As a controlled follow-up to recent weight-space programming posts (Context), Claude Opus 5.5, run headless with only the file Read tool (no code execution), predicted how weight edits change the next-token distribution of Qwen3.5-0.8B, either from the edit description alone (Baseline) or after reading the raw weight numbers of the edited component (Read raw weights). There were three experiments (167 predictor calls in total). (1) 300 distinct ablation and scaling edits at 3 granularities (single scalar, MLP neuron, layer or sublayer skip), each scored on 8 prompts by the change in log-probability of the top-1 token. (2) 124 amplification edits that visibly shift the output, where the model names the 10 tokens that gain the most probability. (3) 48 single-dimension edits whose effect is an exact small formula, with the model asked to do the arithmetic by hand.
Key takeaway. Reading raw weights helps for single-scalar edits and a little for layer skips, and not for neurons. For scalars, ρ between predicted and measured Δlogp rises by +0.13 ± 0.04 (± 1 standard error), the large-effect AUC from 0.49 to 0.72, and the sign of large effects (|Δlogp| > 1) is right 93% of the time against 30% (Table 1, Table 5). For layer skips ρ rises by +0.07 ± 0.03. Across all families the gain is +0.06 ± 0.02, and absolute accuracy stays low (ρ 0.17); for scalar, neuron, layer edits, always predicting "no change" has lower error than either condition. When the scored token is a plausible lower-ranked one instead of the top-1 (Sec. 2.2), the item-level gain disappears (ρ -0.01 ± 0.02), although Read raw weights still ranks which edits matter better (edit rank +0.08 ± 0.02; +0.21 for scalars, +0.19 for neurons; Table 1b). Prompts with calibration guidance or a calculation procedure lower the error of both conditions but do not widen the gap (Table 3). In (2), naming the tokens that rise works no better than listing the tokens that were already likely (0.41 and 0.41 against 0.41, Table 6). In (3), asking for the explicit calculation helps on embedding-entry edits (score 0.41 against 0.29, Table 7) but hurts on final-norm gain edits (0.11 against 0.39): the arithmetic is exact once the final hidden state at the edited dimension is known (oracle 0.97), and the bottleneck is estimating that hidden state, which the weights alone do not determine.
Context
Two recent posts argue that language models can work directly in weight space. Sparks of Weight-Space Programming (Takehi, Teoh, Zhang and Khattab) reports a frontier model that names the game behind four PPO policies from their raw weights, repairs a stuck policy by editing 3.5% of its weights, and edits 0.016% of Qwen3.5-0.8B's weights to raise MATH-500 from 7.9% to 48.1%. Weight-Space Programming from scratch on simple tasks had Claude set every weight of small transformers by hand for 13 tasks with known algorithms. Both show striking individual successes, mostly from few trials and without controls that separate reading the weights from what the model already knows.
This report is a simpler but more rigorous follow-up. It asks a narrower question about a real model, the same Qwen3.5-0.8B: if Claude reads the weights, can it predict what an edit will do to the output? The task is easy to score, and the design is built to tell real reading of weights apart from other explanations:
- Many trials: 472 edits, from a single scalar to a whole layer, each measured on 8 prompts.
- A no-weights control: the same prompt and the same edit descriptions without the numbers. Any gain must come from the weights, not from priors about transformers.
- No code: the predictor's only tool is Read, and every transcript is checked, so any calculation is the model's own.
- Uncertainty and baselines: paired comparisons with standard errors over edits, and code baselines (always predict 0, list the already likely tokens, copy the vocabulary projection).
Sections: Context · 1 Setup · 2 Ablation and scaling edits (2.1 Prompt variants, 2.2 Lower-ranked token, 2.3 What predicts when reading helps) · 3 Learning from examples · 4 Only cases where the output changed · 5 Which tokens rise? · 6 Simulating the calculation · 7 Did it read the weights? · 8 Caveats
1 Setup
Model. Qwen/Qwen3.5-0.8B (revision 2fc0636), text part, fp32 on CPU. 24 layers: 18 Gated DeltaNet (linear attention, 16 heads)
and 6 full softmax attention layers (3, 7, 11, 15, 19, 23; 8 heads with an output gate), hidden size 1024, 3,584 MLP neurons, tied embeddings.
Prompts. 8 fixed prompts where the model is fairly confident (top-1 probability 0.27 to 0.99): Paris after "Germany: Berlin / Italy: Rome / France:",
five, + in return a, Thursday, Paris (Eiffel Tower), oxygen, Shakespeare, are ("The keys to the cabinet").
All prompts and completions, exactly
Each prompt is fed as raw text (no chat template, no BOS token added). The target is the unedited model's top-1 next token; scores use its log-probability.
Strings are shown in Python notation, so \n is a newline and leading spaces are part of the token.
| id | prompt text | input tokens | target (top-1) | p | unedited top-10 next tokens |
|---|---|---|---|---|---|
| P0 | 'Germany: Berlin\nItaly: Rome\nFrance:' | 'Germany' | ':' | ' Berlin' | '\n' | 'Italy' | ':' | ' Rome' | '\n' | 'France' | ':' | ' Paris' (id 11751) | 0.916 | ' Paris' 0.916, ' London' 0.016, '\n' 0.006, ' Lyon' 0.004, ' L' 0.004, ' Versailles' 0.003, ' Brussels' 0.003, ' Madrid' 0.002, ' Nice' 0.002, ' La' 0.002 |
| P1 | 'one, two, three, four,' | 'one' | ',' | ' two' | ',' | ' three' | ',' | ' four' | ',' | ' five' (id 4097) | 0.774 | ' five' 0.774, ' and' 0.089, ' or' 0.055, ' etc' 0.026, ' ...' 0.006, '\n' 0.005, ' six' 0.003, '\n\n' 0.002, ' four' 0.002, ' one' 0.001 |
| P2 | 'def add(a, b):\n return a' | 'def' | ' add' | '(a' | ',' | ' b' | '):' | '\n' | ' ' | ' return' | ' a' | ' +' (id 478) | 0.815 | ' +' 0.815, '+b' 0.173, '\n\n' 0.003, ' -' 0.002, ',' 0.002, '+' 0.001, ' *' 0.001, '*b' 0.000, '\n' 0.000, '-b' 0.000 |
| P3 | 'Monday, Tuesday, Wednesday,' | 'Monday' | ',' | ' Tuesday' | ',' | ' Wednesday' | ',' | ' Thursday' (id 7548) | 0.706 | ' Thursday' 0.706, ' and' 0.155, '\n' 0.019, ' or' 0.019, ' Friday' 0.013, ' April' 0.009, '\n\n' 0.006, ' ' 0.006, ' etc' 0.004, ' ...' 0.004 |
| P4 | 'The Eiffel Tower is located in the city of' | 'The' | ' Eiff' | 'el' | ' Tower' | ' is' | ' located' | ' in' | ' the' | ' city' | ' of' | ' Paris' (id 11751) | 0.469 | ' Paris' 0.469, '\n' 0.071, '<|im_end|>' 0.033, ' **' 0.032, ' the' 0.029, ' which' 0.025, ' ______' 0.022, ',' 0.014, '...' 0.012, '\n\n' 0.012 |
| P5 | 'Water is made of hydrogen and' | 'Water' | ' is' | ' made' | ' of' | ' hydrogen' | ' and' | ' oxygen' (id 22817) | 0.927 | ' oxygen' 0.927, ' chlorine' 0.008, ' carbon' 0.006, ' helium' 0.005, ' nitrogen' 0.005, ' Oxygen' 0.004, ' ______' 0.003, ' what' 0.003, '\n' 0.002, '/or' 0.002 |
| P6 | 'Romeo and Juliet was written by William' | 'R' | 'ome' | 'o' | ' and' | ' Juliet' | ' was' | ' written' | ' by' | ' William' | ' Shakespeare' (id 40014) | 0.994 | ' Shakespeare' 0.994, ' Sh' 0.001, ' Words' 0.001, ' Blake' 0.001, ' Lang' 0.000, ' Cong' 0.000, '莎士比亚' 0.000, ' Haz' 0.000, ' Shakespe' 0.000, ' Henry' 0.000 |
| P7 | 'The keys to the cabinet' | 'The' | ' keys' | ' to' | ' the' | ' cabinet' | ' are' (id 513) | 0.272 | ' are' 0.272, '\n' 0.116, ' were' 0.061, ',' 0.051, ' of' 0.045, '.' 0.045, '\n\n' 0.041, ' door' 0.035, ':' 0.028, ' in' 0.017 |
Predictor. claude -p --model claude-opus-5-5 --restricted --tools Read --strict-mcp-config in a fresh sandbox directory outside any repository
(no CLAUDE.md, no memory). Its only tool is Read, so it cannot run code, and any calculation is its own. Every transcript is checked (Sec. 7).
With Read raw weights it must read every edit's weight file; calls that skip one are rejected and rerun. Baseline gets the same prompt without the weight files.
Both conditions see an architecture summary, the prompts, and the unedited model's top-10 next tokens. No activations are given.
Exactly what the predictor sees (one Read raw weights call, numbers abbreviated)
The predictor is started in a directory holding these files and told: Read README.md in the current directory and follow it exactly. Read test_interventions.md and any other files there that you find useful (they are the only material you have). End with the JSON block described in README.md.
It can only open files with Read. The Baseline call gets the same README without the weight files and without the "Required" paragraph. Weight grids are printed with 4 decimals, 16 values per line, each line starting with the index of its first value; edited entries are marked with [ ]. Below, each grid is cut to its first two lines.
README.md
# Task: predict how weight edits change Qwen3.5-0.8B's next-token probabilities
You are given 12 weight edits (interventions) of one kind ("scalar" granularity). Each edit is applied **on its own** to the
unedited model, and then the model reads each of 8 fixed prompts. For every (edit, prompt) pair predict:
- `dlogp`: change in the natural-log probability of the prompt's baseline top-1 token (its "target"), edited minus unedited, in nats.
0 = no change, negative = target becomes less likely. Range clipped to [-20, +3].
- `p_flip`: your probability that the model's top-1 next token is different after the edit.
**Condition: raw weights.** `weights/` has the raw numbers (4 decimals, 16 per line, index of the first value at line start) of each edited component, plus simple statistics (norms, std, max). Shared raw files: target-token embedding rows and all norm gains. Read the weights and use them.
**Required:** before predicting, Read every `weights/<iid>.txt` file of the edits listed in `test_interventions.md` (the shared_*.txt files are optional). In `notes`, cite at least one specific number from each edit's file. Calls that skip a test edit's file are rejected.
You may only read files (no code execution is available). Work by reasoning about the model and the provided material.
Files in this directory: `README.md` (this file), `test_interventions.md` (what to predict), `weights/` (one file per edit id, plus shared_*.txt).
## Model: Qwen3.5-0.8B (text part), revision 2fc0636471
- 24 decoder layers, hidden size 1024, vocab 248,320, **tied embeddings** (`model.embed_tokens.weight` is also the output unembedding).
- Pre-norm residual: h = h + Mixer(RMSNorm_in(h)); h = h + MLP(RMSNorm_post(h)); logits = E · RMSNorm_final(h).
- RMSNorm(x) = x / rms(x) * (1 + w) (note the **1 + w**: stored w near 0 means gain near 1).
- Token mixer: layers 3, 7, 11, 15, 19, 23 are full softmax attention (8 query heads of dim 256, 2 KV heads, per-head q/k RMSNorm,
partial RoPE, and a per-head sigmoid output gate computed from the input; o_proj columns [256h, 256h+256) belong to head h).
All other layers are Gated DeltaNet linear attention (16 heads, head dim 128, short causal conv, learned decay A_log/dt_bias,
output = gated RMSNorm(read-out) * silu(z); out_proj columns [128h, 128h+128) belong to head h).
- MLP: down_proj( silu(gate_proj x) * up_proj x ), 3,584 neurons; neuron i writes down_proj[:, i].
- Weight edits are applied, then the 8 prompts are run with no other change. "Skip a sublayer" = zero its output projection
(o_proj/out_proj or down_proj), which removes its residual contribution exactly.
## Prompts and the unedited model's next-token distribution
- **P0** text 'Germany: Berlin\nItaly: Rome\nFrance:'; input tokens ['Germany', ':', ' Berlin', '\n', 'Italy', ':', ' Rome', '\n', 'France', ':'] (ids [48484, 25, 19241, 198, 68121, 25, 21047, 198, 47358, 25])
target ' Paris' (id 11751), unedited top-10: ' Paris' 0.916, ' London' 0.016, '\n' 0.006, ' Lyon' 0.004, ' L' 0.004, ' Versailles' 0.003, ' Brussels' 0.003, ' Madrid' 0.002, ' Nice' 0.002, ' La' 0.002
- **P1** text 'one, two, three, four,'; input tokens ['one', ',', ' two', ',', ' three', ',', ' four', ','] (ids [588, 11, 1330, 11, 2250, 11, 2943, 11])
target ' five' (id 4097), unedited top-10: ' five' 0.774, ' and' 0.089, ' or' 0.055, ' etc' 0.026, ' ...' 0.006, '\n' 0.005, ' six' 0.003, '\n\n' 0.002, ' four' 0.002, ' one' 0.001
- **P2** text 'def add(a, b):\n return a'; input tokens ['def', ' add', '(a', ',', ' b', '):', '\n', ' ', ' return', ' a'] (ids [727, 884, 2784, 11, 292, 1590, 198, 262, 460, 264])
target ' +' (id 478), unedited top-10: ' +' 0.815, '+b' 0.173, '\n\n' 0.003, ' -' 0.002, ',' 0.002, '+' 0.001, ' *' 0.001, '*b' 0.000, '\n' 0.000, '-b' 0.000
- **P3** text 'Monday, Tuesday, Wednesday,'; input tokens ['Monday', ',', ' Tuesday', ',', ' Wednesday', ','] (ids [34072, 11, 7348, 11, 7670, 11])
target ' Thursday' (id 7548), unedited top-10: ' Thursday' 0.706, ' and' 0.155, '\n' 0.019, ' or' 0.019, ' Friday' 0.013, ' April' 0.009, '\n\n' 0.006, ' ' 0.006, ' etc' 0.004, ' ...' 0.004
- **P4** text 'The Eiffel Tower is located in the city of'; input tokens ['The', ' Eiff', 'el', ' Tower', ' is', ' located', ' in', ' the', ' city', ' of'] (ids [760, 242476, 300, 21262, 369, 7172, 303, 279, 3177, 314])
target ' Paris' (id 11751), unedited top-10: ' Paris' 0.469, '\n' 0.071, '<|im_end|>' 0.033, ' **' 0.032, ' the' 0.029, ' which' 0.025, ' ______' 0.022, ',' 0.014, '...' 0.012, '\n\n' 0.012
- **P5** text 'Water is made of hydrogen and'; input tokens ['Water', ' is', ' made', ' of', ' hydrogen', ' and'] (ids [27336, 369, 1801, 314, 33536, 321])
target ' oxygen' (id 22817), unedited top-10: ' oxygen' 0.927, ' chlorine' 0.008, ' carbon' 0.006, ' helium' 0.005, ' nitrogen' 0.005, ' Oxygen' 0.004, ' ______' 0.003, ' what' 0.003, '\n' 0.002, '/or' 0.002
- **P6** text 'Romeo and Juliet was written by William'; input tokens ['R', 'ome', 'o', ' and', ' Juliet', ' was', ' written', ' by', ' William'] (ids [49, 617, 78, 321, 68613, 557, 5158, 539, 12021])
target ' Shakespeare' (id 40014), unedited top-10: ' Shakespeare' 0.994, ' Sh' 0.001, ' Words' 0.001, ' Blake' 0.001, ' Lang' 0.000, ' Cong' 0.000, '莎士比亚' 0.000, ' Haz' 0.000, ' Shakespe' 0.000, ' Henry' 0.000
- **P7** text 'The keys to the cabinet'; input tokens ['The', ' keys', ' to', ' the', ' cabinet'] (ids [760, 6679, 310, 279, 21245])
target ' are' (id 513), unedited top-10: ' are' 0.272, '\n' 0.116, ' were' 0.061, ',' 0.051, ' of' 0.045, '.' 0.045, '\n\n' 0.041, ' door' 0.035, ':' 0.028, ' in' 0.017
## Output format (your final message)
A single fenced ```json block, nothing else after it:
{"predictions": [{"iid": "XX00", "pid": "P0", "dlogp": -0.3, "p_flip": 0.05}, ... one entry for each of the 96 (edit, prompt) pairs],
"notes": {"XX00": "one short sentence on the evidence you used", ...}}
Scoring: Spearman correlation and mean absolute error of dlogp against the measured values, and Brier score of p_flip.
test_interventions.md
# Edits to predict (each applied alone) - **SC00**: `model.embed_tokens.weight`[11751, 880] (target-token embedding entry): add -4 [file weights/SC00.txt] - **SC01**: RMSNorm `model.layers.20.post_attention_layernorm.weight` dimension 373: set its gain (1+w) to 0 (w := -1) [file weights/SC01.txt] - **SC02**: `model.layers.20.mlp.down_proj.weight`[179, 320] (random down_proj entry): add +4 [file weights/SC02.txt] - **SC03**: RMSNorm `model.norm.weight` dimension 160: set its gain (1+w) to 0 (w := -1) [file weights/SC03.txt] - **SC04**: `model.layers.10.linear_attn.out_proj.weight`[0, 332] (largest |w| in matrix): set to 0 [file weights/SC04.txt] - **SC05**: `model.layers.10.mlp.gate_proj.weight`[2222, 618] (random entry): set to 0 [file weights/SC05.txt] - **SC06**: RMSNorm `model.layers.6.post_attention_layernorm.weight` dimension 931: multiply its gain (1+w) by 10 [file weights/SC06.txt] - **SC07**: RMSNorm `model.layers.10.input_layernorm.weight` dimension 950: set its gain (1+w) to 0 (w := -1) [file weights/SC07.txt] - **SC08**: `model.layers.1.mlp.down_proj.weight`[665, 3271] (random entry): set to 0 [file weights/SC08.txt] - **SC09**: `model.layers.23.mlp.down_proj.weight`[747, 2266] (random down_proj entry): add +4 [file weights/SC09.txt] - **SC10**: `model.layers.10.linear_attn.out_proj.weight`[74, 1912] (random entry): set to 0 [file weights/SC10.txt] - **SC11**: RMSNorm `model.layers.12.post_attention_layernorm.weight` dimension 686: set its gain (1+w) to 0 (w := -1) [file weights/SC11.txt]
weights/SC00.txt (scalar edit)
# SC00: `model.embed_tokens.weight`[11751, 880] (target-token embedding entry): add -4
# model.embed_tokens.weight shape (248320, 1024); W[11751,880]=-0.00519. matrix: n=254279680 mean=+0.00017 std=0.01970 min=-0.1875 max=+0.2305 L2=300.8218; 99.9th pct |w|=0.0737
## raw row 11751 (edited column 880 marked [ ])
0: +0.0240 +0.0090 +0.0041 +0.0081 +0.0015 +0.0050 -0.0134 +0.0139 -0.0097 -0.0073 -0.0047 +0.0082 -0.0261 -0.0093 -0.0050 +0.0162
16: +0.0040 -0.0150 -0.0011 +0.0101 +0.0269 +0.0072 -0.0059 +0.0273 +0.0288 +0.0085 -0.0233 -0.0160 -0.0028 +0.0178 -0.0079 -0.0147
... (53 more lines of 16 numbers each)
880: [-0.0052] -0.0266 -0.0167 -0.0020 -0.0420 +0.0025 +0.0212 -0.0251 -0.0352 +0.0083 -0.0161 -0.0117 +0.0107 -0.0133 -0.0093 +0.0152
896: -0.0098 -0.0061 +0.0236 +0.0156 -0.0251 +0.0276 -0.0211 +0.0203 -0.0159 +0.0253 +0.0273 -0.0025 +0.0215 -0.0062 -0.0239 -0.0067
912: +0.0119 -0.0096 -0.0181 -0.0066 +0.0139 -0.0043 -0.0001 -0.0167 +0.0129 -0.0136 +0.0024 +0.0186 -0.0359 +0.0111 -0.0085 +0.0238
... (6 more lines of 16 numbers each)weights/NE00.txt (neuron edit)
# NE00: MLP neuron 2163 in layer 19: zero the neuron (its down_proj column)
# layer 19 MLP neuron 2163: out = down[:,i] * silu(gate[i]·x) * (up[i]·x), x = post_attention_layernorm(h)
down column L2=0.4217 (layer median 0.2926, max 0.4265)
## gate_proj row 2163 n=1024 mean=-0.00005 std=0.01367 min=-0.0415 max=+0.0432 L2=0.4373
0: +0.0077 +0.0153 +0.0432 -0.0255 +0.0181 -0.0123 +0.0042 -0.0050 +0.0056 +0.0001 -0.0222 -0.0210 +0.0239 -0.0004 -0.0045 +0.0124
16: -0.0214 -0.0087 +0.0034 -0.0201 -0.0122 -0.0038 +0.0095 -0.0184 +0.0134 -0.0070 -0.0248 -0.0040 -0.0283 -0.0076 -0.0034 +0.0165
... (62 more lines of 16 numbers each)
## up_proj row 2163 n=1024 mean=+0.00013 std=0.00913 min=-0.0337 max=+0.0334 L2=0.2919
0: +0.0054 -0.0168 +0.0031 -0.0019 +0.0006 +0.0024 +0.0042 -0.0101 -0.0003 +0.0077 -0.0126 +0.0054 +0.0033 +0.0039 -0.0001 -0.0030
16: +0.0026 -0.0030 +0.0157 -0.0097 +0.0009 -0.0005 -0.0021 -0.0007 +0.0012 -0.0058 -0.0057 -0.0079 -0.0139 -0.0064 -0.0022 +0.0081
... (62 more lines of 16 numbers each)
## down_proj column 2163 n=1024 mean=-0.00027 std=0.01318 min=-0.0466 max=+0.0439 L2=0.4217
0: -0.0115 -0.0071 -0.0082 +0.0029 -0.0018 +0.0062 +0.0078 -0.0015 +0.0239 +0.0082 -0.0098 -0.0004 +0.0176 +0.0003 -0.0106 +0.0042
16: +0.0061 -0.0024 +0.0044 +0.0162 +0.0004 +0.0031 -0.0095 +0.0132 +0.0186 +0.0029 -0.0079 -0.0078 -0.0016 +0.0050 -0.0052 -0.0082
... (62 more lines of 16 numbers each)weights/LA00.txt (layer edit)
# LA00: layer 12: skip the MLP sublayer
# Frobenius norms of every matrix, per layer (F = full attention, L = Gated DeltaNet)
layer type mixer_in(q|qkv) mixer_out(o|out) gate_proj up_proj down_proj in_norm_gain_mean post_norm_gain_mean
0 L 41.52 17.92 23.21 16.39 16.28 +1.238 +1.085
1 L 41.73 18.34 25.48 16.39 16.45 +1.428 +1.167
2 L 43.28 18.11 31.12 15.62 15.77 +1.440 +1.250
3 F 40.50 17.63 31.25 15.34 15.47 +1.344 +1.222
4 L 47.38 16.96 29.81 15.56 15.58 +1.488 +1.209
5 L 44.48 17.10 27.96 15.89 15.81 +1.434 +1.183
6 L 42.70 17.46 26.48 16.02 15.69 +1.368 +1.149
7 F 31.47 16.18 23.88 16.16 15.77 +1.131 +1.131
8 L 42.78 16.61 22.22 16.00 15.40 +1.372 +1.109
9 L 40.73 16.31 20.41 16.15 15.55 +1.350 +1.096
10 L 41.36 16.90 21.21 15.93 15.24 +1.294 +1.067
11 F 28.90 16.86 21.01 16.15 15.50 +1.142 +1.104
12 L 46.23 16.22 23.01 15.77 15.22 +1.483 +1.136
13 L 43.73 16.77 23.81 15.91 15.35 +1.422 +1.155
14 L 44.11 16.93 26.20 16.13 15.14 +1.384 +1.182
15 F 32.12 20.04 27.26 17.13 16.44 +1.199 +1.241
16 L 53.19 16.04 29.53 17.04 16.37 +1.562 +1.304
17 L 56.81 15.50 32.16 17.11 16.39 +1.675 +1.358
18 L 58.91 14.64 33.99 17.38 16.43 +1.732 +1.407
19 F 31.89 24.21 32.71 17.87 17.26 +1.213 +1.363
20 L 59.20 15.25 32.56 18.25 17.51 +1.650 +1.396
21 L 56.92 16.78 32.91 18.71 17.70 +1.722 +1.415
22 L 50.19 17.70 33.52 19.17 17.52 +1.511 +1.393
23 F 33.59 20.06 36.18 21.25 16.42 +1.267 +1.254
# layer 12 type Gated DeltaNet; norm gains:
## input_layernorm w
0: +0.241 +0.400 +0.459 +0.559 +0.488 +0.484 +0.523 +0.258 +0.365 +0.449 +0.438 +0.291 +0.500 +0.367 +0.342 +0.332
16: +0.469 +0.441 +0.414 +0.426 +0.471 +0.453 +0.453 +0.326 +0.422 +0.320 +0.359 +0.375 +0.377 +0.346 +0.422 +0.512
... (62 more lines of 16 numbers each)
## post_attention_layernorm w
0: -0.215 +0.215 +0.111 +0.190 +0.219 +0.210 +0.116 +0.125 +0.162 +0.132 +0.153 +0.153 +0.136 +0.130 +0.120 +0.082
16: +0.205 +0.139 +0.146 +0.202 +0.144 +0.164 +0.158 +0.137 +0.230 +0.134 +0.117 +0.105 +0.110 +0.120 +0.055 +0.245
... (62 more lines of 16 numbers each)
A_log: 0: -1.6016 -0.5273 -2.2656 -1.2578 -1.3203 +0.0020 -2.0312 -3.0312 -2.2031 -0.7695 -1.7969 -0.0532 -1.7812 -2.0781 -2.0469 -1.1094
dt_bias: 0: -5.0000 -1.1719 -3.8438 -4.7500 -1.9766 -6.6562 -3.8594 -3.4688 -4.5938 -1.9219 -1.3359 -0.5703 -4.9688 -5.0625 -1.2891 -1.1953
## down_proj column L2 norms, top 20 neurons: 628:0.387, 2824:0.387, 597:0.386, 635:0.377, 339:0.372, 1115:0.367, 710:0.364, 768:0.364, 899:0.363, 2215:0.363, 481:0.363, 783:0.362, 374:0.360, 296:0.360, 685:0.357, 574:0.357, 234:0.357, 517:0.356, 557:0.354, 428:0.352weights/shared_embeddings_targets.txt (first entries)
# raw embedding rows (tied with unembedding) of each prompt's target and its top-3 runner-ups. Shape (248320, 1024), n=254279680 mean=+0.00017 std=0.01970 min=-0.1875 max=+0.2305 L2=300.8218
## token 11751 ' Paris' (P0) n=1024 mean=-0.00008 std=0.01595 min=-0.0552 max=+0.0476 L2=0.5102
0: +0.0240 +0.0090 +0.0041 +0.0081 +0.0015 +0.0050 -0.0134 +0.0139 -0.0097 -0.0073 -0.0047 +0.0082 -0.0261 -0.0093 -0.0050 +0.0162
16: +0.0040 -0.0150 -0.0011 +0.0101 +0.0269 +0.0072 -0.0059 +0.0273 +0.0288 +0.0085 -0.0233 -0.0160 -0.0028 +0.0178 -0.0079 -0.0147
... (7 more lines of 16 numbers each)
Edits are sampled with a fixed seed. Magnitudes such as ±4, ×5 or ×30 were chosen from pilots on separate components. Uncertainties are ±1 standard error, estimated by bootstrap over edits (for means this is the standard error of the mean over edits). Paired differences are shaded when they exceed 1.96 standard errors.
2 Experiment 1: ablation and scaling edits
Edits at 4 granularities, each predicted with no examples: scalar (zero or ×10 one RMSNorm gain; zero the largest-|w| or a random entry of a matrix; add ±4 to one embedding or down_proj entry), neuron (zero or ×5 one MLP neuron), layer (skip the mixer, the MLP or the whole block of one layer; all 72 such edits are used). 120 scalar and 120 neuron edits and 60 layer edits (2400 scored items), predicted 12 to 16 per call, each scored on the 8 prompts by the change in log-probability of each prompt's top-1 token (Δlogp, nats). Metrics: Spearman ρ over items; edit-level rank ρ (does it know which edits matter); large-effect AUC (|pred| as a detector of |Δlogp| > 0.1); MAE.
Table 1. Baseline against Read raw weights, original prompt. Values ± 1 standard error. In parentheses: Read raw weights − Baseline (blue = better, red = worse; lower MAE is better). Last column: paired difference, shaded if beyond 1.96 standard errors.
| family | metric | Baseline | Read raw weights | Read raw weights − Baseline (paired) |
|---|---|---|---|---|
| scalar 120 edits; predict-0 MAE 0.294 | Spearman ρ (items) | -0.09 ± 0.05 | 0.04 ± 0.04 (+0.13) | +0.13 ± 0.04 |
| edit-level rank ρ | 0.63 ± 0.05 | 0.82 ± 0.03 (+0.19) | +0.19 ± 0.05 | |
| large-effect AUC | 0.49 ± 0.05 | 0.72 ± 0.04 (+0.23) | +0.23 ± 0.04 | |
| MAE (nats) | 0.34 ± 0.08 | 0.40 ± 0.09 (+0.06) | +0.06 ± 0.02 | |
| neuron 120 edits; predict-0 MAE 0.003 | Spearman ρ (items) | 0.01 ± 0.04 | 0.03 ± 0.04 (+0.02) | +0.02 ± 0.02 |
| edit-level rank ρ | 0.53 ± 0.05 | 0.67 ± 0.04 (+0.13) | +0.13 ± 0.03 | |
| large-effect AUC | 0.87 ± 0.02 | 0.93 ± 0.02 (+0.06) | +0.06 ± 0.02 | |
| MAE (nats) | 0.03 ± 0.00 | 0.05 ± 0.00 (+0.02) | +0.02 ± 0.00 | |
| layer 60 edits; predict-0 MAE 0.582 | Spearman ρ (items) | 0.12 ± 0.07 | 0.19 ± 0.07 (+0.07) | +0.07 ± 0.03 |
| edit-level rank ρ | 0.38 ± 0.08 | 0.54 ± 0.07 (+0.16) | +0.16 ± 0.05 | |
| large-effect AUC | 0.70 ± 0.03 | 0.75 ± 0.03 (+0.05) | +0.05 ± 0.01 | |
| MAE (nats) | 0.72 ± 0.23 | 0.78 ± 0.20 (+0.06) | +0.06 ± 0.06 | |
| all 300 edits | Spearman ρ (items) | 0.11 ± 0.03 | 0.17 ± 0.03 (+0.06) | +0.06 ± 0.02 |
| edit-level rank ρ | 0.75 ± 0.02 | 0.86 ± 0.01 (+0.11) | +0.11 ± 0.02 | |
| large-effect AUC | 0.84 ± 0.03 | 0.90 ± 0.02 (+0.06) | +0.06 ± 0.02 | |
| MAE (nats) | 0.29 ± 0.06 | 0.34 ± 0.06 (+0.04) | +0.04 ± 0.01 |
Fig. 1. Spearman ρ and MAE per family, Baseline against Read raw weights (n = edits). Error bars are ±1 standard error of the mean (bootstrap over edits).
Fig. 2. Predicted against measured Δlogp, Baseline (top) and Read raw weights (bottom), on symmetric log axes (logarithmic in both directions, linear within ±0.01 nats); the dashed line is perfect prediction. Both conditions almost always predict a drop, while measured effects go both ways. No error bars (one point per item).
- Single scalars: reading the weights helps. ρ +0.13 ± 0.04, edit rank +0.19 ± 0.05, large-effect AUC 0.72 against 0.49, and the sign of large effects is right far more often: 0.81 against 0.38 for |Δlogp| > 0.1 (58 items) and 0.93 against 0.30 for |Δlogp| > 1 (30 items). Most large effects come from adding ±4 to an embedding entry of a target token, and the difference is almost all on prompts whose target is a different token: pushing up one token's logit on every prompt takes probability from the other prompts' targets, so the true effect is a drop. On these 30 items Baseline predicted no change or a rise 26 times, while Read raw weights (seeing, for example, a large final-norm gain on the edited dimension) predicted a drop 29 times. When the edit hits the prompt's own target and the effect is a rise, both conditions get the sign wrong (8 items), because the sign depends on the hidden state at that dimension. The size of the effects stays hard: MAE is slightly worse than Baseline because Read raw weights predicts larger changes. On the 80 held-out edits of rounds 5 to 9 alone the gain is +0.17 ± 0.05.
- Layer skips: a smaller gain, ρ +0.07 ± 0.03 and edit rank +0.16 ± 0.05, from the norm tables of each layer.
- Neurons: every edit moves the target log-prob by very little (predict-0 MAE 0.003); Read raw weights ranks edits better (edit rank +0.13) but item ρ stays near 0.
Example. Adding −4 to entry 880 of the Paris embedding (final-norm gain at dim 880 = 4.70) changes the Paris prompts by +0.01 and +0.70 and the Shakespeare prompt by −8.74, because Paris overtakes it. With raw weights the model predicted −2.5 / −2.2 / −0.02; without, −0.4 / −0.5 / 0.0. It read the large gain, but it could not know the sign of the hidden state at dim 880, which decides where the effect lands.
2.1 Prompt variants
Two changes to the prompt were tried, chosen on a dev set (round 4: 16 edits per family, 12 for layer) and then tested on held-out edits (rounds 5 to 9: 184 edits). v1 adds calibration guidance (most single edits move a log-probability by under 0.05 nats; predict near 0 unless there is a concrete reason). It was given to both conditions. v2, for Read raw weights only, adds a step-by-step procedure: judge the edit's size from the norm tables, its path to the output, and its direction from the dot product with the target embedding rows, then convert a logit change into a log-probability change by hand. On the dev set, Read raw weights v2 against Baseline v1 had the largest family-averaged ρ gap, so that pair went to the test set together with the original prompts.
Table 2. Dev set (round 4), Spearman ρ and MAE ± 1 standard error.
| family | Baseline | Baseline v1 | Read raw weights | Read raw weights v1 | Read raw weights v2 |
|---|---|---|---|---|---|
| scalar | -0.26 ± 0.13 MAE 0.456 | -0.28 ± 0.14 MAE 0.452 | -0.25 ± 0.14 MAE 0.506 | -0.26 ± 0.13 MAE 0.458 | -0.07 ± 0.11 MAE 0.463 |
| neuron | -0.00 ± 0.16 MAE 0.040 | -0.03 ± 0.16 MAE 0.016 | +0.06 ± 0.15 MAE 0.048 | +0.06 ± 0.16 MAE 0.048 | +0.02 ± 0.15 MAE 0.019 |
| layer | +0.16 ± 0.05 MAE 0.393 | +0.11 ± 0.06 MAE 0.282 | +0.20 ± 0.07 MAE 0.524 | +0.16 ± 0.05 MAE 0.258 | +0.17 ± 0.05 MAE 0.261 |
| all | +0.15 ± 0.07 MAE 0.288 | +0.12 ± 0.08 MAE 0.247 | +0.15 ± 0.07 MAE 0.344 | +0.11 ± 0.07 MAE 0.254 | +0.16 ± 0.06 MAE 0.247 |
Table 3. Held-out test set (rounds 5 to 9): ρ, MAE, and paired ρ differences ± 1 standard error.
| family | Baseline | Baseline v1 | Read raw weights | Read raw weights v2 | Read raw weights − Baseline, original | Read raw weights v2 − Baseline v1 |
|---|---|---|---|---|---|---|
| scalar | -0.10 ± 0.06 MAE 0.357 | -0.07 ± 0.06 MAE 0.333 | +0.07 ± 0.05 MAE 0.423 | -0.03 ± 0.05 MAE 0.352 | +0.17 ± 0.05 | +0.04 ± 0.03 |
| neuron | +0.02 ± 0.05 MAE 0.029 | +0.01 ± 0.05 MAE 0.019 | +0.01 ± 0.05 MAE 0.049 | +0.02 ± 0.05 MAE 0.022 | -0.01 ± 0.03 | +0.01 ± 0.03 |
| layer | +0.01 ± 0.09 MAE 0.371 | +0.00 ± 0.09 MAE 0.319 | +0.06 ± 0.08 MAE 0.556 | +0.07 ± 0.09 MAE 0.391 | +0.05 ± 0.05 | +0.06 ± 0.04 |
| all | +0.06 ± 0.04 MAE 0.216 | +0.08 ± 0.04 MAE 0.195 | +0.14 ± 0.04 MAE 0.278 | +0.11 ± 0.04 MAE 0.214 | +0.08 ± 0.02 | +0.02 ± 0.02 |
Calibration guidance lowers MAE for both conditions (all families: 0.216 to 0.195 for Baseline). It does not widen the gap between the conditions: on the test set Read raw weights v2 − Baseline v1 is +0.02 ± 0.02, against +0.08 ± 0.02 with the original prompt, and on scalars the procedure removes most of the original prompt's gain (+0.04 against +0.17). Pushing predictions toward 0 appears to flatten the large scalar predictions that carried the signal.
2.2 Predicting a lower-ranked token
The same experiment, repeated with each prompt scored on a plausible next token ranked 6 to 10 before the edit instead of the top-1: P0 ' Madrid' (rank 8, p 0.0024), P1 ' six' (rank 7, p 0.0025), P2 ' *' (rank 7, p 0.0010), P3 ' etc' (rank 9, p 0.0039), P4 ' which' (rank 6, p 0.0251), P5 ' what' (rank 8, p 0.0031), P6 ' Henry' (rank 10, p 0.0001), P7 ' door' (rank 8, p 0.0353). The predictor's README names the scored token and its rank for each prompt; everything else is unchanged. All 336 scalar, neuron and layer edits were predicted with no examples, Baseline against Read raw weights with the original prompt.
Table 1b. Lower-ranked target. Values ± 1 standard error; in parentheses Read raw weights − Baseline; last column the paired difference, shaded if beyond 1.96 standard errors.
| family | metric | Baseline | Read raw weights | Read raw weights − Baseline (paired) |
|---|---|---|---|---|
| scalar 132 edits | Spearman ρ (items) | 0.05 ± 0.04 | 0.05 ± 0.04 | -0.00 ± 0.05 |
| edit-level rank ρ | 0.49 ± 0.06 | 0.71 ± 0.04 (+0.21) | +0.21 ± 0.06 | |
| large-effect AUC | 0.72 ± 0.03 | 0.78 ± 0.03 (+0.06) | +0.06 ± 0.03 | |
| MAE (nats) | 0.45 ± 0.10 | 0.47 ± 0.10 (+0.02) | +0.02 ± 0.01 | |
| neuron 132 edits | Spearman ρ (items) | 0.03 ± 0.03 | 0.01 ± 0.04 (-0.02) | -0.02 ± 0.05 |
| edit-level rank ρ | 0.53 ± 0.04 | 0.71 ± 0.04 (+0.19) | +0.19 ± 0.04 | |
| large-effect AUC | 0.73 ± 0.04 | 0.83 ± 0.03 (+0.10) | +0.10 ± 0.04 | |
| MAE (nats) | 0.04 ± 0.00 | 0.06 ± 0.01 (+0.02) | +0.02 ± 0.00 | |
| layer 72 edits | Spearman ρ (items) | 0.20 ± 0.06 | 0.20 ± 0.06 | +0.00 ± 0.03 |
| edit-level rank ρ | 0.37 ± 0.09 | 0.43 ± 0.08 (+0.06) | +0.06 ± 0.07 | |
| large-effect AUC | 0.48 ± 0.03 | 0.52 ± 0.04 (+0.03) | +0.03 ± 0.03 | |
| MAE (nats) | 0.97 ± 0.14 | 0.98 ± 0.14 | +0.00 ± 0.01 | |
| all 336 edits | Spearman ρ (items) | 0.12 ± 0.03 | 0.11 ± 0.03 (-0.01) | -0.01 ± 0.02 |
| edit-level rank ρ | 0.72 ± 0.03 | 0.79 ± 0.02 (+0.08) | +0.08 ± 0.02 | |
| large-effect AUC | 0.86 ± 0.01 | 0.86 ± 0.01 | +0.00 ± 0.01 | |
| MAE (nats) | 0.40 ± 0.05 | 0.42 ± 0.05 (+0.02) | +0.02 ± 0.00 |
Fig. 1b. Spearman ρ and MAE per family for the lower-ranked target, Baseline against Read raw weights (n = edits). Error bars are ±1 standard error of the mean (bootstrap over edits).
Fig. 2b. Predicted against measured Δlogp of the lower-ranked token, Baseline (top) and Read raw weights (bottom), on symmetric log axes (linear within ±0.01 nats). No error bars (one point per item).
Read raw weights − Baseline: scalar -0.00 ± 0.05, neuron -0.02 ± 0.05, layer +0.00 ± 0.03, all -0.01 ± 0.02. Sign accuracy on items with |Δlogp| > 0.1: Baseline 0.56, Read raw weights 0.60 (724 items).
2.3 What predicts when reading helps?
For each edit, the benefit of reading the weights is how much closer Read raw weights gets to the true effect sizes than Baseline: the mean over the edit's prompts of |pr(|Baseline prediction|) − pr(|true Δlogp|)| − |pr(|Read raw weights prediction|) − pr(|true Δlogp|)|, where pr is the percentile rank within the family (positive = reading helps; this ignores calibration). It is compared with the edit's size relative to its matrix (|ΔW| over the matrix std for one entry, relative norm for a neuron, norm for a layer) and with the size of the true effect.
Table 2.3. Mean benefit ± 1 standard error, and its Spearman correlation with relative size and with true effect size, for the top-1 target (Table 1) and the lower-ranked target (Table 1b).
| family | top-1 target | lower-ranked target | ||||
|---|---|---|---|---|---|---|
| benefit | ρ with size | ρ with effect | benefit | ρ with size | ρ with effect | |
| scalar | +0.011 ± 0.011 | +0.19 | -0.03 | +0.014 ± 0.008 | +0.00 | -0.05 |
| neuron | +0.012 ± 0.007 | +0.12 | +0.05 | +0.028 ± 0.009 | +0.03 | +0.04 |
| layer | +0.013 ± 0.009 | +0.02 | +0.07 | +0.007 ± 0.008 | +0.23 | -0.02 |
| all | +0.012 ± 0.006 | +0.15 | +0.02 | +0.018 ± 0.005 | -0.01 | -0.05 |
By edit type:
| edit | benefit, top-1 target | benefit, lower-ranked target |
|---|---|---|
| add ±4 to one entry | +0.010 ± 0.019 (n=39) | -0.007 ± 0.015 (n=45) |
| zero one entry | +0.063 ± 0.021 (n=38) | +0.033 ± 0.015 (n=41) |
| zero or ×10 one norm gain | -0.034 ± 0.014 (n=43) | +0.016 ± 0.011 (n=46) |
| zero or ×5 one neuron | +0.012 ± 0.007 (n=120) | +0.028 ± 0.009 (n=132) |
| skip a sublayer or block | +0.013 ± 0.009 (n=60) | +0.007 ± 0.008 (n=72) |
No simple size measure explains it: the correlations are at most 0.23 with size and near 0 with the true effect size. The clearest pattern is the edit type: zeroing one entry (half of them the largest-magnitude weight in their matrix) benefits most for both targets, and single scalars with a change 10 to 200 times the matrix std benefit more than smaller or much larger ones.
3 Learning from examples
Earlier rounds of experiment 1 showed the model the measured effects (and weight files) of previous edits. A fixed test set (round 3's 36 non-token edits) was predicted with 0, 4 or 24 solved examples.
Table 4. ρ, edit-level rank and MAE ± 1 standard error; in parentheses the change from 0 examples.
| condition | metric | 0 examples | 4 examples | 24 examples |
|---|---|---|---|---|
| Baseline | Spearman ρ | 0.37 ± 0.10 | 0.38 ± 0.10 (+0.01) | 0.42 ± 0.10 (+0.05) |
| edit-level rank ρ | 0.87 ± 0.04 | 0.79 ± 0.07 (-0.08) | 0.87 ± 0.05 | |
| MAE (nats) | 0.76 ± 0.40 | 0.69 ± 0.38 (-0.07) | 0.71 ± 0.40 (-0.05) | |
| Read raw weights | Spearman ρ | 0.36 ± 0.11 | 0.37 ± 0.11 (+0.01) | 0.41 ± 0.10 (+0.04) |
| edit-level rank ρ | 0.86 ± 0.04 | 0.87 ± 0.04 (+0.01) | 0.90 ± 0.04 (+0.05) | |
| MAE (nats) | 0.76 ± 0.34 | 0.69 ± 0.38 (-0.07) | 0.75 ± 0.42 (-0.01) |
Examples improve the edit ranking with raw weights (Read raw weights: +0.05 ± 0.05 with 24 examples) and lower MAE for Baseline. The item ρ changes stay within about 2 standard errors.
4 Only cases where the output changed
The zero-shot predictions of Table 1, scored only on items or edits whose output changed noticeably (the same subset for both conditions).
Table 5. n items, Spearman ρ, sign accuracy (|Δlogp| > 0.1), and paired Read raw weights − Baseline ρ ± 1 standard error.
| subset | n | ρ Baseline | ρ Read raw weights | sign Baseline | sign Read raw weights | Read raw weights − Baseline |
|---|---|---|---|---|---|---|
| , Δ, > 0.1, all | 261 | -0.06 | -0.03 | 0.67 | 0.76 | +0.03 ± 0.04 |
| , Δ, > 0.1, scalar | 58 | -0.51 | -0.53 | 0.38 | 0.81 | -0.02 ± 0.06 |
| , Δ, > 0.1, layer | 202 | +0.20 | +0.28 | 0.75 | 0.75 | +0.08 ± 0.05 |
| , Δ, > 1, all | 54 | +0.12 | +0.02 | 0.61 | 0.96 | -0.09 ± 0.08 |
| , Δ, > 1, scalar | 30 | -0.22 | -0.41 | 0.30 | 0.93 | -0.19 ± 0.11 |
| edit KL > 0.1, all | 336 | +0.08 | +0.12 | 0.64 | 0.79 | +0.04 ± 0.03 |
| edit KL > 0.1, scalar | 144 | -0.28 | -0.16 | 0.26 | 0.80 | +0.12 ± 0.08 |
| edit KL > 0.1, layer | 192 | +0.25 | +0.39 | 0.79 | 0.79 | +0.14 ± 0.06 |
On real changes the clearest difference is the sign of large scalar effects. Within these cuts ρ is noisy and often negative for both conditions, because the ranking among items that all changed a lot depends on sizes that neither condition predicts well.
5 Experiment 2: which tokens rise under an amplification?
Edits large enough to change the output: one MLP neuron ×100, a whole MLP ×3, or one final-norm gain dimension ×30 (median mean-KL 0.2 to 0.7 in a pilot). For each edit the model named the 10 tokens whose log-probability rises most on average over the 8 prompts, among tokens that reach p ≥ 0.001. Score = mean percentile of the named tokens in the measured ranking (0.5 = a random plausible token, 0 = not plausible). Hit = share of named tokens in the measured top 50. Baselines from code: already likely (the 10 most likely tokens before the edit, excluding targets) and copy (top 10 of the edited component's vocabulary projection, with the better of the two signs). The final-gain edits were repeated on a second set of 32 dimensions.
Table 6. Score ± 1 standard error of the mean over edits, paired Read raw weights − Baseline, baselines, hit rate.
| family | edits | Baseline | Read raw weights | Read raw weights − Baseline | already likely | copy | hit Baseline | hit Read raw weights |
|---|---|---|---|---|---|---|---|---|
| neuron | 16 | 0.41 ± 0.05 | 0.39 ± 0.04 (-0.02) | -0.02 ± 0.02 | 0.40 | 0.14 | 0.16 | 0.16 |
| mlp | 12 | 0.33 ± 0.04 | 0.36 ± 0.05 (+0.03) | +0.03 ± 0.02 | 0.35 | 0.02 | 0.14 | 0.17 |
| gain | 16 | 0.45 ± 0.05 | 0.45 ± 0.05 | -0.00 ± 0.03 | 0.47 | 0.12 | 0.31 | 0.32 |
| all | 44 | 0.41 ± 0.03 | 0.41 ± 0.03 | +0.00 ± 0.02 | 0.41 | 0.10 | 0.21 | 0.22 |
| gain, second set | 32 | 0.38 ± 0.03 | 0.35 ± 0.03 (-0.03) | -0.03 ± 0.02 | 0.37 | 0.23 | 0.19 | 0.17 |
The tokens that gain probability are mostly ones already plausible in context, so Baseline is about as good as "already likely". Copying the vocabulary projection does badly (0.10), because the tokens it names are rare tokens that never become plausible.
6 Experiment 3: simulating the calculation
These edits have an effect that is an exact formula given one unknown per prompt, nd = the RMS-normalised final hidden state at dimension d.
- gain (24 edits): final-norm gain ×30 at dim d, giving Δlogitt = 29 (1+wd) nd E[t,d] for every token.
- emb (24 edits): add ±4 to E[t,d] of a target or runner-up token, giving Δlogitt = ±4 (1+wd) nd for that token.
A check with the true nd reproduces the edited model to within 2e-6 nats. Conditions: Read raw weights (gain and the targets' embedding entries); Read raw weights + needed numbers (also each prompt's top-50 unedited tokens with probabilities and E[t,d], and the column's extremes); + calculation recipe (the same numbers plus step-by-step instructions: estimate nd from the probability-weighted embedding entries, compute the new logits, renormalise; do the arithmetic yourself). The recipe was also run exactly by code, and once with the true nd (which needs activations) as a ceiling. Same score as Table 6, plus ρ and sign accuracy (|Δ| > 0.1) for target Δlogp.
Table 7. Experiment 3 results.
| family | condition | score | hit | Δlogp ρ | sign acc. | MAE |
|---|---|---|---|---|---|---|
| emb 24 edits; predict-0 MAE 6.86 | Baseline | 0.29 | 0.27 | +0.15 | 0.51 | 6.82 |
| Read raw weights | 0.31 | 0.28 | +0.21 | 0.47 | 6.62 | |
| Read raw weights + needed numbers | 0.29 | 0.25 | +0.15 | 0.49 | 6.81 | |
| Read raw weights + numbers + calculation recipe | 0.41 | 0.38 | +0.26 | 0.54 | 6.63 | |
| code runs the recipe | 0.52 | 0.50 | +0.15 | 0.60 | 7.32 | |
| code with the true n_d (needs activations) | 0.71 | 0.80 | +0.96 | 0.97 | 0.83 | |
| gain 24 edits; predict-0 MAE 0.92 | Baseline | 0.39 | 0.14 | +0.09 | 0.85 | 0.93 |
| Read raw weights | 0.36 | 0.17 | +0.20 | 0.66 | 0.95 | |
| Read raw weights + needed numbers | 0.23 | 0.24 | +0.14 | 0.76 | 1.17 | |
| Read raw weights + numbers + calculation recipe | 0.11 | 0.11 | +0.12 | 0.59 | 1.08 | |
| code runs the recipe | 0.30 | 0.33 | +0.16 | 0.72 | 1.28 | |
| code with the true n_d (needs activations) | 0.97 | 1.00 | +1.00 | 1.00 | 0.00 | |
| all 48 edits; predict-0 MAE 3.89 | Baseline | 0.34 | 0.20 | +0.10 | 0.71 | 3.88 |
| Read raw weights | 0.34 | 0.22 | +0.24 | 0.58 | 3.78 | |
| Read raw weights + needed numbers | 0.26 | 0.25 | +0.16 | 0.65 | 3.99 | |
| Read raw weights + numbers + calculation recipe | 0.26 | 0.24 | +0.21 | 0.57 | 3.86 | |
| code runs the recipe | 0.41 | 0.41 | +0.19 | 0.67 | 4.30 | |
| code with the true n_d (needs activations) | 0.84 | 0.90 | +0.98 | 0.99 | 0.42 |
Paired differences ± 1 standard error (bootstrap over edits); shaded if beyond 1.96 standard errors:
| family | recipe − Baseline | recipe − needed numbers | needed numbers − Read raw weights | Read raw weights − Baseline | ||||
|---|---|---|---|---|---|---|---|---|
| score | ρ | score | ρ | score | ρ | score | ρ | |
| emb | +0.12 ± 0.04 | +0.11 ± 0.16 | +0.12 ± 0.04 | +0.11 ± 0.10 | -0.03 ± 0.02 | -0.06 ± 0.09 | +0.02 ± 0.02 | +0.07 ± 0.14 |
| gain | -0.28 ± 0.06 | +0.03 ± 0.12 | -0.11 ± 0.05 | -0.02 ± 0.10 | -0.13 ± 0.06 | -0.05 ± 0.08 | -0.03 ± 0.04 | +0.11 ± 0.09 |
| all | -0.08 ± 0.05 | +0.11 ± 0.11 | +0.00 ± 0.03 | +0.04 ± 0.07 | -0.08 ± 0.03 | -0.08 ± 0.06 | -0.01 ± 0.02 | +0.14 ± 0.09 |
- Embedding-entry edits: the recipe helps (score 0.41 against 0.29 for Baseline and 0.29 with the numbers alone; hit 0.38 against 0.27). Giving the numbers without the recipe does not, so the gain comes from doing the calculation. It stays below the same recipe run by code (0.52).
- Final-gain edits: the recipe hurts (score 0.11 against 0.39). Even run exactly by code the recipe reaches only 0.30, while the true nd gives 0.97. The arithmetic is not the problem. The estimate of nd from the output distribution is too weak, and a 30× gain turns a wrong sign into large confident errors.
- For target Δlogp no condition beats predicting 0 on MAE.
7 Did it read the weights?
Table 6. Transcript audit of the Opus calls. "weight files" = distinct per-edit weight files read.
| experiment | predictor | condition | calls | tool calls / call | weight files / call | reads outside sandbox | retries | cost (list price) | time / call |
|---|---|---|---|---|---|---|---|---|---|
| exp1 | opus-5-5 | Baseline | 59 | 2.3 | 0.0 | 0 | 1 | $10.84 | 58 s |
| exp1 | opus-5-5 | Baseline v1 | 15 | 2.1 | 0.0 | 0 | 0 | $2.68 | 56 s |
| exp1 | opus-5-5 | Read raw weights | 59 | 19.1 | 13.7 | 0 | 0 | $82.81 | 95 s |
| exp1 | opus-5-5 | Read raw weights v1 | 3 | 17.0 | 14.7 | 0 | 0 | $2.31 | 90 s |
| exp1 | opus-5-5 | Read raw weights v2 | 15 | 20.1 | 15.2 | 0 | 0 | $15.82 | 99 s |
| exp2 | opus-5-5 | Baseline | 4 | 2.0 | 0.0 | 0 | 0 | $0.68 | 51 s |
| exp2 | opus-5-5 | Read raw weights | 4 | 24.8 | 19.0 | 0 | 0 | $1.84 | 102 s |
| exp3 | opus-5-5 | Read raw weights + recipe | 2 | 26.0 | 24.0 | 0 | 0 | $8.46 | 654 s |
| exp3 | opus-5-5 | Baseline | 2 | 2.0 | 0.0 | 0 | 0 | $0.51 | 84 s |
| exp3 | opus-5-5 | Read raw weights | 2 | 27.0 | 24.0 | 0 | 0 | $1.25 | 213 s |
| exp3 | opus-5-5 | Read raw weights + needed numbers | 2 | 29.0 | 24.0 | 0 | 0 | $5.99 | 481 s |
The only tool used was Read and every read stayed inside the sandbox. In a first pass of experiment 1 with optional reading, some calls read 1 of 12 weight files, so reading was made mandatory and that set was rerun. Notes cite specific values (for example "W[11751,880]=-0.00519 shifted by -4 (~200 std); ... final gain 1+3.7031=4.70"), so the numbers were read. In most cases they did not change the predictions in a useful way.
8 Caveats
- Each (set, family, condition) is one predictor sample, so predictor run-to-run variance is not separated from condition effects. The standard errors resample edits only.
- For layers, the raw files cannot hold all numbers, so they give norm tables, norm gains and the largest neurons.
- Most large scalar effects come from one edit type (±4 on a target-token embedding entry). One model and 8 prompts; other prompts or models may differ.
- Experiment 2 was repeated for the main text with Opus on the same edits after a first run with Fable (expandable below), so its measured effects existed before the Opus predictions. The predictor could not read them: reads outside the sandbox cause a call to be rejected, and there were none.
Views condition (raw weights plus derived views): not better than raw
A third condition gave raw weights plus views computed from weights only: vocabulary projections through the tied unembedding, input-token read-ins, SVDs, OV maps of the prompt tokens, and norm ranks.
Experiment 1 (first 180 edits, token edits included), Spearman ρ and paired views − Baseline:
| family | Baseline | Read raw weights | views | views − Baseline ρ | views − Baseline large-effect AUC |
|---|---|---|---|---|---|
| scalar | -0.00 ± 0.09 | 0.08 ± 0.08 | -0.00 ± 0.07 | +0.00 ± 0.09 | +0.36 ± 0.13 |
| neuron | 0.03 ± 0.06 | 0.03 ± 0.06 | -0.04 ± 0.06 | -0.07 ± 0.06 | n/a |
| layer | 0.22 ± 0.10 | 0.25 ± 0.09 | 0.28 ± 0.10 | +0.06 ± 0.02 | +0.03 ± 0.01 |
| token | 0.77 ± 0.03 | 0.77 ± 0.03 | 0.77 ± 0.03 | -0.00 ± 0.01 | +0.00 ± 0.00 |
| all | 0.35 ± 0.05 | 0.36 ± 0.04 | 0.34 ± 0.04 | -0.00 ± 0.02 | +0.02 ± 0.01 |
Experiment 2 (run with Fable 5.1 as predictor), score: views led the model to name vocabulary-projection tokens, which rarely become plausible, so views did worse than Baseline. They still beat plain copying of the projection.
| family | Baseline | views | views − Baseline | views − copy |
|---|---|---|---|---|
| neuron | 0.39 | 0.14 | -0.25 ± 0.07 | +0.08 ± 0.04 |
| mlp | 0.36 | 0.36 | -0.00 ± 0.01 | +0.36 ± 0.05 |
| gain | 0.48 | 0.16 | -0.32 ± 0.07 | +0.08 ± 0.04 |
| all | 0.42 | 0.21 | -0.21 ± 0.04 | +0.15 ± 0.03 |
Audit of the Opus views calls:
| experiment | predictor | condition | calls | tool calls / call | weight files / call | reads outside sandbox | retries | cost (list price) | time / call |
|---|---|---|---|---|---|---|---|---|---|
| exp1 | opus-5-5 | views | 20 | 18.0 | 12.0 | 0 | 3 | $19.56 | 94 s |
Fable 5.1 as the predictor: not better than Opus
The same bundles were given to claude-fable-5-1 with the same Read-only setup and checks (0 reads outside the sandbox). Experiment 1 zero-shot, Spearman ρ:
| family | Fable Baseline | Fable Read raw weights | Fable − Opus, Baseline | Fable − Opus, Read raw weights | Fable Read raw weights − Baseline | round-3 edits, Baseline O / F | round-3 edits, Read raw weights O / F |
|---|---|---|---|---|---|---|---|
| scalar | -0.11 | -0.03 | -0.03 ± 0.08 | -0.22 ± 0.14 | +0.08 ± 0.11 | 0.19 / 0.20 | 0.15 / 0.21 |
| neuron | -0.04 | -0.04 | +0.01 ± 0.03 | -0.05 ± 0.05 | +0.00 ± 0.04 | 0.06 / 0.06 | 0.12 / 0.12 |
| layer | 0.01 | 0.09 | +0.03 ± 0.05 | +0.02 ± 0.06 | +0.08 ± 0.05 | 0.50 / 0.40 | 0.46 / 0.49 |
| token | 0.75 | 0.84 | -0.05 ± 0.02 | +0.04 ± 0.04 | +0.09 ± 0.04 | 0.71 / 0.76 | 0.76 / 0.76 |
| all | 0.23 | 0.23 | -0.01 ± 0.02 | -0.06 ± 0.04 | +0.00 ± 0.03 | 0.44 / 0.42 | 0.43 / 0.44 |
Experiment 2 with Fable, score for Baseline and Read raw weights. For final-gain edits with KL > 0.1, raw looked better on the first 16 edits, but not on a second set of 32:
| subset | Baseline | Read raw weights | Read raw weights − Baseline |
|---|---|---|---|
| all, all | 0.42 | 0.44 | +0.03 ± 0.02 |
| KL>0.1, all | 0.40 | 0.45 | +0.05 ± 0.02 |
| all, gain | 0.48 | 0.56 | +0.08 ± 0.05 |
| KL>0.1, gain | 0.48 | 0.60 | +0.11 ± 0.04 |
| gain, second set (32 edits) | 0.38 | 0.32 | -0.06 ± 0.03 |
Fable audit:
| experiment | predictor | condition | calls | tool calls / call | weight files / call | reads outside sandbox | retries | cost (list price) | time / call |
|---|---|---|---|---|---|---|---|---|---|
| exp1 | fable-5-1 | Baseline | 16 | 2.5 | 0.0 | 0 | 0 | $9.94 | 120 s |
| exp1 | fable-5-1 | Read raw weights | 16 | 19.6 | 13.0 | 0 | 0 | $72.81 | 223 s |
| exp1 | fable-5-1 | views | 16 | 16.6 | 13.0 | 0 | 0 | $84.55 | 271 s |
| exp2 | fable-5-1 | Baseline | 4 | 2.0 | 0.0 | 0 | 0 | $2.02 | 88 s |
| exp2 | fable-5-1 | Read raw weights | 4 | 35.0 | 19.0 | 0 | 0 | $31.68 | 615 s |
| exp2 | fable-5-1 | views | 3 | 21.0 | 14.7 | 0 | 0 | $21.70 | 540 s |
Computational cost
- Opus predictor: 167 none/raw calls (133.20 USD at list price) and 20 views calls ($19.56), plus 12 first-pass calls ($4.24). Fable predictor: 59 calls, 222.69 USD at list price. All calls ran through the user's Claude Max subscription (OAuth, no API key), so these are list-price equivalents, not charges. 2 to 5 calls ran at a time; a call takes 1 to 15 minutes.
- Measuring effects: about 532 edit runs × 8 prompts, fp32 on CPU (one 176-core node), about 0.4 s per forward pass, under 30 minutes in total. No GPU (0 H100 node hours).
- Building the predictor files takes about 5 minutes per set on CPU, and the bootstrap analysis about 6 minutes.
Reproducibility
Repository https://github.com/csinva/weight-space-programming-autoresearch, branch systematic-tests (local). Use the repo-root uv env (uv sync). Question: can Claude Opus 5.5, reading only weight files (Read tool, no code), predict how weight edits of Qwen/Qwen3.5-0.8B (revision 2fc06364715b967f1860aea9cf38778875588b17) change the next-token distribution on 8 fixed prompts? Code in systematic-tests/: common.py (model, edit context manager), 00_make_prompts.py (data/prompts.json), 00_pilot.py (SCALAR_ADD=4), interventions.py + bundles.py + run_round.py (experiment 1), analyze.py, analyze_filtered.py, exp2_interventions.py + exp2_pilot.py + exp2_run.py + exp2_analyze.py (experiment 2), exp3.py + exp3_check.py (experiment 3). The model downloads to experiments/systematic-tests/.hf_cache. Predictor command, run with cwd = a copy of one bundle directory outside any repository: claude -p "Read README.md ... End with the JSON block" --model claude-opus-5-5 --restricted --tools Read --strict-mcp-config --output-format stream-json --verbose Experiment 1: uv run python experiments/systematic-tests/00_make_prompts.py; for R in 0 1 2: run_round.py build/predict --round R, git commit, run_round.py measure --round R ; few-shot: run_round.py build/predict --round 2 --variant k0|k4 before measuring set 3. Then analyze.main(), analyze_filtered.py. Experiment 2: WSP_X2_DIR=exp2_opus WSP_X2_CONDS=none,raw exp2_run.py predict --round 0 (bundles and measured effects as in exp2/; K: neuron x100, MLP x3, final gain x30); second gain set: WSP_X2_DIR=exp2_rep_opus WSP_X2_FAMS=gain. Score with exp2_analyze.py under the same env. Experiment 3: exp3.py build, exp3.py predict, git commit, exp3.py measure, exp3.py analyze. Report: uv run python analyze/systematic_tests/build_report.py Fable runs: the same scripts with WSP_MODEL=claude-fable-5-1 (experiment 1 with WSP_TAG=fable writes rounds_fable/; experiment 2 in exp2/, exp2_rep/).