TinyLoRA: Can 13 Parameters Teach an LLM to Reason?

Share
TinyLoRA: Can 13 Parameters Teach an LLM to Reason?

A model with billions of weights improves its mathematical reasoning after just thirteen trainable numbers are changed. The interesting question is not how small the update is, but what the model already knew.

Modern language models are routinely fine-tuned with millions, sometimes billions, of trainable parameters. Even parameter-efficient methods such as LoRA generally require substantial adapters. It is therefore surprising to see a large model improve on a reasoning benchmark after training an update that fits into 26 bytes.

In Learning to Reason in 13 Parameters, John X. Morris and colleagues at Meta FAIR, Cornell University, and Carnegie Mellon University introduce TinyLoRA, a parameterization that can shrink the number of trainable values to a single scalar. Combined with reinforcement learning, it takes Qwen2.5-7B-Instruct from 76% to 91% accuracy on GSM8K with 13 trainable parameters. With 120 parameters, the model reaches 95%.

The result does not suggest that thirteen numbers contain an entire mathematical education. Instead, it raises a subtler possibility: when much of the required knowledge is already present in a pretrained model, improving performance may be more about steering existing capabilities than storing new ones.

Based on Morris et al., Learning to Reason in 13 Parameters (arXiv:2602.04118, February 2026). All reported results below are from the paper; interpretation is identified where relevant.

Why LoRA still needs so many parameters

Ordinary fine-tuning changes the weights of a pretrained network. LoRA reduces this cost by leaving the original weight matrix frozen and learning a low-rank correction. Rather than updating an entire matrix, it learns two smaller matrices whose product modifies the layer's behavior.

This is a major reduction, but it is not arbitrarily small. Even at rank one, the adapter's size remains tied to the dimensions of the layer. When the method is applied to many attention and feed-forward projections across a transformer, those values accumulate. The authors cite roughly three million trainable parameters for minimum-rank LoRA on an 8B-scale model.

LoRA-XS takes a different approach: it obtains a set of directions from the singular value decomposition (SVD) of a frozen weight matrix and learns how to recombine them. This reduces the trainable component considerably, but typically still requires separate trainable values across the adapted modules.

TinyLoRA compresses that final piece. Rather than learn a full recombination matrix, it constructs the matrix from a small trainable vector projected through fixed random matrices. More importantly, the same trainable vector can be shared across multiple layers and modules. The number of learned values is then determined by the size of that shared vector, not directly by the width or depth of the backbone.

The TinyLoRA update
W′=W+UΣ( ∑i=1u vi Pi) V⊤
Only the coordinates v are trained. The pretrained weight W, SVD components U, Σ, V, and random projection matrices P remain fixed. Sharing v across modules can reduce the trainable update to one parameter. Adapted from Section 4 of the paper.

That distinction is essential. TinyLoRA is not removing the pretrained model or generating a useful update from nothing. It is optimizing a tiny set of coordinates inside an update structure built from large, fixed components. The trainable information is extraordinarily compact; the computational system that makes those coordinates meaningful is not.

The striking result is really about reinforcement learning

The authors compare two ways of training the same underlying model. Supervised fine-tuning (SFT) asks the model to imitate target answers token by token. Reinforcement learning instead samples responses and rewards those that satisfy a verifiable criterion. In the experiments, the reinforcement-learning algorithm is GRPO, using exact-match rewards for mathematical answers.

In the extremely small parameter regime, the difference is substantial. On the GSM8K-only training setup, Qwen2.5-7B-Instruct starts at 76% accuracy. With just thirteen trainable parameters, GRPO raises it to 91%, while SFT reaches 83%. At 120 parameters, GRPO reaches 95%; SFT reaches 84%.

Accuracy on GSM8K, by training method
GSM8K accuracy with 13 and 120 trainable parameters At 13 parameters, GRPO reaches 91 percent, supervised fine-tuning 83 percent. At 120 parameters, GRPO reaches 95 percent and SFT 84 percent. The untrained baseline is 76 percent. All bars use a zero-to-100 percent scale. 0 25 50 75 100% 76% baseline 13 parameters GRPO SFT 120 parameters GRPO SFT 91% 83% 95% 84%
Qwen2.5-7B-Instruct, GSM8K-only setup. The dashed line marks the untrained 76% baseline. Orange indicates GRPO; charcoal indicates SFT. Results reported in Section 6.2 and Figures 1–2 of the paper. The axis begins at zero to avoid exaggerating the differences.

The paper's proposed explanation is about the information contained in the learning signal. In SFT, the model is pushed toward an entire reference solution, including its wording and intermediate choices. In reinforcement learning with a verifiable reward, the decisive information is whether a sampled solution succeeds. By sampling repeatedly, reward-correlated changes can accumulate without requiring the model to reproduce every detail of a demonstration.

This is a compelling hypothesis, but it should not be mistaken for a general proof that reinforcement learning always learns more efficiently. The result is established in these training settings, at these adapter sizes, on these mathematical tasks. Other types of supervision or different reward signals could change the comparison.

