Mitigating Legibility Tax with Decoupled Prover-Verifier Games

The Legibility Tax: A New Bottleneck in AI Verification

A recent paper on arXiv (2602.23248v2) tackles a subtle but critical problem in AI safety: the "legibility tax" that emerges when using prover-verifier games to make large language model outputs more checkable. The research identifies a degradation in performance when models are trained to produce outputs that are easily verifiable by weaker systems—a trade-off that has significant implications for how we deploy increasingly capable AI.

What the Research Reveals

Prover-verifier games work by pitting two models against each other: a "prover" generates outputs, while a "verifier" checks them. The prover is incentivized to produce outputs the verifier can validate, theoretically improving legibility. However, this paper documents a degradation effect—the legibility tax—where the prover's performance drops as it optimizes for verifiability. This isn't a simple accuracy trade-off; it's a structural limitation where the very act of making outputs checkable reduces their utility.

The mechanism appears to be that the prover learns to constrain its outputs to patterns the verifier can parse, which may exclude valid but complex reasoning paths. This creates a tension: the most capable models often produce outputs that are hardest to verify, and forcing verifiability may strip away the sophistication that makes them valuable.

Why This Matters

This finding is particularly relevant as organizations rush to deploy LLMs in high-stakes domains like healthcare, legal analysis, and financial services. The assumption has been that we can always add verification layers after the fact. This research suggests that verification and capability may be fundamentally at odds—at least with current game-theoretic approaches.

The legibility tax also has implications for oversight architectures. If we rely on weaker models to check stronger ones (a common safety strategy), we may inadvertently create a ceiling on the stronger model's performance. This challenges the scalability of current alignment techniques and suggests that verification systems must evolve in tandem with the models they monitor.

Implications for AI Practitioners

For teams building production systems, this research underscores that verifiability should be a first-class design constraint, not an afterthought. Practitioners should:

• Measure the legibility tax explicitly in their own systems by comparing verifiable vs. unconstrained model outputs across key metrics.
• Consider multi-verifier architectures where different verifiers handle different complexity levels, potentially reducing the tax by distributing the verification burden.
• Explore adaptive verification where the verifier's capability scales with the prover's output complexity, rather than using a fixed weaker model.
• Rethink deployment thresholds—if a 5% legibility tax is acceptable for your use case, that's a concrete design parameter; if not, you may need alternative verification strategies.

The paper doesn't claim to solve the legibility tax, but it does something equally valuable: it names and measures the problem. For an industry racing to deploy ever-more-capable models, understanding where verification breaks down is the first step toward building systems that are both powerful and trustworthy.

Key Takeaways

• Prover-verifier games suffer from a "legibility tax" where optimizing for verifiability degrades model output quality, creating a fundamental trade-off between capability and checkability.
• This degradation is structural, not merely a tuning issue—it reflects the difficulty of aligning complex reasoning with simpler verification systems.
• AI practitioners should measure this tax explicitly in their own deployments and consider multi-verifier or adaptive verification approaches to mitigate it.
• The finding challenges the scalability of current alignment techniques that rely on weaker models to supervise stronger ones, highlighting the need for verification systems that keep pace with model capability.