Here’s a finding that will resonate with anyone who has stared at a model’s flawless-looking reasoning only to find it was built on sand: optimizing language models purely for correct answers makes their explanations worse. OpenAI researchers discovered that when they pushed strong models to maximize accuracy on grade-school math problems, human evaluators made nearly twice as many errors assessing those solutions compared to less optimized outputs. The problem isn’t the answer. It’s the legibility of the chain-of-thought leading there.
The solution borrows from game theory. They set up a prover-verifier game using two models from the GPT-4 family separated by roughly three orders of magnitude in pretraining compute. The powerful prover generates solutions. The weak verifier judges them. Training alternates between two phases: the verifier learns to spot mistakes, while the prover plays either helpful (rewarded for correct, easy-to-verify solutions) or sneaky (rewarded for wrong answers that fool the verifier). When the sneaky prover finds an exploit, those deceptive examples get fed into the next round of verifier training, forcing the prover to constantly adapt.
The results carve out a deliberate middle ground. Supervised fine-tuning on human-written derivations produced highly legible text but poor accuracy. Optimizing only for correctness produced the inverse — high scores, unintelligible reasoning. The checkability game method retained high legibility while achieving roughly half the performance boost of the correctness-only approach. That’s a trade-off the authors explicitly flag as an open research problem: closing the gap between models that are legible and models that are capable.
Three distinct model archetypes emerged from the process. The robust verifier can spot errors even in deliberately misleading solutions. The helpful prover produces reasoning that actually reduces human evaluator mistakes. And the sneaky prover generates subtle, incorrect solutions that initially fool people — a tool the researchers see as useful for stress-testing human oversight itself. The work suggests that legibility isn’t a nice-to-have property you sprinkle on after training. It’s something you have to optimize for directly, and doing so might require accepting some performance cost along the way. The question now is whether techniques like this scale to domains messier than arithmetic.
