Axion 1.0: How ByteDance Built a Fully Open Agent Foundation Model with Just 18K Training Examples

Building capable AI agents has historically required elaborate training pipelines — mid-training phases, direct preference optimization, on-policy distillation, and mountains of proprietary data. Axion 1.0, released on November 2, 2026 by a team from ByteDance, Duke University, the University of Maryland, and the University at Buffalo, challenges that assumption. It achieves competitive performance on hard scientific reasoning and tool-use benchmarks using a three-stage recipe, 18,363 training trajectories, and roughly 1,000 GPU-hours for the 122B variant — and releases everything under Apache 2.0.

The Axion 1.0 paper and project page make the case that data quality and task construction matter more than pipeline complexity. Here is what that looks like in practice.

The Three-Stage Training Recipe

Axion 1.0 deliberately avoids techniques that have become standard in agent training: no dedicated mid-training, no DPO, no on-policy distillation. Instead, it uses two supervised fine-tuning stages followed by reinforcement learning.

Stage I — Learn to Reason (SFT): The model starts with self-contained scientific reasoning, meaning tasks that require no external tools. The team uses model-aware data construction: seed problems are synthesized from public sources, then adversarially strengthened based on the base model's own successful solution strategies. Operations like composition, parameterization, and range shifts generate 10,819 trajectories that are genuinely hard for the model at the time of training.

Stage II — Learn to Investigate (SFT): The second stage introduces tool-dependent reasoning. Tasks are grounded in real-world databases — NASA Exoplanet Archive, OpenAlex, UniProt — and reference answers are determined programmatically before the LLM formulates the question. This ensures verifiability without human annotation. The stage adds 7,544 trajectories (approximately 312M tokens), teaching the model to recover missing information through external retrieval.

Stage III — Learn Through Interaction (RL): The final stage uses asynchronous Group Relative Policy Optimization (GRPO) over long-horizon agent trajectories. Rollout workers interact with tools and environments concurrently with policy updates in the trainer pool, avoiding the idle time that synchronous RL creates. Session-level training handles the long interaction histories that agentic tasks produce.

Architecture and Infrastructure

Axion 1.0 is available in two sizes: 35B and 122B parameters, both using a Mixture of Experts (MoE) architecture with a 128K context window during SFT. The training infrastructure is built for reproducibility:

• FSDP + expert parallelism + context parallelism for SFT runs at 128K context
• Token-In-Token-Out (TITO) to preserve token IDs across the pipeline, preventing subtle mismatches between rollout and training
• Rollout Routing Replay (R3) to align MoE expert choices between the rollout phase and the training phase — a non-obvious consistency requirement for MoE agents
• swift for SFT and verl for RL, providing a unified, documented pipeline

The R3 mechanism is worth noting. In a standard MoE setup, the expert routing during rollout (when the model generates trajectories) can differ from routing during the training forward pass, because the two happen in different contexts. R3 replays the routing decisions from rollout into training, ensuring the gradient updates land on the same experts that produced the behavior being reinforced.

Benchmark Results

Axion 1.0 was evaluated on six benchmarks spanning scientific reasoning, information seeking, and biological data analysis: Humanity's Last Exam (HLE), BioMysteryBench (BMB), SEAL-0, HiPhO, and the Olympiad and Research splits of FrontierScience.

Model	HLE	BMB	SEAL-0	HiPhO	FS Olympiad	FS Research
Agents-A1	47.6	—	56.4	46.4	79.0	40.0
Gemini 3.1 Pro	51.4	35.3*	53.2*	38.5*	85.0*	26.7*
Axion 1.0-35B	52.2	35.3	62.2	45.7	86.0	56.7
Axion 1.0-122B	59.0	41.7	58.6	46.2	87.0	66.7

*Evaluated by the Axion team.

The 122B model scores 59.0 on HLE and 66.7 on FrontierScience Research — the latter being a particularly demanding benchmark that requires synthesizing information across multiple scientific papers. The 35B model holds its own against Gemini 3.1 Pro on most tasks despite being a fraction of the cost to run.

What Makes the Data Construction Interesting

The model-aware approach in Stage I is the most technically distinctive part of the recipe. Rather than curating a static dataset, the team generates problems, runs the base model on them, identifies which solution strategies succeed, and then constructs harder variants that stress-test those same strategies. This creates a feedback loop between the model's current capabilities and the difficulty of its training data — without requiring human labelers to judge what "hard" means.

Stage II's grounding in real databases is equally deliberate. By anchoring tasks to sources like UniProt and OpenAlex, the team ensures that the model learns to retrieve and reason over evidence that actually exists, rather than hallucinating plausible-sounding citations. The programmatic answer generation also means every training example has a verifiable ground truth, which is what makes GRPO's reward signal reliable in Stage III.

What Is Released

The GitHub repository contains the full training code: data construction, filtering, SFT, asynchronous RL, and the evaluation harness. The training dataset on Hugging Face provides both SFT splits and the RL tasks. The 35B reproduction checkpoint is publicly available under Apache 2.0. The 122B weights are also released, making this one of the more complete open releases for a model at this performance tier.

Practitioner Implications

For teams building domain-specific agents, Axion 1.0 offers a few concrete takeaways. First, the three-stage recipe is modular: Stage I can be replaced with domain-specific reasoning data, and Stage II can be grounded in proprietary databases rather than public ones. The infrastructure (TITO, R3, asynchronous GRPO) is reusable. Second, the 18K trajectory count is small enough that fine-tuning on top of the released checkpoints is tractable for teams without large compute budgets. Third, the emphasis on verifiable tasks — where the answer can be checked programmatically — points toward a general principle: RL for agents works best when you can define a reward without human judges in the loop.

The broader trend here is that agent training is becoming more systematic. The gap between "we trained an agent" and "here is the exact recipe, data, and code to reproduce it" is closing, and Axion 1.0 is a clear example of what that looks like when done carefully.