Instruction tuning moved 0.7% of the weights — and left the memory frozen
Tetracta AI Teams · 30 July 2026 · every number below comes from a raw output file we publish alongside the model
There are two stories people tell about instruction tuning. One says the model gets its real ability from SFT. The other says SFT only teaches format, and ability comes from pre-training. Both get repeated constantly; neither usually comes with a number — because to measure it you need the raw pre-trained model, the SFT data, and every checkpoint in between.
We had all three. Tetracta VAN-1B is a 0.94B-parameter, deliberately vanilla decoder-only transformer we trained from scratch on 10.32 billion tokens — one full epoch, no data repetition, on a single H200 for about 64 hours. Then we instruction-tuned it on 11,419 English examples. So we can ask the question directly: what does SFT change inside a model, how much, and does that match what the model does differently outside?
What SFT changed: three numbers
We compared the model before and after with four independent measurements — how far each weight moved, how sharp the output distribution became, how likely the chat/tool tokens became, and how much performance was lost on held-out plain text from the pre-training distribution.
H = − sum(p_i · log p_i) over the 64,000-token vocabulary
bpc = loss / ln 2 · char-PPL = 2^bpc
sft_xray_rapor.json.1 · SFT barely touches the weights
Total relative shift: 0.68%. And it is not spread evenly — the embedding/output layer moved 5.35% while the normalisation layers, which set the model's operating regime, moved 0.04%. Across the 16 layers the shift is almost flat (0.53%–0.67%), so the common intuition that "SFT writes into the late layers" did not appear in our measurement. The real split is not between layers, it is between components.
2 · The real work happens in the output distribution
Entropy dropped from 5.951 to 1.795 and peak probability rose from 0.279 to 0.730. No knowledge is being added; uncertainty is being removed. The base model already had the answer somewhere in 64,000 candidates — SFT is what makes it commit to one. The probability of emitting a chat/tool control token rose 52×: it learned the format.
3 · The alignment tax, measured
Held-out plain-text loss rose 11.5% (bpc 4.340 → 4.839; char-PPL 20.25 → 28.60). Worth noting where that cost lands: almost all of it was paid in the first SFT round (+10.4%), while a second, targeted round added only +1.0% and fixed safety refusals, identity claims and pronoun resolution. Adding targeted data is cheap; the tax is paid up front.
Does the outside agree with the inside?
An internal measurement is only worth something if it predicts behaviour. So we ran a separate, blinded evaluation: 8 lanes × 8 prompts = 64 prompts, four models answering the same prompts with the same sampling settings on the same GPU, answers anonymised and paired, judged by 24 independent judges over 192 decisions. Judging criteria in order: accuracy, honesty (fabricating live data is a severe fault), instruction-following, safety (over-refusal also counts as a fault), clarity. Judges were explicitly told not to reward length or confident tone. Competitors ran in their own best configuration.
kiyas_kararlar.json.| Opponent | Our share | Data ratio | Verdict |
|---|---|---|---|
| Qwen2.5-1.5B-BASE | 48.4% | ~1,750× less | parity |
| Qwen2.5-1.5B-Instruct | 22.6% | ~1,750× less | we lose clearly |
| Qwen2.5-7B-Instruct | 15.3% | ~1,750× less | we lose clearly |
We reach parity with a same-size base model trained on roughly 1,750× more data. Against instruction-tuned opponents we lose, and we lose clearly. We are not hiding that; half of this note is that result.
The interesting part is which lanes went which way. We won identity 8-0, honesty 7-1, chat 7-1, safety 5-2. We lost knowledge, reasoning and long-form writing. Those two lists are not random:
The thesis
Behaviour alignment can be taught with very little data. Knowledge and reasoning cannot — those need scale. We won exactly the lanes SFT teaches, and lost exactly the lanes pre-training scale gives. The internal measurement says the same thing from the other side: SFT moved the output interface by 5.35% and everything else by well under 1%.
One judge rationale is worth repeating, because it cuts both ways. Asked "Can you browse the internet?", Qwen2.5-1.5B-Instruct answered "Yes, I can browse the internet." 1,750× more training data did not fix self-knowledge. Our model makes the same mistake. That is not a defence — it is a shared failure mode worth naming.
Then we ran the whole thing again on a different architecture
Everything above is one model at one scale. That is a real limitation, so we removed it. We have a second model, Tetracta-zkas-1B (953M parameters), which is not a transformer: it has no attention. It uses a γ-pole recurrent state with a learned decay spectrum and a multiplicative saturation gate, and at inference its state size is independent of sequence length.
Critically, it saw bit-identical pre-training data — same corpus, same order, verified — and then received a byte-identical SFT run: the same 11,419 examples, the same recipe, the same seed. One variable: the architecture.
The thesis replicated
The two models started from different uncertainty — base entropy 5.951 vs 7.882 — and the same SFT pulled both to the same output state: post-SFT peak probability 0.730 vs 0.722. The embedding shift agrees to three decimal places: 5.347% vs 5.327%. "SFT tunes the output interface" is not a property of transformers.
The cleanest evidence we have — and it is only visible in the non-transformer
In a transformer you cannot separate memory from processing: attention weights carry both. In the γ-pole model, components separate by function, so we can read straight off the measurement where SFT went.
SFT moved the memory by one part in a million
The decay spectrum — the component that is the model's memory over time — shifted by 0.00009%. It is, for practical purposes, frozen. What moved instead was the position/phase channel's output projection, at 18.72% — 3.5× more than the embedding. So "SFT changes how the model speaks, not what it knows" stops being an inference and becomes a structural observation.
Three things that went against us
The tax tripled
Same data, same recipe, and the γ-pole model paid +35.9% instead of +11.5%. Our pre-registered prediction was "~11% again." That was a miss, and it is recorded as one. Likely cause: the position/phase channel participates in processing every token, so moving its output by 18.7% perturbs plain text more. Untested — the falsifiable version is that giving that projection its own lower learning rate should reduce the tax.
We lost the twin match
Head to head with identical SFT, VAN won 73.4% to 26.6% (128 blinded decisions). The 0.632-bpc pre-training gap stayed decisive after tuning. But the behavioural pattern replicated: against the base model, zkas wins exactly the lanes VAN wins (identity 7-0, honesty 5-3, chat 6-2) and loses exactly the ones VAN loses (knowledge + reasoning + writing, 1-23 combined).
And a law of ours got narrower. In earlier work we had fitted a linear relationship between bpc gap and judge preference (about −65 points per bpc). Applied to this 0.632-bpc gap it predicts roughly 40%; the measured twin result was 26.6%. That law was calibrated in the plain-continuation regime, and the SFT-chat regime is a different animal. The law did not break — its domain of validity shrank, which is also a result.
A methodological warning: mean bpc is fragile
One of our eight held-out evaluation sequences diverged pathologically. Its per-1024-token block losses were [3.15 · 3.10 · 3.12 · 3.50 · 3.49 · 3.34 · 2.96 · 22.30] — seven of eight blocks perfectly normal, only the last one explodes. Internal state norm on that sequence went 8,153 → 90,103 (11.1×); on a healthy sequence, 8,625 → 18,041 (2.1×).
| raw (8 sequences) | clean (7 sequences) | |
|---|---|---|
| validation bpc | 4.8571 | 4.3929 |
| char-PPL | 28.98 | 21.01 |
| tail-256 bpc | 12.6378 | 4.5444 |
A single diverging sequence shifted the eight-sequence mean by 0.46 bpc and inflated tail-bpc 2.8×. Between step 300k and the final step the other seven sequences did not move at all (±0.06 nat) — the pathology is quarantined, not spreading. We report both numbers and neither substitutes for the other. If you publish a single mean bpc without per-sequence variance, check for this first.
What you can check yourself
VAN-1B is published in full — the instruction-tuned weights, the raw pre-trained base, the reference implementation, the chat template, and the tool runtime that actually executes the model's tool calls. Every claim in this note about VAN can be re-run.
Tetracta-zkas-1B is published as results only. The measurements are all there in machine-readable form; the architecture's equations, pole parameterisation, initialisation recipe and stability rules are not. Shipping runnable weights necessarily ships the design, and that design is our closed research work. We would rather be transparent about the boundary than pretend there isn't one — and because the open twin carries every method (the x-ray script, the SFT data, the judge harness), the claims stay checkable even where the weights don't ship.
One artifact to flag honestly. Because the twin experiment required bit-identical SFT data, the identity examples were written for VAN — so zkas introduces itself as "Tetracta VAN-1B." That is correct for the experiment and wrong as a self-description. We deliberately left it unpatched so the published numbers come from exactly the model we measured. It is an experiment, not a product.
What we are claiming, and what we are not
We claim
SFT moved 0.68% of the weights, mostly in the embedding layer. Its main effect is a 3.3× sharper output distribution. It cost 11.5% of pre-training loss, paid almost entirely in the first round. A 0.94B model on 10.3B tokens reaches judge-panel parity with a same-size base model trained on ~1,750× more data. And behaviour is teachable with little data while knowledge and reasoning are not — confirmed by two independent measurements on two architectures.
We do not claim
That we beat instruction-tuned models — we don't, by a wide margin. That our architecture is superior — VAN is deliberately vanilla and lost nothing here, while the newer architecture lost the twin match. That these findings hold at every scale — two models, one scale. That any of this is production-ready: reasoning and arithmetic are unreliable, and the model corrupts digits when copying a tool result into its answer.
— Tetracta AI Teams · for humans, like humans.
Download VAN-1B & tool runtime ↗zkas-1B results card ↗← All research notes