Axion 1.0: A Minimalist Training Recipe for a 35B Open-Source Agent Foundation Model

A noteworthy contender has emerged in the open-source agent model space. Axion 1.0, released by the ByteDance team, is a fully open 35B-parameter agent foundation model whose core claim is straightforward: powerful agentic capabilities don't necessarily require a complex training pipeline. It's officially positioned as an agent foundation model that is "both open and simple," released alongside a paper, code, datasets, and a project homepage.

Three-Stage Training: A Minimalist Route That Cuts the Middle Steps

Axion 1.0's training recipe has just three steps: two lightweight supervised fine-tuning (SFT) stages plus one reinforcement learning stage. The team explicitly states that the entire pipeline contains no dedicated mid-training, no direct preference optimization (DPO), and no online policy distillation (OPD).

This stands in contrast to current mainstream practice. Many models stack multiple rounds of alignment and distillation after pretraining, lengthening the training pipeline and raising the bar for reproduction. Axion 1.0 chooses subtraction, concentrating capability building into two SFT stages and a single RL pass. The implicit judgment: data construction quality matters more than stacking training stages.

First SFT Stage: Letting the Model Write Its Own Questions

The first SFT stage aims to build solid self-contained reasoning ability. Its approach is "model-aware data construction"—first synthesizing challenging problems, then adversarially strengthening these problems based on the base model's own successful solving strategies.

The cleverness here lies in anchoring to the model's own capability boundary: problem difficulty isn't set by feel but generated around the zone where the base model "can solve but with effort," avoiding wasted training signal from problems that are too easy or too hard. Adversarial strengthening then pushes further toward the capability ceiling.

Second SFT Stage: Extending Reasoning to Tool Calling

The second SFT stage extends capability to tool-dependent reasoning scenarios. The team built a scalable data pipeline to construct diverse, automatically verifiable tasks grounded in real data sources and deterministic computation.

"Automatically verifiable" is the key phrase here. If tool-calling tasks rely on human judgment, they can't scale; tasks built on deterministic computation naturally come with verifiable answers, making data scaling and quality filtering possible—and providing a reliable source of reward signals for the subsequent reinforcement learning.

Automatically verifiable tasks and verifiable rewards (RLVR). "Automatically verifiable" means a task's correctness can be determined by a deterministic program—for example, code execution results, mathematical expression evaluation, database query returns, or structured output validation of API calls. Such tasks require no human annotation or model judgment to generate binary or continuous reward signals for each sample, which is precisely the foundation of reinforcement learning with verifiable rewards (RLVR). Compared with subjective scoring by reward models, verifiable rewards are more stable, harder to reward-hack, and easier to scale. For agent training, tool calling is naturally suited to this paradigm: whether a tool call succeeds and whether the return meets expectations can often be checked directly by a program. This also explains why Axion 1.0 builds its second SFT stage on real data sources and deterministic computation—it pre-installs a reliable reward source for the subsequent RL stage.

Reinforcement Learning: Polishing Long-Horizon Reasoning and Tool Interaction

The final reinforcement learning stage further strengthens long-horizon reasoning ability and the model's ability to interact with external tools and environments. Building on the reasoning and tool-use foundations laid by the first two stages, RL plays more of a "polishing" role than a "build from scratch" one.

What is mid-training? Mid-training is a stage between pretraining and post-training, typically using large-scale, high-quality, domain-specific data (such as code, math, long context, or agent trajectories) to continue pretraining the base model, injecting capabilities that general SFT data struggles to cover. In recent years, many models treat mid-training as a key step for improving reasoning and tool-use ability, but the cost is extra compute overhead and data engineering complexity. Axion 1.0 explicitly skips this stage, meaning it advocates injecting domain capabilities through high-quality SFT data and RL rather than relying on a large-scale continued pretraining pass.

What are DPO and OPD? Direct preference optimization (DPO) is a preference alignment method that doesn't rely on an explicit reward model, directly optimizing the policy with paired "better/worse" response data and commonly replacing the reward modeling and PPO steps in RLHF. Online policy distillation (OPD) involves a stronger teacher model scoring or distilling the distribution of trajectories sampled by the current policy in real time during training, so the student model imitates online. Both are common components of current post-training pipelines. Axion 1.0 discards both, compressing alignment and capability shaping into SFT and RL, reducing inter-component coupling and tuning burden—but it also means preference signals must enter training in other forms (such as verifiable rewards).

