Absolute Zero is a zero-artificial data inference model training paradigm proposed by Tsinghua University and other institutions. The core idea is to use a language model as both a proposer and a solver, providing verifiable reward signals through the code executor, and continuously improving code and mathematical reasoning capabilities without the need for manual annotation.

Full review of Absolute Zero

Core parameters and statistics

Project	Specifications
Product Positioning	Zero-data inference model training paradigm
Development Agency	Tsinghua University LeapLab, BIGAI, Pennsylvania State University
Open Source License	MIT License
Technical Route	Reinforcement Learning Self-Game + Code Executor Verification
Model size	3B / 7B / 14B (public checkpoint provided)
Training Resources	3B ≈ 2×80GB GPU; 7B ≈ 4×80GB GPU; 14B ≈ 8×80GB GPU
Inference Mode	Deduction, Abduction, Induction
Paper address	arxiv.org/abs/2505.03335

You may ask: Is Absolute Zero a product? No, it is more like a "let the model teach itself" training method. It's like a student writing out his own test papers, answering the questions, correcting them by himself, and then learning from his mistakes - the whole process does not require the participation of a teacher (human annotator).

User and market recognition

Absolute Zero was publicly released through an arXiv paper in May 2025, and the complete implementation was open sourced on GitHub and Hugging Face during the same period. Although it is not a SaaS product for the general public, it has attracted attention in the research community because it answers a fundamental question in the field of LLM: How can models improve when they run out of human-labeled data? **

• Academic influence: The "zero data reasoning" paradigm proposed in the paper directly challenges the traditional route of RLHF relying on artificial preferences, and provides a new practical path for RLVR (reinforcement learning with verifiable rewards).
• Community Activity: The GitHub repository is highly complete (including training code, evaluations, model weight conversion tools, and W&B logs), and researchers can directly reproduce the results of the paper. The specific number of Stars is subject to real-time data from the warehouse.
• Industry Benchmarking: Complementary with DeepSeek-R1's reinforcement learning reasoning training and OpenAI o1's chain reasoning idea - but Absolute Zero is more radical in insisting on "zero artificial data".

Cost advantage

Billing dimensions	Current status
Framework and Code	MIT open source and free
Model checkpoint	Hugging Face public download
API Service	Not provided
Enterprise Technical Support	Undisclosed

The Free Truth: The code and models are free, but training requires a real GPU. The official reference configurations—about 2 A100-80GB for the 3B model and 8 for the 14B model—mean that the cloud GPU cost for a typical experiment ranges from thousands to tens of thousands of dollars. The "free" thing is the software, the expensive thing is the computing power.

Cost stratification

• C-side/individual researchers: You can use the officially provided 3B checkpoint for inference and fine-tuning experiments. 8 A100-80GB costs about US$16-24/hour. If you only need to do inference rather than retraining, a single card with 24GB of video memory can run a 3B model.
• Developer/API: No public API, you need to build your own inference service.
• Enterprise/Institution: If you need to reproduce the training process on internal data, you need to prepare your own GPU cluster. The MIT license allows commercial use, but the README clearly states that the Python executor is limited to research use, and production security needs to be reinforced by yourself.

Hidden benefits: For teams researching inference training methods, Absolute Zero provides a highly engineered baseline - complete training/evaluation code, self-game context and log system, allowing the team to run through an end-to-end zero-data inference training experiment in a few days, while it takes about several months to build the same workload from scratch.

Publicity verification: The paper claims "zero artificial data" - "zero data" here refers to question and answer pairs that do not rely on manual annotation, but the model still requires massive pre-training corpus and code execution context as prior knowledge. "Zero data" does not equal "zero cost". It is necessary to distinguish the dependencies between the training phase and the pre-training phase.

Main functions

