ScaleLogic ties compute to reasoning depth

Reinforcement learning for language models has had a weird problem. Everyone can see that extra training sometimes makes models “think” better, but it has been hard to measure what exactly got harder — more steps, more branching, or just messier data. ScaleLogic is interesting because it tries to isolate that. The paper landed on arXiv on May 7, 2026, and its claim is pretty crisp: the compute needed for RL grows like a power law with reasoning depth, and that curve gets steeper as the logic itself gets richer. ### What is ScaleLogic, exactly? It is a synthetic reasoning environment. Instead of training on messy math or coding corpora, the authors generate logic problems where they can directly control two knobs — how many proof steps the model needs, and how expressive the logic is. That expressiveness ranges from simple implication rules up through conjunction, disjunction, negation, and universal quantification. The point is control, not realism. (arxiv.org) ### Why does that matter? Because most “reasoning” benchmarks bundle too many things together. A hard math problem can be hard because it needs ten steps, because it hides the right theorem, or because the wording is nasty. ScaleLogic strips that down to something more like a wind tunnel for RL. If you want to know whether longer-horizon reasoning is actually learnable, you need a setup where horizon is an explicit variable. (arxiv.org) ### What did the paper actually find? The headline result is a scaling law. Training compute \(T\) rises with reasoning depth \(D\) as \(T \propto D^\gamma\), with reported fits above 0.99 \(R^2\). That is the clean part. The more important part is that \(\gamma\) is not fixed. It rises monotonically with logical expressiveness — from 1.04 in simpler settings to 2.60 in richer ones. Basically, deeper reasoning costs more, but deeper reasoning in a richer world costs much more. (arxiv.org) ### So is this just “more compute helps”? Not really. The sharper claim is that *what* you train on changes the payoff curve. More expressive training settings transferred better to downstream math and general reasoning tasks, with gains up to 10.66 points, and they did so more compute-efficiently than less expressive setups. That is a useful correction to the lazy version of scaling talk. It is not only about piling on tokens or GPU hours — task structure matters. (arxiv.org) ### Why does expressiveness change the exponent? A good way to think about it is branching. A shallow chain of “if A then B” feels like following one hallway. Add “and,” “or,” “not,” and “for all,” and now the model is navigating a building with side rooms, dead ends, and global constraints. The number of plausible intermediate paths grows, so RL has a harder search problem. The paper’s contribution is turning that intuition into a measurable curve. (arxiv.org) ### Does this connect to real agent training? Indirectly, yes. The same week-to-month wave of open RL work includes OpenClaw-RL, a framework for asynchronous agent training in terminal, GUI, software-engineering, and tool-call settings. That project is about deployment and training infrastructure, not synthetic logic scaling, but the connection is obvious: if you know how training cost grows with horizon and branching, you get a better prior for where real-world agent RL will break first. (arxiv.org) ### What is the catch? ScaleLogic is synthetic by design. That is its strength and its limit. Real reasoning tasks have retrieval, ambiguity, world knowledge, and reward noise. So you should read this less as “we solved reasoning” and more as “we finally have a ruler.” A ruler is still a big deal if the field has mostly been eyeballing progress. ### Bottom line? This paper gives RL-for-reasoning work a cleaner map. (github.com) Longer reasoning looks scalable, but the bill rises as logic gets richer. Frontier labs were already acting as if that might be true. ScaleLogic is an early attempt to put the shape of that tradeoff in math. (arxiv.org)