CritICL turns weaker models' failures into stronger LLM reasoning

Large language models increasingly rely on inference-time scaling to improve reasoning, typically by generating many candidate answers and picking the best one, or by checking outputs against an external verifier. Both approaches add extra generations and cost to every question asked. A new paper introduces CritICL, an inference-time framework built to raise reasoning performance without paying that price.

The authors' key insight is that when a language model gets something wrong, the mistake is rarely random: failure modes follow structured patterns that recur across different sizes of model within the same family. CritICL treats those failures as a resource rather than noise. It takes the failure patterns shown by a weaker model in the family and turns them into critique-based examples, which are then fed into a larger model's context at inference time so it can be shown what kinds of mistakes to watch for.

CritICL comes in two variants. CritICL-dynamic adaptively predicts which failure mode is likely relevant to a given input and retrieves matching critiques for it. CritICL-static instead relies on one global profile of failure modes decided in advance, applying the same guidance to every input, which the authors say provides more stable guidance.

According to the authors, CritICL consistently outperforms standard in-context learning and achieves performance competitive with, or in some cases better than, dedicated test-time scaling methods that generate and check many outputs, all while requiring significantly fewer generations and lower token cost than those approaches. The abstract does not give exact figures for those savings, nor does it name the specific model family, benchmark, or baseline methods used in testing.

The authors have published their code on GitHub, at github.com/umwyf/CRITICL, alongside the paper.

Key facts

CritICL is an inference-time framework that improves LLM reasoning without the repeated generation or external verification that most existing scaling methods rely on.
Its key insight: failure modes of a weaker model in the same family follow structured patterns, which CritICL turns into critique-based in-context examples for a larger model.
Two variants are proposed: CritICL-dynamic, which predicts input-specific failure modes and retrieves matching critiques, and CritICL-static, which uses one fixed, global failure-mode profile for every input.
The authors report that CritICL consistently outperforms standard in-context learning and matches or exceeds test-time scaling methods, while needing significantly fewer generations and lower token cost than those approaches overall (no exact figures are given).
The code is published on GitHub at github.com/umwyf/CRITICL.

Why it matters

Much of the recent progress in LLM reasoning has come from spending more compute at inference time: generating many candidate answers and picking the best, or checking outputs against an external verifier, both of which add cost and latency to every question. CritICL's contribution is to show that a cheaper source of guidance already sits inside a model family: the specific ways a weaker model in that family tends to fail. By turning those failure patterns into critique-based examples that a larger model sees in its context, the authors report accuracy gains over standard in-context learning and performance that matches or beats test-time scaling methods, all while using far fewer generations and lower token cost than those approaches. That combination, if it holds up under further testing, would matter to anyone running LLM reasoning at scale, where every extra generation pass adds up.

Who it affects

The technique is aimed at researchers and engineers building or deploying LLM reasoning systems who want some of the accuracy gains of heavier generate-and-verify approaches without paying for extra generations on every request. It presupposes access to a weaker model from the same family whose failures can be mined for critiques, so it applies most directly to teams that already have such a model on hand. The abstract does not name any specific company, product, or model family the method has been tested on, so it reads as a general research technique rather than an announcement tied to one lab's models.

How to use it

The authors have released code on GitHub at github.com/umwyf/CRITICL, alongside the paper. CritICL operates purely through critique-based in-context examples supplied to the larger model at inference time, rather than through retraining. The two variants offer a choice between adaptivity and predictability: CritICL-dynamic retrieves failure-mode critiques tailored to each input, while CritICL-static applies one fixed set of critiques to every input for more predictable behavior. The abstract states no price, license, or specific model family the method has been validated against, so applying it to a given production system would require testing it directly.

How solid is it

The claims rest on the authors' own reported experiments: CritICL is said to consistently outperform standard in-context learning and to be competitive with, or better than, test-time scaling methods, while using significantly fewer generations and lower token cost than those approaches overall. However, the abstract does not name the model family, benchmark, or dataset used to produce these results, nor the specific in-context-learning or test-time-scaling baselines compared against, and it gives no percentages, ratios, or counts for the claimed savings in generations or token cost. That level of detail would typically appear in the paper's full body rather than its abstract, but going only on what is available here, the result should be read as a promising, code-backed claim rather than an independently verified one.

Risks and caveats

The abstract does not discuss limitations, failure cases, or the compute and runtime cost of building the failure-mode profiles in the first place, so there is no way from the available text to judge how CritICL performs outside the conditions the authors tested, or whether it generalizes to model families and tasks beyond those in the paper. The approach also depends on having access to a weaker model from the same family to mine for failure modes, which will not be available in every setting. As with any single paper's self-reported results, independent replication would be needed before treating the reported efficiency and accuracy gains as settled.