• Autonomous task generation (Proposer): The model generates "learnable" programming or mathematics tasks by itself, rather than relying on manual screening of question banks. The difficulty of tasks dynamically adjusts with learning progress - from simple single-line operations in Python to complex multi-step algorithm problems.
• Task Autonomous Solver (Solver): The model solves the tasks it proposes and verifies the correctness of the answers through the Python executor. "Problem setting" and "problem solving" are completed by different reasoning modes of the same model, and shared parameters are jointly optimized.
• Triple Reasoning Mode: Supports deductive reasoning (deriving conclusions from rules), abductive reasoning (inferring causes from observations), and inductive reasoning (summarizing rules from examples). The three modes cover the core types of human reasoning, making the model more than just "calculating fast".
• Zero data training process: Does not rely on any manually labeled data or predefined question and answer pairs. The model obtains verifiable reward signals through contextual interaction with code execution, and continues to improve during the self-game cycle.

Model and version evolution

Mainline release

• ~2025-05: First public release of Absolute Zero Reasoner. The arXiv paper (2505.03335) explains the theory of the zero-data inference paradigm. GitHub synchronizes open source the complete code repository including training and evaluation checkpoints.

The project is in the early research stage and has not yet formed a multi-version iteration system. Subsequent evolution may include: more secure code executors, support for more task types (such as scientific reasoning, logical reasoning), and training experiments for larger-scale models.

Technical advantages

Mechanism analysis: How does the model teach itself?

Absolute Zero's core technology link consists of four roles:

┌────────────────────────────────────────────────────────┐
│ Proposer (question maker) ←→ Solver (problem solver) │
│ ↓ ↓ │
│ Generate task description, generate problem-solving process and answers │
│ ↓ ↓ │
│ ┌──────────────── Code Executor ──────────────────┐ │
│ │ ① Verify whether the task is executable and non-trivial │ │
│ │ ② Execute the problem-solving code and verify whether the output is correct │ │
│ │ ③ Return verifiable reward signal (learnability reward + correctness reward) │ │
│ └─────────────────────────────────────────────────┘ │
│ ↓ │
│ TRR++ optimizer → jointly update Proposer and Solver parameters │
└───────────────────────────────────────────────────────┘

1. Verifiable rewards replace artificial preferences: Traditional RLHF relies on human annotators to rank model output preferences, while Absolute Zero uses pass/fail of code executors as objective rewards. The effect is to remove the subjectivity and inconsistency of human preferences, making the training signal cleaner and more scalable. Suitable for areas where rules can be verified by programs (code, mathematics).

2. Self-game course learning: Proposer automatically generates "optimal difficulty" tasks near the current ability boundary - questions that are too easy will not be rewarded (because they have no learning value), and questions that are too difficult will not be solved and will not be rewarded. The effect is that the training process automatically forms a Curriculum Learning curve, and the model is always trained at the "edge of the comfort zone". Suitable for inference models that require large amounts of diversity for training.

3. TRR++ joint optimization: Improved on the basis of traditional GRPO/PPO, while optimizing Proposer's task generation strategy and Solver's problem-solving strategy. The effect is that the two characters make progress together in the confrontation - the question maker becomes more and more "cunning", and the problem solver becomes more and more "strong", forming a positive feedback spiral.

4. Emergent reasoning behavior: In the official display, after training, the model spontaneously showed high-order reasoning behaviors such as annotation planning (write the annotation planning steps first and then write the code), trial and error backtracking (reverting to retry when encountering an error), self-verification (automatic checking after solving the problem), and these behaviors were not explicitly demonstrated in the training data.

How to use

Absolute Zero is aimed at researchers. The entrance is GitHub repository and command line tools. There is no graphical interface.

Reproduce the results of the paper:

git clone https://github.com/LeapLabTHU/Absolute-Zero-Reasoner
cd Absolute-Zero-Reasoner
# Configure Conda context according to README
conda env create -f environment.yaml
conda activate absolute-zero

# Download pre-training checkpoint
# Refer to the Hugging Face collection: https://huggingface.co/collections/andrewzh/absolute-zero-reasoner

#Run inference evaluation
python eval.py --model absolute-zero-3b --benchmark code

