What separates verifiable reasoning from open-ended judgment in scaling requirements?
This explores why reasoning with checkable answers (math, code) scales cheaply and reliably, while open-ended reasoning — judgment calls with no clean right answer — resists the same scaling tricks, and what the corpus says actually causes the gap.
This explores why reasoning with checkable answers (math, code) scales cheaply and reliably, while open-ended judgment resists the same tricks. The corpus's sharpest claim is that the dividing line isn't model size at all — it's whether a task has a ground truth a verifier can check. A 3B model reaches frontier math and coding scores not through scale but through a post-training pipeline of curriculum SFT and reinforcement learning, and the authors explicitly bound that result to verifiable tasks where RL gets a clean reward signal Can small models match frontier reasoning without massive scale?. Where the answer is checkable, you can manufacture as much training signal as you want; where it isn't, the cheap signal disappears.
So what's the actual bottleneck for open-ended reasoning? The corpus points at question diversity, not method. Reasoning transfers into messy domains — economics, social science — when models train on millions of diverse, difficult questions rather than on cleverer algorithms What limits reasoning capability beyond math and code?. That reframes the scaling requirement: verifiable reasoning scales on compute and reward, open-ended reasoning scales on curated breadth of hard problems, which is far more expensive to produce.
The interesting move in the corpus is shifting verification from the answer to the process — which is how open-ended work claws back some of the rigor that checkable tasks get for free. When there's no final answer to grade, you grade the intermediate steps: checking states and policy compliance mid-trace raised task success from 32% to 87%, because most failures were process violations, not wrong conclusions Where do reasoning agents actually fail during long traces?. Verifiers can even run asynchronously alongside generation at near-zero latency cost Can verifiers monitor reasoning without slowing generation down?, and structured argument prompts force a model to expose the warrants it would otherwise skip Can structured argument prompts make LLM reasoning more rigorous?. These are all attempts to build a verifier where the domain doesn't hand you one.
A second thread complicates the whole premise: some apparent reasoning ceilings aren't reasoning failures at all. Models that 'fail' at long procedures often know the algorithm but can't execute it in text — give them tools and they clear the supposed cliff Are reasoning model collapses really failures of reasoning?. Extended chain-of-thought produces more text, not more iterative computation, so it doesn't help on numerical optimization Do reasoning models actually beat standard models on optimization?. And on constraint-satisfaction problems requiring genuine backtracking, frontier models stall at 20-23% Can reasoning models actually sustain long-chain reflection? — sometimes because they abandon good paths prematurely rather than lacking the compute to finish Why do reasoning models abandon promising solution paths?. The takeaway worth carrying away: 'scaling requirements' is really three different questions wearing one coat — do you have a verifiable signal, can the model execute the procedure, and is the search organized — and verifiable-vs-open-ended only cleanly answers the first.
Where a checkable signal is truly absent, the corpus offers a substitute: the Darwin Gödel Machine drops formal proofs entirely and self-improves through empirical benchmarking and an evolutionary archive Can AI systems improve themselves through trial and error? — trading the clean reward of verifiable tasks for messy real-world feedback, which is precisely the scaling trade open-ended judgment forces on you.
Sources 10 notes
A 3B model trained with curriculum SFT and multi-domain RL reaches 94.3 AIME26 and 80.2 LiveCodeBench scores matching much larger systems. The result is bounded to verifiable tasks with checkable ground truth, where RL can provide clean reward signals.
Reasoning scales in open-ended domains when trained on diverse, difficult questions rather than better algorithms. NaturalReasoning's 2.8M curated questions show distillation and self-training transfer reasoning capability across STEM, economics, and social sciences.
Reliability for long-trace reasoning comes from checking intermediate states and policy compliance during generation, not from scoring final outputs. Adding intermediate verification raised task success from 32% to 87% because most failures are process violations, not wrong answers.
Decoupling verification from generation lets verifiers run alongside a single trace, forking to extract verifiable state and intervening only on violations. On correct runs the latency penalty is near-zero; interwhen matches or beats CoT across benchmarks at similar token budgets.
Applying Toulmin's argument model as explicit prompting steps (CQoT) improves LLM reasoning by forcing models to identify warrants and backing rather than skipping implicit premises. The method catches failures that standard chain-of-thought prompting allows.
Models confined to text-only generation cannot execute multi-step procedures at scale, even when they know the underlying algorithm. Tool-enabled models solve problems beyond the supposed reasoning cliff, suggesting the bottleneck is procedural execution bandwidth.
Reasoning variants with extended CoT show no consistent advantage over standard models on constraint-bound numerical tasks like optimal power flow. Extended thinking produces more text, not more iterative computation, suggesting the bottleneck is numeric procedure rather than reasoning steps.
DeepSeek-R1 and o1-preview achieve only 20-23.6% exact match on 850 constraint satisfaction problems requiring genuine backtracking. This ceiling reveals that reflective reasoning fluency does not translate to actual problem-solving competence on unfamiliar instance structures.
Reasoning LLMs exhibit two reinforcing failures: wandering (invalid exploration) and underthinking (premature path-switching). Decoding-level interventions like thought-switching penalties improve accuracy without fine-tuning, suggesting viable solutions exist but are abandoned prematurely.
DGM replaces formal proofs with empirical benchmarking and maintains an evolutionary archive of agent variants, achieving 2.5× improvement on SWE-bench and 2.2× on Polyglot by discovering capabilities like better code editing and context management.