Performance: Competing Head-to-Head with Commercial Models

The team claims that despite the compact training recipe, Axion 1.0 achieves strong performance across a broad suite of agent benchmarks, and is competitive with leading commercial models on several of them.

It should be noted that the official materials do not provide specific benchmark scores or comparison figures, so only a qualitative description is possible here: its competitiveness claim covers a "broad suite" rather than topping a single leaderboard. For agent models, comprehensive performance across multiple benchmarks reflects practical usability better than a single metric, because agent tasks span a wide range—from single-step reasoning to multi-turn tool calling, the differences are significant.

What's Open Goes Beyond the Weights

Axion 1.0 goes further on openness than most "open-source" models. The team emphasizes that the scope of openness exceeds the model weights themselves, with the complete recipe released together—including data construction, generation, filtering, validation, prompts, and training code—so the entire development process can be reproduced and extended.

Related resources released alongside include an arXiv paper, a GitHub code repository, a Hugging Face training dataset, and a project homepage. The value of this "recipe-level openness" to the community: researchers not only get a usable model but can dissect the design tradeoffs at each stage, run ablation experiments on that basis, or transfer it to their own scenarios.

The difference between "open-source" and "open recipe." In the model community, "open-source" is often used loosely to mean "weights are downloadable," while training data, data construction pipelines, filtering rules, and training code are often not disclosed—making models hard to truly reproduce or audit. An open recipe requires releasing data generation, cleaning, validation, prompt templates, and training scripts together, enabling third parties to rerun the entire pipeline end to end. The difference directly affects research cumulativity: with weights alone, the community can only do inference-level evaluation and fine-tuning; with an open recipe, one can run ablations on training-stage tradeoffs, swap data sources, or transfer the method to new domains. Axion 1.0 claims to achieve the latter, and its actual value depends on the completeness and runnability of the released resources.

A Few Observations

First, Axion 1.0's value proposition is essentially about reproducibility. Agent model training has long suffered from the problem of "many performance claims, little detail disclosure," and recipe-level openness directly targets this pain point.

Second, the tension between the minimalist recipe and strong performance deserves attention. If competitiveness can be maintained without mid-training, DPO, and OPD, it suggests these stages' marginal returns in agent scenarios may be overestimated—though of course, this judgment can only be confirmed after community reproduction.

Third, data construction is central to both SFT stages: the first relies on model-aware synthesis and adversarial strengthening, the second on automatically verifiable real-data tasks. This thread points to a broader conclusion—in agent training, the ability to design data pipelines may determine the ceiling more than the complexity of the training algorithm.

Whether Axion 1.0 can truly become a reproducible template for open-source agent foundation models depends on how the community verifies its recipe. But it at least provides a clear experimental starting point: fewer technical steps in exchange for greater transparency.

One-line Summary

ByteDance releases Axion 1.0, a fully open 35B agent model that challenges complex pipelines with a minimalist training recipe.

Paragraph Summary

The ByteDance team released Axion 1.0, a fully open 35B-parameter agent foundation model whose core claim is that powerful agentic capabilities don't necessarily require a complex training pipeline. Its training recipe consists of just two lightweight supervised fine-tuning stages and one reinforcement learning stage, explicitly excluding mid-training, DPO, and online policy distillation. The first SFT stage synthesizes challenging problems through model-aware data construction and applies adversarial strengthening; the second SFT stage uses a scalable pipeline to construct automatically verifiable tool-calling tasks; the RL stage polishes long-horizon reasoning and tool interaction. The team claims strong performance across a broad suite of agent benchmarks and competitiveness with leading commercial models on several, though no specific scores are given. Openness extends beyond weights to cover data construction, generation, filtering, validation, prompts, and training code, released alongside a paper, code repository, dataset, and project homepage. The article argues its value lies in reproducibility and the central role of data pipeline design.