Multi-domain thinking verifiers trained via Reinforcement Learning with Verifiable Rewards (RLVR) are a cornerstone of modern post-training. However, their adoption in code generation has lagged behind that of execution feedback due to the prohibitive costs of the full RLVR pipeline. In this work, we ablate three primary choices along the performance-cost trade-off in RLVR: intermediate thinking traces, learning from negative samples, and on-policy training. We introduce Aletheia, a controlled, execution-grounded testbed to facilitate a contamination-free analysis of code verifier training recipes across disparate model sizes and covariate shifts across two common verifier application scenarios. Our analysis reveals that the optimal training recipe is scale-dependent: on-policy learning is the primary performance driver for small verifiers, whereas the thinking budget becomes the most vital factor at larger scales. While leveraging negative samples has a consistent impact on top-1 selection accuracy across sizes, their contribution to ranking reconstruction increases monotonically with scale and plays a key role in stabilizing training at large sizes. Our Pareto optimality analysis demonstrates that eliminating on-policy training at larger model scales yields a verifier that performs comparably to the full RLVR recipe. Furthermore, we find that eschewing thinking traces serves as a compute-efficient strategy at lower budgets, offering a strong trade-off between training cost and verifier accuracy. Ultimately, our work provides the empirical foundation necessary to efficiently deploy robust code verifiers, thereby enabling their wider adoption in post-training pipelines for large code generation models.

🤖 This Model

RAFT-14B is a RAFT verifier: trained with on-policy rejection sampling fine-tuning, learning only from positive reasoning samples (no negatives). It is fine-tuned from deepseek-ai/DeepSeek-R1-Distill-Qwen-14B (14B scale) on INSAIT-Institute/Aletheia-Train.

Given a competitive-programming problem and a set of candidate solutions, the verifier judges and ranks the candidates. See the GitHub repository for the exact prompt format, plus training and evaluation scripts.

📦 Model Zoo

Fine-tuned code verifiers at 1.5B, 7B, and 14B scales using several algorithms:

Algorithm	Thinking	Negatives	Online	Description
GRPO-Think	✅	✅	✅	Standard GRPO-style approach to training verifiers.
GRPO-Instruct	❌	✅	✅	RLVR training without intermediate thinking traces.
RAFT	✅	❌	✅	On-policy rejection sampling fine-tuning using only positive reasoning samples.
DPO-Think	✅	✅	❌	Offline preference optimization using pre-collected thinking traces.
BatchOnline-GRPO	✅	✅	⚠️	Semi-online training where the generator policy is synced every 4 steps.

The -4k / -8k / -16k suffix on GRPO-Think checkpoints denotes the reasoning-token budget (maximum completion length) used during training.

🎁 Datasets

The Aletheia dataset collection includes:

Aletheia-Train: 50,000 training instances, each pairing a competitive-programming problem with 2–5 candidate solutions — exactly one of which is correct (execution-verified) — generated by a pool of weak and strong policy models across Python, C++, and Java.
Aletheia-Train-Questions: The 3,574 unique problem statements underlying Aletheia-Train, useful for on-policy sampling.
Aletheia-DPO: A companion dataset to Aletheia-Train containing "chosen" and "rejected" verification responses for each instance. The chosen response identifies the correct code snippet, while the rejected response does not.
Aletheia-Mixed: A variant of Aletheia-Train in which ~25% of instances carry adversarial modifications that exploit common LLM biases (authority references, self-declared correctness, misleading comments, etc.).
Aletheia-Mixed-DPO: The DPO-style companion to Aletheia-Mixed.
Aletheia-Heldout: A completely in-distribution test set.
Aletheia-Strong: An OOD test set where the candidates are generated by stronger models.
Aletheia-Hard: An OOD test set where the comparison between candidates is more difficult.
Aletheia-Adv: An OOD test set where the candidates are adversarially modified to exploit common LLM biases.

💡 Intended Uses

RLHF / RLAIF: plug-and-play reward function for code generation policy optimization.
Automated evaluation: LLM-as-a-judge for a variety of code-related tasks.
Research: study the effects of thinking traces, on-policy learning, and negative samples in training successful code verifiers.

📚 Citation

If you find this work useful, please cite our paper:

bibtex

@misc{venkatkrishna2026aletheiamakesrlvrcode,
      title={Aletheia: What Makes RLVR For Code Verifiers Tick?},
      author={Vatsal Venkatkrishna and Indraneil Paul and Iryna Gurevych},
      year={2026},
      eprint={2601.12186},
      archivePrefix={arXiv},
      primaryClass={cs.SE},
      url={https://arxiv.org/abs/2601.12186},
}

📄 License

This work is licensed under CC BY-NC-SA 4.0.

INSAIT-Institute/RAFT-14B

Aletheia: What Makes RLVR For Code Verifiers Tick?