Editing a Turkish model's weights, with no training

Two days ago a team at MIT CSAIL showed that GPT-6 Astra can read a small language model’s raw weights, find the part that misbehaves, and fix it by hand. No gradient descent, no training loop. I wanted to know whether that holds up outside the paper, on a model nobody tuned the method for. So I ran the same setup on Kumru, a Turkish model trained from scratch, and spent $2.33 of GPU time finding out.

The short version: weight editing removed a bad habit each time. It fixed the math model’s loops and the grammar model’s urge to rewrite sentences. It did not add knowledge. Kumru-2B can’t do grade-school arithmetic, and no edit changed that. Where the model already knew the skill, a small edit made it measurably better.

The idea I wanted to test

The MIT post, “Sparks of Weight-Space Programming” by Rikiya Takehi, Jayden Teoh, Alex Zhang and Omar Khattab, gave Astra a Python kernel over Qwen3.5-0.8B’s weights and a budget of 50 forward passes. Qwen3.5-0.8B knows a fair amount of math but falls into thinking loops: 93% of its answers ran to the 32,768-token limit. Astra traced the loop to one direction written by the MLPs of layers 15 and 19 and subtracted it from 64 output columns in each. That is 131,072 weights, 0.016% of the model. MATH-500 went from 7.9% to 48.1%.

The same post has a quieter result. On Gemma 3 270M, which rarely loops, Astra could not improve math at all. Gemma’s mistakes were ordinary arithmetic errors with no single component behind them. I read that as the real hypothesis: an edit can remove an obstacle sitting in one place, but it can’t install a capability the model never learned.

Kumru looked like a good place to check that hypothesis. VNGRS trained Kumru-2B from scratch on 300B Turkish tokens and released it under Apache-2.0. It uses a standard Mistral layout with 18 layers, so the MIT approach carries over without changes. There is also a community reasoning fine-tune, Kumru-2B-turkish-reasoning, which turned out to have exactly the kind of failure Qwen had.

The harness

I rebuilt MIT’s setup from their published logs and matched its rules wherever I could. Astra runs through the Codex CLI at maximum reasoning effort. It never touches the model directly. Every action goes through a small client, ws.py, that talks to a model server on a rented GPU.

The server gives Astra three tools:

• exec runs Python in a kernel where W maps parameter names to the live tensors. Changing W changes the model. Astra gets 300 runs.
• forward makes the current model answer up to 512 practice items with the evaluation’s sampling settings, or runs the original and edited model side by side on the same 256. It costs one pass.
• read runs the model teacher-forced over up to 1,024 texts Astra writes and stores hidden states, MLP activations, attention maps and token log-probs. It also costs one pass.

Each experiment had 50 passes. Astra could use linear algebra on the weights and on activations it had read: means, differences, projections, SVD, a ridge solve. It could not run a backward pass, an optimizer, or any loop that fits weights to a loss.

How I tested it

The rule that matters most: Astra never sees the data I report. It works on the training split of each dataset, holds back its own untouched practice items for a final paired check, and saves one edit. I then run that edit on a held-out test sample with the same sampling I used for the baseline.

All generation uses vLLM at temperature 0.7 and top-p 0.9, the sampling in VNGRS’s own example minus its repetition penalty. Sampling adds noise, so I report paired results: the same items, original against edited.

Experiment 1: math

I scanned both Kumru models on 200 problems from the Turkish GSM8K test set (malhajar/gsm8k-tr), allowing 4,096 new tokens.

The reasoning fine-tune had Qwen’s problem. Asked how many days early Mike finishes a 200-page book, it wrote “Mike son teslim tarihine 3 gün kala bitirecek” and then repeated that sentence for 4,096 tokens. Repetition penalty, the usual sampling fix, made the loops worse.

The scan also showed something I didn’t like. When the reasoning model finished cleanly, without looping or copying the question, it got 0 of 42 answers right. The base model got 0 of 145. Kumru doesn’t know this math. I ran the experiment anyway, because it would tell me whether the Gemma result generalizes.

What Astra found

Astra spent 48 passes and about two hours. Its notes are more interesting than its final edit:

• After the model copies the question, it ends its turn with probability 0.80. After a correctly written solution, that probability is 0.0001. The fine-tune learned to parrot and stop.
• Three attention heads (layer 8 head 5, layer 12 heads 9 and 11) put about 80% of their attention on the next token to copy. Zeroing them cut question copying from 61.7% to 1.6% on practice data and pushed loops from 23% to 80%. Astra rejected that edit.
• The repetition signal spreads over many layers. Projecting it out of 64 columns in each of layers 6 to 17 barely helped.

Its final edit added three rank-1 updates to the layer-14 MLP that steer the model from “copy the question” toward “write a solution,” and one rank-1 update to layer 17 that pushes the end-of-turn token whenever a repetition pattern shows up.

Result

The loops are gone, and repetition penalty can’t do that. Accuracy stayed at zero, and answers shrank from 953 tokens to 63 on average. Many of the short ones are nonsense. The model learned when to stop. It did not learn arithmetic. This reproduces MIT’s Gemma result on a different model and language.

Experiment 2: grammar correction

For a fair second test I needed a task Kumru-2B is good at. VNGRS reports that it does best on Turkish-specific tasks like grammatical error correction, so I scanned 400 sentences from the test split of GECTurk. About half contain injected spelling or grammar errors. The rest are already correct and should come back unchanged.

