On 10 November 2026, Hadi Salloum of QDeep in Riyadh and Ammar Ali of ITMO University posted Tree-Ising: Repairing Language Models with Bit-Level Ising Edits to arXiv. The tree ising method repaired Qwen3.5-0.8B for about $0.90 of GPU time, against $312 for the GPT-6 Astra agent edit it replaces (emergent.sh), and it scored 54.6% against 51.7% on MATH-500@4 (arXiv). Our verdict: for anyone maintaining an open-weights model with a known looping failure, Tree-Ising wins on cost, runtime and edit size, and the agent is only worth keeping as a way to diagnose the problem.
TL;DR
- Tree-Ising turns a weight repair into sparse discrete optimisation over BF16 bits, solved on a GPU with no LLM tokens (arXiv).
- It costs about $0.90 and 31 minutes, against $312 and about 15.6 hours for the agent run (emergent.sh).
- On MATH-500@4 it reaches 54.6% against the agent's 51.7%, a paired gain of 2.9 points (alphaXiv).
- It edits 13% fewer weights and flips 2.2 times fewer BF16 bits than the agent (alphaXiv).
- Results are math-only, author-reported, and not yet independently reproduced.
What is Tree-Ising and what did it replace?
Tree-Ising is a repair method for language models. It replaces the agent step in the MIT weight-space programming work by Takehi et al., where a GPT-6 Astra agent fixed reasoning loops in Qwen3.5-0.8B without gradients. That run took 158 agent turns, 89.7 million tokens and 50 forward-pass requests (arXiv).
The failure being repaired is specific. Qwen3.5-0.8B in thinking mode cycles repeated text on 93% of MATH-500 problems until it hits the 32,768-token cap, which leaves base accuracy at 7.9% (explainx.ai). We covered the agent edit and its audit in our earlier weight-space programming piece. This article covers the optimiser that makes the agent unnecessary.
How does tree ising repair a model's weights?
Tree ising defines an objective from forward-pass statistics. It weakens a "loop" direction, strengthens a "concluding" direction, and tries to leave outputs on productive tokens unchanged. The admissible edits are sign flips and exponent shifts on the model's own BF16 weights, constrained so that shared group exponents and mantissas are preserved (arXiv).
The useful property is that the objective decomposes exactly into independent QUBO (Ising) problems, one per output row. On the two edited layers that means 2,048 row problems of 512 spins each, solved on GPU with either simulated annealing (SA) or quantum-inspired simulated bifurcation (SB) (alphaXiv). Independent small problems parallelise well, which is why the whole job fits in half an hour.
Does Tree-Ising really beat the GPT-6 Astra edit?
Yes, on the paper's evidence, though the margin on accuracy is modest and the margin on cost is not. Under a unified evaluation harness, the agent edit scores 51.7% on MATH-500@4 (originally reported as 48.1%), and Tree-Ising SA scores 54.6% (explainx.ai). The SB solver is statistically indistinguishable at 55.1% (alphaXiv).
| Measure | GPT-6 Astra agent edit | Tree-Ising (SA) | Source |
|---|---|---|---|
| MATH-500@4 (base 7.9%) | 51.7% | 54.6% | alphaXiv |
| Cost | $312 | about $0.90 | emergent.sh |
| Runtime | about 15.6 hours | about 31 minutes | emergent.sh |
| Weights changed | 130,188 | 112,630 | alphaXiv |
| BF16 bits flipped | 621,388 | 278,767 | alphaXiv |
| LLM tokens used | 89.7 million | 0 | arXiv |
The paired accuracy gain over the agent is 2.9 points with p of about 0.003 (arXiv). Tree-Ising also beats the agent on all five math benchmarks, and after correcting for 12 multiple comparisons the MATH-500@4 and GSM8K gains remain significant (arXiv). On GSM8K@1 the base model's 13.8% rises to 70.8% (AI Weekly). The cost gap works out to roughly 350x, and the runtime gap to roughly 30x (emergent.sh).
Does the repair transfer to other models?
Partly, and without an agent. On Qwen3.5-2B, with layers and dose chosen using only the base model, the same recipe lifts greedy GSM8K accuracy from 21.6% to 69.4%. It edits 292,845 weights, which is 1.2% of the targeted matrices (AI Weekly).
The per-problem breakdown is worth reading: 669 test problems were solved only by the edited model, 38 only by the base, and 247 by both (AI Weekly). Few regressions relative to gains suggests the edit is targeted rather than a blunt shift. It is still one extra model family member, so treat it as encouraging rather than general.
What are the limits of the Tree-Ising result?
The authors disclose several, and they matter:
- Every benchmark is mathematical. Nothing here shows the method repairs non-math behaviour.
- There is no comparison against gradient fine-tuning or LoRA, so "cheaper than the agent" is not the same as "cheaper than the standard alternative".
- 100 of the 500 MATH-500 problems were seen during development. Excluding them, SA scores 53.8% against the agent's 50.8%, a paired gain of 2.9 ± 1.1 points (arXiv). The gain holds, but the contamination is real.
- All figures are author-reported until someone else reproduces them.
The quantum angle needs the same restraint. An eight-variable repair subproblem was run with QAOA on an IBM Heron processor (arXiv). That is a proof of concept. Since SB matches SA, no quantum hardware is needed today.
How would you reproduce a Tree-Ising repair?
The authors released code on GitHub covering SA, SB and experimental repair loops. It targets Python 3.11 on Linux with NVIDIA CUDA GPUs (blockchain.news). We have not run it, so the steps below are our reading of the method, not a tested recipe.
- Confirm a Linux machine with a CUDA GPU and Python 3.11, then clone the repository.
- Reproduce the failure first: measure how often your model loops to the token cap on a small problem set.
- Collect forward statistics on looping and concluding examples to define the loop and conclusion directions.
- Pick target layers and edit strength using only the base model, as the 2B transfer experiment did.
- Run the row-wise annealing, then check the changed-weight and flipped-bit counts are in the low hundreds of thousands, as in the paper.
- Evaluate on held-out problems with a paired test against the unedited model, not just a headline accuracy.
Which should you use: Tree-Ising or an agent edit?
Use Tree-Ising if you already know the failure mode. Four forward-pass requests, no LLM tokens and about a dollar of GPU time is hard to argue against, and the edits are smaller (arXiv). The agent still has a role where the failure is not yet understood, because the method depends on a correct diagnosis of the loop. For related open-weights decisions, see our notes on self-hosting LongCat 2.5, and for other comparisons against the same frontier agent, Hydrogen 1.0 vs GPT-6 Astra and GroundingPi vs GPT-6 Astra.
FAQ
Q: What is tree ising in simple terms?
A: It is a method that repairs a language model by choosing a small set of bit-level changes to its BF16 weights, framed as Ising optimisation problems and solved on a GPU, as described in the paper.
Q: How much does a Tree-Ising repair cost?
A: About $0.90 of GPU time and roughly 31 minutes for the annealing recipe on Qwen3.5-0.8B, against $312 for the agent run (emergent.sh).
Q: Do you need a quantum computer to use it?
A: No. The simulated annealing and quantum-inspired simulated bifurcation solvers run on a GPU, and the IBM Heron QAOA run covered only an eight-variable subproblem (arXiv).
Q: Is Tree-Ising better than LoRA fine-tuning?
A: Unknown. The paper does not compare against gradient fine-tuning or LoRA, so the only established result is the comparison with the GPT-6 Astra agent edit (arXiv).
Q: Has anyone independently verified the results?
A: Not yet, as far as we can tell at the time of writing. The figures are author-reported, and 100 of the 500 MATH-500 problems were used during development (arXiv).
This article was drafted with AI assistance and fact-checked line by line against the primary sources linked above. Corrections are logged and welcome. See how we work.