# Start self-game training (requires ≥4×80GB GPU)
python train_selfplay.py --model base-3b --output ./experiment

Since it is a research framework, users need to have basic knowledge of GPU cluster management, Python development and reinforcement learning. The actuators provided by the project are not suitable for production environments. If you need to safely execute user code, you need to strengthen it yourself.

Product Pricing

Project	Description
Software License	MIT License, free and open source
Training Hardware	Minimum 2×A100-80GB (3B model experiment)
Inference Hardware	A single card with 24GB of video memory can run 3B checkpoint
Cloud GPU Cost	About $1,500-8,000 for complete reproduction experiment
Business API	Not available

Application scenarios

• Inference Model Research: Research teams can use Absolute Zero as a baseline framework for zero-data inference training. Compared with implementing a self-game training system from scratch, a complete pipeline based on Absolute Zero can shorten the experiment startup time from months to days - just fork the warehouse, configure the context, and adjust the hyperparameters.
• Model Capability Boundary Exploration: Study "how far a model can go without human data input" and evaluate the conditions and limitations for the emergence of reasoning capabilities. It is suitable for research experiments on AI safety, capability boundaries, and emergent behavior directions.
• Reinforcement Learning Training Method Experiment: Test the impact of different reward designs, self-game strategies, and reasoning mode combinations on the model's reasoning ability. The modular design of the project (replaceable actuators, reward functions, inference strategies) facilitates experimental variations.

Not suitable for boundaries: Not suitable as a production-bound code execution sandbox (the built-in executor is marked for research use); not suitable for direct use by individual developers without GPU resources; not suitable for business scenarios that require out-of-the-box inference services.

Applicable people

• LLM training researchers: Researchers who focus on reinforcement learning and reasoning ability self-play can use Absolute Zero as an experimental base and paper baseline.
• Frontier Model Team Engineer: A technical team that tries the zero-data inference training method based on existing models to evaluate whether the method is suitable for its own model scale and task scenarios.
• AI Security and Alignment Researcher: Research whether the behavior of the model is controllable under the "self-teaching and self-learning" paradigm, whether the rewards are hacked, and the predictability of emergent behaviors.

Not suitable for people: Product managers or business users with non-technical backgrounds (programming and ML engineering experience required); individual developers who lack GPU cluster budget; engineering teams who need production-grade inference APIs.

Summary and Outlook

Absolute Zero represents a completely different technical route from mainstream RLHF: replacing human feedback with contextual feedback. It proves that in the field of code and mathematical reasoning, models can continue to improve through the process of "self-generating, self-solving, and self-verification" without the need for a steady stream of manual annotations. As a research prototype, the current version is outstanding in terms of the completeness of the training tool chain, but there is still an engineering gap between laboratory methodology and implementable training framework.

Current limitations: The training resource threshold is high (14B model requires 8 cards of A100); the built-in code executor is marked for research use and is not safe for production; the project is in an early stage, and community support and documentation need to be improved; the effect of reasoning capabilities in areas other than code/mathematics (common sense reasoning, open domain question answering) has not been fully verified.

Acquisition/Adoption Risk Assessment: As an academic open source project, Absolute Zero has no commercialization commitments. It is recommended that the research team use it as a technical reference and experimental baseline; the selection of an industrial-grade training platform needs to evaluate the compatibility with the internal MLOps system, the cost of actuator safety reinforcement, and the human investment in long-term maintenance. The MIT license is compatible with commercial use, but it is recommended to confirm the compliance terms of derived models before training your own model.

Related tools: hugging-face, replicate

Version Info

• Absolute Zero Reasoner ：The first public complete implementation, including training code, model checkpoint, reasoning mode (deduction/abduction/induction) and evaluation script, no official precise date yet. （~2025-05）
• Absolute Zero Reasoner ：The complete implementation is disclosed for the first time, including training code, model checkpoint, inference mode and evaluation script. There is no official precise date yet. （~2025-05）