Kumru-2B corrected 38.7% of the erroneous sentences exactly and returned 63.7% of all sentences identical to the reference. The mistakes fell into a pattern:

• It rewrote words the reference keeps in 19% of sentences. It dropped “bir,” expanded “THK” to “Türk Hava Kurumu,” turned “başarabilmiş değil” into “başaramamış.”
• It damaged 14.5% of sentences that were already correct.
• It left 20.4% of erroneous sentences untouched.

The first two look like behaviour, a pull toward paraphrase, from a model that knows Turkish spelling. That was the situation where I expected an edit to help.

The scan also caught something worth knowing if you run Kumru. VNGRS’s model card samples with repetition_penalty=1.1. On this task that setting halves exact accuracy, from 63.7% to 34.5%, because correcting a sentence mostly means copying it, and the penalty punishes copying.

What Astra found

Astra finished in about 50 minutes, using 20 of its 50 passes. It found the same kind of copy heads as in Experiment 1 (layer 8 heads 4 and 5, layer 12 heads 9 and 11, layer 14 head 7). Amplifying them reduced rewriting but made the model miss more errors, a direct copy-versus-correct trade-off.

The edit it kept works on the layer-11 MLP. Astra read the residual stream under three versions of the instruction: the standard one, one that asks for a fluent rewrite, and a long one that spells out minimal edits. It took two directions from those reads:

• r, the average difference between “correct this” and “rewrite this”
• s, the average difference between the long minimal-edit instruction and the standard one

A plausible guess would have used s as is. Astra checked and found the long instruction lowered the likelihood of the reference answers, so it subtracted s instead. It then chose 256 MLP neurons that fire while the model writes its answer but stay quiet while it reads the source sentence, and solved a ridge regression for a gate g over them. On held-out diagnosis rows the gate averaged 0.96 at answer positions and 0.02 at source positions.

# d: direction in the 3072-d residual stream
# J: the 256 chosen columns of layers.11.mlp.down_proj
d = 2 * r - s
D[:, J] += d[:, None] * g[None, :]

That is one rank-1 update to one matrix. On 512 practice sentences it had never touched, Astra measured 58.6% → 63.1% exact, with 31 sentences fixed and 8 broken.

Result

Paired on the same 400 sentences, 19 went from wrong to exact and 6 went the other way (exact McNemar test, p = 0.015). Sampling noise contributes to both counts, so treat the size of the gain as approximate. The direction held in every check Astra and I ran: validation, confirmation, the final practice set, and the test set.

A few sentences show what changed:

It also broke things. In one validation sentence the edited model left “yollıyanlar” misspelled where the original had written “yollayanlar,” and in another it dropped a pair of parentheses.

Where the edits landed

Raw weight counts can mislead. The math edit changed 2.63% of the model, nearly 500 times as many weights as MIT’s Qwen edit, yet it amounts to four rank-1 terms. The grammar edit is a single rank-1 term restricted to 256 columns: about six times MIT’s weight count, still a few hundredths of a percent.

What it cost

All of it ran on single RTX 4090s from Vast.ai at $0.36 to $0.43 an hour. A 2B model fits easily, and vLLM generates 400 short corrections in about a minute. Astra’s own usage isn’t in this table: it ran through the Codex CLI, and I didn’t meter its tokens.

About a third of the GPU money bought nothing, counting the machines in China and a few in Experiment 1 that never finished booting. These cost me time and are cheap to avoid:

• Pick hosts outside mainland China. PyPI downloads crawled on two of them, and the cheapest offers cluster there.
• Use pytorch/pytorch:2.8.0-cuda12.8-cudnn9-runtime. The vLLM image sat in “loading” for 10 minutes on several hosts; this one boots in 40 seconds. It then needs gcc, a newer brotli, and VLLM_USE_FLASHINFER_SAMPLER=0.
• Kumru ends a turn with <|eot_id|>, while its tokenizer’s EOS is a different token. Stop on both, or every answer looks like a loop.
• Run long jobs under nohup and keep the SSH tunnel in a reconnect loop. Mine dropped once mid-run; the model server and Astra’s kernel state survived because they lived on the GPU box.
• Charge the pass budget only when a request succeeds. My first server version billed two out-of-memory failures.

Halfway through Experiment 2 I needed to close my laptop, so I moved the Codex session to a VPS and resumed the same conversation there. After one sandbox error, Astra picked up where it had left off.

What I’d take away

Before you point a weight editor at a model, check whether the model gets the answer right when the failure doesn’t fire. If it does, you are looking at an obstacle, and an edit like these has something to remove. If it doesn’t, you need training data, and no amount of linear algebra on the weights will substitute for it.

Astra also caught a few of my own measurement mistakes along the way. My first accuracy metric counted copied questions as correct when the last number happened to match, and my server charged failed requests. Both fixes are in the numbers above.

Thanks to the MIT CSAIL authors for publishing complete logs, which made a faithful reproduction possible, and to VNGRS for releasing Kumru under an open license. Datasets: GSM8K-TR by malhajar, GECTurk by Kara et al. Every number in this post comes from saved model outputs; the edits, Astra’s reports, decision logs and transcripts are archived with them.