Researchers at ITMO University and QDeep have demonstrated a method to repair language models by directly editing their weights at the bit level. The team’s Tree-Ising approach boosted Qwen3.5-2B’s accuracy on the GSM8K benchmark from 21.6% to 69.4% through edits that preserve shared exponents and mantissas.

This contrasts sharply with a GPT-6 Astra agent, which required 15.6 hours and $312 per edit to attempt a similar fix, while Tree-Ising completed its repair in 31 minutes for $0.90. The work addresses a significant looping issue in Qwen3.5-0.8B, where 93% of attempts to solve MATH-500 problems failed to produce an answer before hitting a 32k token cap.

A critical limitation of the Qwen3.5-0.8B language model is its propensity to loop during problem-solving, with 93 percent of attempts to answer MATH-500 questions reaching the 32,768-token cap before producing a solution. This looping behavior manifests as repetitive text generation, effectively halting progress and restricting the model’s accuracy to just 7.9 percent on the benchmark. The issue arises when the model enters “thinking mode”, a state intended to facilitate complex reasoning, but instead leads to cyclical outputs.

Researchers identified that this failure mode stems from the model’s multilayer perceptrons in layers 15 and 19, pinpointing the source of the repetitive behavior. Addressing this looping issue with existing methods proves costly and time-intensive. A GPT-6 Astra agent required 158 agent turns, consuming 89.7 million tokens and 50 forward-pass requests to attempt a repair of Qwen3.5-0.8B.

This boost in performance is achieved while simultaneously reducing the proportion of looping answers by two-thirds, indicating a robust solution to the previously identified problem.

Each edit undertaken by the Astra agent incurred a cost of $312, highlighting the substantial resources needed for conventional approaches to language model correction. This contrasts sharply with the new Tree-Ising method, which achieves comparable fixes with significantly reduced expenditure and processing time. The team’s approach focuses on bit-level edits, directly manipulating the model’s weights without relying on gradient calculations. The Tree-Ising method, using forward statistics, casts the repair process as a sparse discrete optimization problem.

This allows for the implementation of sign flips and exponent shifts within the model’s weights, preserving the integrity of shared exponents and mantissas. By decomposing the optimization into independent QUBO problems solved on a GPU, the process achieves a runtime of 31 minutes and a cost of $0.90 per edit.

The efficiency of Tree-Ising is further demonstrated by its ability to reduce the number of state-tree bits written to 181,000, compared to the 721,000 required by the GPT-6 Astra agent. The model’s greedy accuracy increased dramatically from 21.6 percent to 69.4 percent, a nearly 230 percent improvement. Tree-Ising achieves 54.6% on MATH-500, outperforming the agent’s edit (51.7%) under the same evaluation protocol, while the base model scores only 7.9%.

“Two highest layers, excluding the final layer” were targeted for the most prominent demonstration of this improvement. The method’s success suggests a viable path toward efficient and effective language model repair, potentially unlocking improved performance and reliability in future iterations.

Tree-Ising: Optimization via QUBO Decomposition

The optimization process within Tree-Ising relies on formulating the language model repair as a series of independent Quadratic Unconstrained Binary Optimization (QUBO) problems, one for each output row of a targeted layer. This decomposition allows for parallel processing on a Graphics Processing Unit (GPU) using simulated annealing or a quantum-inspired simulated bifurcation method, accelerating the search for optimal weight adjustments. Each QUBO problem represents a sub-problem focused on a specific row of the model’s weight matrix, enabling efficient exploration of potential edits.

Tree-Ising’s approach differs from earlier weight-space programming techniques, such as the GPT-6 Astra agent, by directly addressing the computational demands of model repair. This method uses forward statistics to define an objective that simultaneously weakens directions leading to looping behavior, strengthens pathways toward conclusive answers, and preserves the model’s output on correctly processed tokens.

This performance boost stems from a fundamentally different approach to model repair, casting the problem as a sparse discrete optimization over the model’s native BF16 weights and using a state-tree representation for lossless storage. The resulting checkpoint, created at a cost of $0.90, represents a substantial efficiency gain over the agent’s 15.6-hour runtime and $312 per edit expense for a comparable fix.

