Axion 1.0: An Open Agent Model Trained With Two SFT Stages and RL

Axion 1.0 is an open agent model family whose authors say a plain recipe is enough: two supervised fine-tuning (SFT) stages, then reinforcement learning (RL), on about 18,000 training examples. The paper (arXiv 2611.03233) lists authors from Duke University, ByteDance, the University of Maryland and the University at Buffalo. It reports that the 122B version scores 59.0 on full Humanity's Last Exam (HLE) with restricted website access, and that the 35B version scores 62.2 on SEAL-0, above every other row in its comparison table.

The notable part is not only the scores. The team released the data construction code, prompts, training code and grading scripts, so others can rerun the process. This post covers what is released, what the numbers say, where the caveats are, and how it connects to other open-model recipes we have covered.

TL;DR: Axion 1.0 at a glance

What did the Axion team actually release?

The release has four parts, and they matter more than any single score.

1. The paper and project page. The Hugging Face paper page ranked third among papers of the day when we checked and had 25 upvotes. The project page summarizes the recipe and the training-stage tables.
2. The code. The bytedance/axion1_0 repository holds data generation and filtering, prompts, two-stage SFT, asynchronous RL, and benchmark preparation and grading. At the time of writing it had 19 stars and 36 commits, so this is an early release, not a tool with a community yet.
3. The training data. A dataset named axion-training-data sits on Hugging Face under the Axion1-0 organization.
4. A 35B checkpoint. The Axion-1.0-35B model card describes a BF16 reproduction checkpoint with about 35.1 billion parameters, Apache 2.0 licensed, tagged qwen3_5_moe.

One detail is easy to miss. The README says plainly that the 35B checkpoint "is a community release, not an official Axion checkpoint." The 122B model has results in the paper and README, but we did not find a 122B weights link in the sources we read. If you want the 122B model today, the path is to follow the training guide yourself.

The recipe: learn to reason, learn to investigate, learn through interaction

The authors frame the recipe as three stages. The idea is to put the complexity into the data, not into a long pipeline of training tricks.

Stage I: self-contained reasoning

Stage I uses 10,819 trajectories of scientific and mathematical reasoning. The team takes public seed problems and rewrites them into harder ones. Problems the base model already solves get strengthened further through composition, parameterization, range shifts or case analysis, and the reference answer is checked after each rewrite. The paper calls this model-aware data construction: the difficulty is tuned against what the base model can already do. Solvers may use Python here, but not search or web retrieval.

Stage II: tool-dependent reasoning

Stage II uses 7,544 trajectories, about 312 million tokens. The pipeline works backwards from the answer. Programs filter records from structured sources, pick a unique entity and compute the reference answer. Only then does an LLM write the question. The solver has to find the evidence with tools, and the construction data stays hidden from it. Questions that can be answered without retrieval are removed.

The README names the sources: the NASA Exoplanet Archive, OurAirports, OpenAlex, UniProt and Ensembl. That gives the tasks a deterministic, checkable answer, which is the property RL needs.

Stage III: reinforcement learning

Starting from the Stage II checkpoint, the team runs asynchronous GRPO on agent interactions with search, webpage visits, scholarly retrieval and Python. A correct final answer earns full reward, and verified intermediate progress can earn partial credit. Long rollouts are split into sessions with context condensation. Two systems details stand out: Token-In-Token-Out keeps token IDs identical between rollout and training, and Rollout Routing Replay aligns mixture-of-experts routing between the two.

If you want the background on why RL on verifiable tasks has become the standard last step, see our guide on asynchronous GRPO and agentic RL in TRL and the Perplexity JOLT paper on joint on-policy learning.

Reinforcement learning agent following a reward path, as in the Axion 1.0 final training stage

The scores: what the tables show and what they do not

Here is the selected table from the README, with the authors' footnote that a star marks baselines the Axion team evaluated itself and that other baselines come from official reports. A dash means the score was not reported.

BMB is the human-difficult subset of BioMysteryBench, and FS is FrontierScience. The longer table on the model card also lists Claude Opus 5 at 63.6 on HLE and 49.4 on BMB, GPT-6 Astra at 57.2 on HLE, and Muse-Spark-1.0 at 58.0 on HLE.

Reading the table honestly gives three points.

• Axion is strong where the table has data for it. The 122B model leads FrontierScience Olympiad and Research in the printed columns, and the 35B model leads SEAL-0.
• It does not lead on HLE or BioMysteryBench. Claude Fable 5 and Claude Opus 5 score higher on HLE, and several closed models score higher on BMB.
• The comparison is uneven. Many cells are empty, some baseline numbers were run by the Axion team, and others come from official reports. The project page itself warns that "baseline evaluation settings may differ." Treat it as a strong open result with a self-reported table, not as a leaderboard.

Another caution: the Axion scores are the best single-run scores from three runs, or five for BMB, per the project page. A best-of-N figure is not the same as a mean. The reproduction checkpoint on the model card shows 52.8 on HLE, 35.3 on BMB, 60.4 on SEAL-0, 45.9 on HiPhO, 85.0 on FS Olympiad and 55.0 on FS Research. That is close to the paper's 35B numbers, which is a useful sign that an outside team can approach the result, though it is a single reproduction.

