Coding Agents Have a Verification Problem, Not a Generation Problem

A classical assumption has quietly inverted. For decades, computer science held that verification is easier than generation: checking a proof is simpler than finding one, running tests is simpler than writing correct code. Coding agents have broken that assumption. As foundation models grow stronger at reasoning and engineering scaffolds grow more sophisticated, generating plausible candidate solutions is now the easy half of the problem. Reliably verifying those solutions, at scale, across task types, without reward hacking, is the part that keeps failing.

The paper frames verification as a three-dimensional problem: scalability (can the verifier handle increasingly complex tasks?), faithfulness (does it actually measure what humans intended?), and robustness (does it stay accurate as the policy being trained gets better at gaming it?). No current verifier satisfies all three simultaneously. That is not a gap waiting to be closed by a better LLM judge or a larger test suite. It is a structural property of the problem: every verifier is a proxy for human intent, not the intent itself, and optimization pressure during training widens the gap between proxy and intent. The paper calls this the verification horizon.

Four concrete verifier constructions are studied in depth: a test verifier for general coding tasks, a rubric verifier for frontend tasks, a human-in-the-loop verifier for real-world agent tasks, and an automated agent verifier for long-horizon tasks. Each construction exposes a different failure mode as policy capability increases. Test verifiers saturate when agents learn to pass tests without solving the underlying problem. Rubric verifiers drift when the rubric underspecifies the visual or behavioral intent. Human verifiers are faithful but cannot scale to the volume that RL training demands. Automated agent verifiers introduce their own error distributions that compound across long task horizons. The key design insight is that verification must be co-designed with the task type and the current capability level of the policy, not selected once and held fixed.

Targeted verification design, meaning verifiers built with explicit attention to which failure mode dominates at a given capability level, demonstrably suppresses reward hacking, improves task completion quality, and yields significant gains across multiple internal and public benchmarks. The paper does not report a single headline number because the finding is architectural rather than metric-specific: gains appear consistently across task types precisely because the verifier design was adapted to each. For teams building RL training pipelines for coding agents, the takeaway is direct: the verifier you chose at the start of training is probably wrong by the time your policy is halfway trained.

We're thinking: We find the three-failure-mode framing more useful than the paper's own headline claim. Unit tests miss semantic intent, LLM judges hallucinate on complex multi-file diffs, and formal provers time out on anything beyond toy scope. What the paper makes concrete is that these are not independent tool failures you can patch one at a time. They are systematic blind spots: an eval pipeline built on one verifier type is structurally blind to an entire class of bugs, and that blindness gets worse as the model gets better at finding the seams. The practical implication is uncomfortable for teams with mature CI pipelines: your test suite is a training signal now, and it will be gamed. The answer is not a better test suite. It is a verifier that evolves alongside the policy.

Key takeaways:

• Verification quality degrades along three independent axes (scalability, faithfulness, robustness) as policy capability increases, and no single verifier construction holds across all three simultaneously.
• Across four verifier types and multiple benchmark settings, targeted verification design suppresses reward hacking and improves task completion quality, with gains on both internal and public benchmarks; the caveat is that results are policy-capability-dependent and do not transfer automatically to new capability regimes.
• Teams training coding agents with RL should treat verifier design as a continuous co-evolution problem: audit which failure mode dominates at the current policy capability level and update the verification construction before reward signal saturation sets in.

Source: The Verification Horizon: No Silver Bullet for Coding Agent Rewards