The smaller the trainable update, the more important the distinction becomes between teaching a model new information and eliciting behavior it can already produce.

Does the effect survive harder mathematics?

GSM8K is useful, but it is not enough to establish a broad advance in reasoning. The authors therefore extend their experiments to a more demanding mathematics-training setup and evaluate across six benchmarks, including MATH500, AIME 2024, AMC 2023, Minerva Math, and OlympiadBench.

Here the results are less spectacular in absolute terms, but arguably more informative. On Qwen2.5-7B-Instruct, a 13-parameter update raises the six-benchmark average from 40.3 to 50.1. With 196 parameters, it reaches 53.2, compared with 55.2 for the reported full-fine-tuning reference. That 196-parameter update recovers roughly 87% of the improvement between the untrained and fully fine-tuned scores.

Trainable parametersMATH500AIME24Six-task average
0 (base model)64.63.340.3
13 (TinyLoRA)74.616.050.1
196 (TinyLoRA)76.616.753.2
Full fine-tuning78.220.055.2
Selected values from Table 2 of the paper, for Qwen2.5-7B-Instruct under the harder MATH-training protocol. Numbers are benchmark scores, with the final column averaging six benchmarks.

Important comparison detail: the base-model and full-fine-tuning reference scores in Table 2 are taken from the earlier SimpleRL study, rather than produced in the same TinyLoRA runs. The GSM8K scores in this table also come from a different training/evaluation setup than the 76% → 91% experiment above; the two baselines should not be treated as interchangeable.

The data also resist an overly simple interpretation. Increasing the number of trainable parameters generally helps, but not every metric improves monotonically, and some smaller updates remain noticeably behind full fine-tuning. AIME, for example, rises from 3.3 to 16.7 with 196 parameters, but reaches 20.0 in the full-fine-tuning reference. TinyLoRA can recover a large share of the improvement; it does not uniformly eliminate the gap.

What fits into 26 bytes, and what does not

The phrase “26 bytes” refers to thirteen trainable values stored in bfloat16 precision. It is an accurate description of the size of those values. It is not the total memory needed to run the model, perform the training procedure, or represent every fixed component involved in TinyLoRA's parameterization.

The pretrained weights remain in place. TinyLoRA also relies on SVD-derived directions and fixed random projections that define how the small vector affects many large matrices. Reinforcement learning requires repeated generations, reward computation, and optimization. A tiny trainable state therefore does not imply tiny training compute or a 26-byte deployable reasoning system.

This matters for practical claims. The paper establishes an unusually small trainable parameter budget. It does not provide a complete systems-level demonstration that the same gain can be deployed or trained at negligible cost. The possible benefits for adapter storage, communication, and serving are interesting, but they need to be measured in an actual deployment stack.

There is also a conceptual caveat: the result does not demonstrate that reasoning is learned from scratch in thirteen numbers. The frozen model is already a strong instruction-tuned model. The small update may select, amplify, or reorganize behaviors made possible by pretraining. The paper itself raises this interpretation, including the possibility that changes to response style or reasoning length account for part of the gain.

The larger the model, the smaller the steering signal?

One of the study's most suggestive observations is that extremely small updates become more effective as the pretrained backbone grows. The authors report that larger Qwen2.5 models need fewer trainable parameters to approach their best fine-tuned performance, while smaller models benefit less from the same restricted update budgets.

The effect is also model-dependent. Qwen responds more favorably than the tested Llama models in the tiny-parameter regime. The authors note that differences in pretraining or architecture may help explain this, and even raise the possibility that exposure to similar examples during pretraining affects Qwen's strong results. This makes it difficult to attribute the entire effect to the adaptation method alone.

A natural interpretation is that model scale changes the role of fine-tuning. For a sufficiently capable backbone, adaptation may become less about adding competence and more about finding compact controls over competence that already exists. Yet this remains an interpretation rather than a proven scaling law for arbitrary models and tasks.

The evaluation is confined to mathematical reasoning benchmarks. Whether the same mechanism works for code generation, scientific problem-solving, tool use, multilingual tasks, or open-ended writing remains unanswered. In those domains, reliable evaluation will also require looking beyond final-answer accuracy to robustness, generalization, and the nature of the generated reasoning.

A different way to think about fine-tuning

TinyLoRA does not make large-model training free, nor does it reduce reasoning to thirteen independent facts. Its contribution is more precise: with a strong frozen model, a carefully structured adaptation space, and reinforcement learning, meaningful improvements can be obtained while optimizing astonishingly few numbers.

The deeper question is what these updates actually change. Are they modifying reasoning strategies, encouraging the model to spend more computation on difficult questions, or revealing capabilities that pretraining had already placed within reach? Distinguishing these possibilities will matter more than pushing the parameter count from thirteen down to one.

For research on efficient adaptation, the paper offers an important shift in perspective. The number of parameters we need to train may be far smaller than the amount of capability we want to activate.

Read more