How much did training cost?

This is the part most readers will care about. The authors report these costs on 32 GPUs for the two SFT stages.

RL adds more on top. The project page lists about 15 hours for the 122B model using 40 rollout GPUs and 16 training GPUs for 40 steps, and about 30 hours for the 35B model using 8 rollout and 8 training GPUs for 20 steps. These are reported numbers from the authors, not something we reproduced. They exclude the cost of building the data, which includes many LLM calls to rewrite problems and collect trajectories. The README also flags a small inconsistency in the released 122B SFT recipe: the saved arguments record micro-batch size 1 while the paper's Section 5.1 lists 2, and the release keeps the saved arguments.

Open model weights being released, matching the Axion 1.0 open recipe and Apache 2.0 checkpoint

How is this different from other open recipes?

Open weights are common now. An open recipe is rarer. Most open releases give you a checkpoint and a model card, and the data pipeline stays private. Axion publishes the generators, the filters, the prompts and the grading code.

The closest comparisons we have covered are small-model results built on the same Qwen base family. Coinbase reported that a fine-tuned Qwen3.5 9B beat Opus 4.5 on a fraud task, and a Qwen3.5 4B coder preview showed what a narrow fine-tune can do. Axion is broader: it targets general scientific reasoning and tool use, not a single task. On the open-weights side, Thinking Machines released Inkling Small, and the paper page's auto-generated summary line names that model, which is a small sign of how fast the open ecosystem is cross-pollinating.

For the argument that owning a tuned model beats renting one, see our piece on intelligence ownership and a GRPO-trained 9B catalog.

Limitations and open questions

• Base model dependence. Axion is a post-training recipe. Both main models start from Qwen checkpoints, so the base model's quality is a large part of the result. The paper does not claim to train a model from scratch.
• Benchmark scope. The tasks are scientific reasoning and information seeking. HLE, SEAL-0, HiPhO, FrontierScience and BioMysteryBench say little about coding agents, long computer-use sessions or product workflows.
• Restricted web access. The 59.0 HLE figure is "with restricted website access," per the README. That setting matters, because HLE answers can leak through the web.
• Tool harness not included. The inference guide notes that agent evaluation needs a tool-execution harness you supply. Matching the paper's numbers depends on matching that harness.
• Hardware. The model card example serves the 35B model with eight-way tensor parallelism. A 35B MoE with 3B active parameters is lighter than its size suggests, but BF16 weights are about 70 GB (the card lists 70,214,577,652 bytes), so plan for multiple GPUs or a quantized build.
• Early and small. 19 GitHub stars, 1 like on the model card and zero downloads at fetch time. The result has not been independently tested at scale.
• The community checkpoint is not official. Read the README line carefully before you cite "the Axion weights."

How to try it

If you want to serve the community 35B checkpoint, the model card uses vLLM:

vllm serve Axion1-0/Axion-1.0-35B \
  --served-model-name axion-35b \
  --host 127.0.0.1 --port 8000 \
  --tensor-parallel-size 8 --dtype bfloat16 \
  --max-model-len 131072 \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice --tool-call-parser qwen3_coder

Then call the OpenAI-compatible endpoint at /v1/chat/completions. For training, clone the repository and follow the training guide: SFT uses Swift with Megatron-FSDP, and RL uses verl. For data work, install the project with the data and evaluation extras in a separate Python 3.11 environment.

A useful first experiment is not to train anything. Read the Stage II data generators, then ask whether your own domain has a database with deterministic answers. If it does, the same "compute the answer first, write the question second" trick gives you verifiable agent tasks. Our IBM Palette 20B write-up shows another recent case of a task-specific harness shaping what an open model can do.

Why it matters

Three things make Axion worth watching, even with an early and self-reported result.

1. A reproducible path. If the numbers hold up in outside hands, a small team can build a competitive scientific agent with roughly 18K curated examples and a few hundred GPU-hours of SFT. The first reproduction is already close to the paper.
2. Data over pipeline. The authors argue for putting effort into verifiable, model-aware data and keeping the training stack plain. That matches a trend in recent RL work: reward quality limits the result.
3. Pressure on closed models. The 35B model has 3B active parameters, yet it posts competitive scores on a few columns against much larger closed systems. The gap on HLE shows closed labs still lead on the hardest general benchmark, but the margin is not large in every column.

We will add an update section if independent evaluations or the 122B weights appear.

Details are accurate as of November 4, 2026. Model scores, repository state and licenses can change after publication.

Related reading

• TRL AsyncGRPO and tree packing for agentic RL
• Perplexity JOLT: joint on-policy learning versus GRPO
• Coinbase's fine-tuned Qwen3.5 9B fraud agent
• Qwen3.5 4B 3D coder open preview
• Inkling Small open weights from Thinking Machines
• Intelligence ownership and a GRPO-trained 9B catalog
• IBM Palette 20B open-weight deck builder
• Official: paper page, arXiv abstract, GitHub, model card