A key innovation lies in the representation of model weights, W ∈ R^(d× n), where d denotes the number of output rows and n the number of input neurons. This representation unifies low-bit compression and exact storage, with lossless BF16 storage serving as a specific instance. A BF16 number comprises a sign bit, an 8-bit exponent *e*, and a 7-bit mantissa, grouped into 64 consecutive weights per row.

The system stores a maximum exponent *E* as a shared node, with each weight storing a 4-bit state *D* = *E* – *e* and its sign and mantissa. A separate side list maintains the rare escape case where the exponent is not shared. The method also demonstrated a substantial improvement in greedy accuracy on the Qwen3.5-2B GSM8K benchmark, increasing performance from 21.6% to 69.4%.

Statistical significance was found on MATH-500 and GSM8K after correcting for multiple comparisons. Tree-Ising modifies 13% to 17% fewer weights and reduces BF16 bit flips by a factor of 2.2 to 2.3. The agent required 50 forward-pass requests, consuming 15.6 hours of GPU time and 89.7 million tokens, while Tree-Ising completed the task in 31 minutes with only four forward passes and no token usage. Tree-Ising operates without writing to shared exponents or mantissas, a design choice that simplifies the repair process and potentially enhances stability.

This improvement in problem-solving ability stems from a method that significantly reduces computational demands, a key factor in scaling language model repair. The work demonstrates a substantial reduction in resource expenditure, achieving comparable results with a fraction of the cost and time required by the agent-based approach.

Specifically, Tree-Ising restricts admissible edits to sign flips and exponent shifts within each weight group’s state tree, evaluating them using forward statistics. The system’s design eliminates the need for LLM tokens altogether, bypassing the substantial cost associated with prompting and processing large language models during the repair process. Beyond speed and cost, Tree-Ising also minimizes the extent of model disruption, modifying 13% fewer weights and significantly reducing bit flips.

The method produced 112,630 changed weights compared to the agent’s 130,188, and reduced state-tree bit flips from 720,586 to 181,062, a fourfold decrease. “Both simulated annealing and the quantum-inspired simulated bifurcation solver yield repairs of equivalent quality,” the paper states, “demonstrating that the performance gains stem fundamentally from the mathematical formulation itself rather than the tuning of a specific solver.” The reduction in computational burden extends to forward-pass requests, with Tree-Ising requiring only four compared to the agent’s 50.

This translates to 12.5 times fewer forward passes, and a 34-fold reduction in GPU time, 21.8 minutes for Tree-Ising versus 12.2 hours for the agent. The researchers also observed a 1. The work quantifies the computational expense of a single repair, highlighting the potential for efficient and scalable language model refinement.

Qwen3.5-2B GSM8K Accuracy Boost with Optimized Recipe

For context, a dense closed-form solution attempting the same objective modifies 96% of the weights in both matrices, 62 times as many as Tree-Ising, demonstrating a more targeted approach to repair. The recipe was designed after analyzing publicly available logs of a GPT-6 Astra agent, reusing the agent’s selected layers 15 and 19 and calibrating the dose based on the agent’s initial edit, allowing for a direct comparison of the exhaustive search for a fix versus the application of a pre-optimized solution. “Crucially, this process requires no LLM agent, no reference checkpoint, and no gradient computations,” the paper states, emphasizing the streamlined nature of the approach.

Forward Statistics Define Tree-Ising’s Objective Function

The Tree-Ising method defines its repair objective by using forward statistics, specifically quantifying the impact of potential weight adjustments on a language model’s tendency to loop during reasoning. This approach moves beyond simply identifying errors to proactively weakening looping behavior while simultaneously reinforcing the model’s ability to reach a conclusive answer, all while preserving performance on correctly processed tokens. The objective function, as detailed in the work, centers on manipulating the model’s weights to favor concluding directions in its reasoning process.

This statistical foundation allows for a highly targeted repair strategy, focusing on adjustments that maximize impact with minimal disruption. The researchers decompose this objective into independent Ising problems, one for each output row, enabling parallel processing on standard GPU hardware or, potentially, quantum processing units. The process begins with a forward scan of the base model, assessing each layer’s contribution to both looping and conclusive reasoning.

👉 More information
🗞 Tree-Ising: Repairing Language Models with Bit-Level Ising Edits
✍️ Hadi Salloum and Ammar Ali
🧠 ArXiv: https://arxiv.org/html/2611.14210v1

More like this