For two years the AI industry has run on an assumption close to religious faith: stronger models need more parameters. A trillion parameters is the entry ticket for the major leagues; a few hundred billion is the passing grade for the middle class; anything under a hundred billion, politely, is not seated at the table. Shanghai AI Lab just knocked on that consensus with an open-source 35B mixture-of-experts model called Agents-A1.
The model is not trying to prove that 35B parameters can replace a trillion-parameter giant — it makes no such claim. What it does is more fundamental: it moves the axis of agent competition from “whose model is bigger” to “who can keep working longer.” The paper’s title says it outright: Scaling the Horizon, Not the Parameters. This is not a contrarian tract against large models. It is evidence for an underrated choice — that the horizon of a task, not the width of a network, is where agentic capability is actually being won and lost right now.
The Big-Model Story Is Leaking Air
Nobody disputes what trillion-parameter models are good at. They know more, reason deeper, and understand wider. Chat with one on a leaderboard and you come away thinking: yes, this thing is smart. But when the task changes from “answer one question” to “complete one process” — research it, call the tools, run the code, read the feedback, correct course, run again — the giants start to stutter. Their intelligence is sprinter intelligence, and agentic work is a marathon.
The paper quantifies the gap with unusual clarity. On GAIA, a long-horizon search benchmark, a search-augmented teacher built on a 35B-class base (a Qwen3.5 variant) lifted its score from 59.8 to 95.1 — and the only thing that changed was the length of the tool-call and search chain, not a single parameter. On FS-R, a scientific reasoning benchmark, the score went from 2.5 to 54.3, because the model learned to call external tools, check intermediate evidence, and verify its own reasoning steps across long scientific chains.
Read those numbers again with care. This is not a David-beats-Goliath story. It is a story about what kind of training marathoners need: the same base model, trained for duration, beats the model that merely answers quickly.
Not More Parameters — Longer Chains
The training recipe behind Agents-A1 is a conversion: from teaching a model to answer one question, to teaching a model to finish one process. It runs in three stages.
Stage one: full-domain SFT. The team first ran supervised fine-tuning on multi-domain, high-quality long-horizon trajectories, so the model could understand tasks and follow instructions in long contexts. This laid the foundation — and exposed the problem. Full-domain SFT improved long-horizon search and engineering tasks, but degraded general agent tasks and instruction following. Different reasoning modes conflict with each other, and one-size training cannot resolve the conflict.
Stage two: domain teachers. Agent capability was split into four tracks — search, scientific reasoning, instruction following, and tool calling — and a specialist teacher was trained for each. The search teacher, SFT then RL, pushed GAIA to 95.1. The scientific teacher, two-stage SFT, took FS-R from 2.5 to 54.3. The instruction-following teacher used two-stage RL to lift LongBench V2 and IFBench. The tool-calling teacher learned through SFT plus RL when to call, how to recover from errors, and when to stop.
Stage three: multi-teacher on-policy distillation. This is the paper’s core technical contribution. Rather than an ensemble or MoE-style routing, the team built a domain-routed on-policy distillation framework with salient vocabulary alignment: each domain teacher evaluates trajectories that the student model generates itself, instead of grading pre-paired offline data through imitation. The distinction matters because in long-horizon tasks, the trajectories a student generates in the wild diverge completely from what a teacher sees in a training set. Offline imitation teaches answer-matching; on-policy distillation teaches process-matching. The paper confirms this resolves the reasoning-mode conflicts that full-domain SFT could not, preserving broad coverage while absorbing each specialist’s strengths.
Underneath all three stages sits the paper’s infrastructure contribution: the Knowledge-Action Graph, or KAG. It does not just record facts; it logs every intermediate state of every task — what the model looked up, which tool it invoked, what came back, whether verification passed, how it adjusted after failure. The average agent trajectory in this dataset runs about 45,000 tokens, a hundred times longer than a typical question-answer pair. That process-level supervision is what lets a 35B model learn to persist. A proposer-solver-verifier self-play loop keeps generating fresh high-quality trajectories, so the training data evolves continuously instead of being stamped once.
The Framework: Capability Times Horizon Times Trajectory
The lasting value of Agents-A1 is not its benchmark runs — those age fast. It is the mental model it proposes: agent capability equals base-model competence, multiplied by task-chain length, multiplied by trajectory quality. The industry has fixated on the first factor. Scaling laws drove the trillion-parameter race; every order of magnitude jumped training costs and inference bills alike. That is the table OpenAI, Anthropic, and Google play at.
The other two factors have been starved of attention. Task-chain length asks: how many consecutive decisions can a model make before it loses the plot? Can it stay coherent across ten searches, twenty tool calls, five rounds of code execution? The relationship to parameter count is real but not linear — a 35B model that can sustain a 45,000-token trajectory will beat a trillion-parameter model that answers brilliantly and then forgets the thread. Trajectory quality asks what the model learns from long runs: not to memorize answers but to memorize how answers are found, verified, and repaired. KAG provides verification-bearing process records — which step was right, which deserved reflection, whether the evidence chain is complete — and that density of signal is what generalizes.
Scaling the horizon means the bottleneck on agent capability is migrating from a model’s knowledge density to its task persistence and decision-loop closure. That is a different kind of scaling law, and nobody has hit its ceiling yet.
Where Else the Framework Explains What You Are Seeing
The framework reaches well beyond one paper. Coding assistants have already shifted their competitive axis from completion accuracy to how long an issue-to-PR loop an agent can hold without derailing; practitioners now compare agents on whether they can carry a full feature or a gnarly bug through dozens of steps. That is a horizon contest. Deep research products from Google, OpenAI, and a crowd of startups compete not on which model they call but on how many rounds of search they sustain, how many sources they cross-check, how long a report stays logically consistent — a 35B agent with good search trajectories can beat a closed trillion-parameter model doing single-shot search. Enterprise RPA is the same story with older software: rule scripts are being replaced by models that understand processes, and the harder the process — more systems, more validation steps, more exception handling — the more horizon the agent needs. And in science automation, the paper’s whale-call detection case is not a gimmick: starting from a plain CNN, the agent pushed AUC from 0.58 to 0.9935 in twelve hours through dozens of code-edit, train, evaluate, reflect, repeat cycles. An agent that can run a research loop unattended defines the next paradigm of scientific work better than any math-benchmark score does.
What to Do With This
If you build AI applications: stop selecting models by chatbot-arena rank and start selecting by performance at your required task-chain length. A 35B model that sustains 50,000-token tool trajectories may fit your workflow better than a 200B model that only excels at single turns. Agents-A1 is open-sourced under Apache-2.0 with vLLM and SGLang support, and it costs little to test against your real workload.
If you train models: long-horizon trajectory infrastructure may buy more capability per dollar than another parameter zero. Process-level data collection in the KAG style, self-play expansion, multi-domain distillation — these directions compound. When resources are tight, optimizing how you train increasingly beats enlarging what you train.
If you make technology decisions: recalibrate what “scaling” means for your roadmap. The trillion-parameter race belongs to frontier labs; the broader application-layer race is being run on horizons. Watch the techniques that extend execution chains, raise trajectory quality, and lower deployment costs — in most enterprise scenarios they will return more than the next model upgrade does.
Benchmarks change, frameworks change, but the core question does not: how long a piece of work can your agent actually finish without you?
Paper: Scaling the Horizon, Not the Parameters (arXiv 2606.30616). Code and weights: github.com/InternScience/Agents-A1, Apache-2.0 license.
