LLM Post-Training Race Shifts to Long-Horizon Agents: From Parameter Scale to Sustained Task Execution

1. A New Signal: Parameter Scale Is No Longer the Only Narrative

A leading model team recently released its latest-generation flagship model with trillion-parameter scale and support for million-token contexts, with targeted reinforcement in four scenario areas: code generation, 3D content creation, financial research, and long-horizon agents. A high-throughput variant launched alongside it delivers roughly two to three times faster output while maintaining the same intelligence level.

For developers, the most meaningful part of this release is not the parameter count but the migration of training focus: compared with the previous generation, the most visible change is a significant increase in post-training compute, with reinforcement learning extended to hundreds of downstream domains. The capability growth curve is shifting from “scaling data in pretraining” to “scaling environments in post-training” — instead of passively learning corpus distributions, the model explores, fails, and improves through feedback signals across large numbers of interactive task environments.

Supporting joint training at this scale required a systematic overhaul of the RL framework, long-context inference, training efficiency, sandbox infrastructure, scheduling systems, and the environment quality validation platform. This technical path is a valuable reference for any team aiming to build similar capabilities: when the training objective changes from “answer a question” to “complete a chain of tasks,” the bottleneck shifts from GPU compute to environment engineering.

2. A Watershed for Coding: Terminal Environments as the Core Benchmark

Coding and long-horizon agents are the clearest upgrade directions in this generation. On a coding agent benchmark built around real terminal environments, the new model scored 65.7%, while publicly released comparison results show two other widely recognized top-tier closed-source models scoring 58.2% and 66.4% respectively. In other words, the model has surpassed one strong competitor on this test and sits within one percentage point of the best result.

The benchmark’s design deserves a closer look, because it reflects real difficulties in engineering practice:

• Real, resource-constrained terminal environments: tasks run in terminals with resource limits, not in idealized sandboxes running unit tests;
• Task-specific verification for every task: evaluation checks intermediate artifacts and system state, not just the final output;
• Multi-step execution and tool calls: the model must plan command sequences, handle errors, and roll back mistaken operations on its own.

This is fundamentally different from traditional code benchmarks that “complete a function body given a signature.” The latter tests pattern matching; the former tests the ability to hold onto a goal in an uncertain environment and converge toward a solution step by step. On a long-horizon coding test, the model scored 61.2%, up noticeably from 55.95% for the previous generation. The test covers multiple engineering domains and focuses on multi-step execution, tool calls, and end-to-end problem solving.

From a developer’s perspective, the direct value of this improvement is that agentic coding tools can take on more complete units of work — for example, “locate an intermittent cross-module test failure, reproduce it, fix it, and verify the fix” — rather than just “complete a snippet of code.” But two concerns remain:

1. Uneven capability: after reinforcement learning was extended to hundreds of domains, improvements are not balanced across them; performance on some niche tasks lags behind the overall score;
2. Verbosity: in long-horizon tasks, the model tends to produce extensive intermediate explanations and redundant operations, driving up token consumption — which translates directly into cost under usage-based billing.

3. The Engineering Foundation: Harness as Infrastructure

One easily overlooked move in the release is that the task framework (Harness) supporting long-running agents is being offered as cloud infrastructure, forming a managed agent service: it supports 24/7 long-horizon tasks and multi-agent collaboration.

The technical implication is clear — the core competitiveness of agents is shifting from “can the model reason” to “can the system endure.” An agent that runs continuously for hours or even days has to solve the following engineering problems:

Key components of a long-horizon agent runtime
├─ Session and state persistence   → resumable checkpoints, context compression and retrieval
├─ Sandbox and resource isolation  → per-task execution environments, quotas and timeout control
├─ Tool-call gateway               → permission tightening, idempotent retries, result validation
├─ Scheduling and orchestration    → multi-agent division of labor, dependency management, failover
├─ Observability                   → end-to-end tracing, token and latency attribution
└─ Environment quality validation  → task solvability, grader consistency, cheat prevention

The “environment quality validation platform” deserves particular attention. The effectiveness of reinforcement learning depends heavily on the reliability of environmental feedback: if the grader itself is biased, or if many tasks are unsolvable, the model learns noise. That is why large-scale RL training must first establish an environment governance system instead of running directly on off-the-shelf task sets.

The practical lesson for enterprises: when adopting long-horizon agent capabilities, prioritize evaluating the runtime infrastructure, not just model scores. An agent that completes complex tasks in a demo, and an agent that runs stably for a week in production, recovers from failures, and has attributable costs, are separated by an entire engineering system.

4. Deployment and Cost Structure: Real Trade-offs Under Token-Based Billing

The model family now spans multiple product forms: web and mobile entry points for general users, office-scenario capabilities for desktop, and coding capabilities used in terminal and desktop environments. Full model weights are planned to be released about two weeks after launch — an important signal for teams that need private deployment or deep customization.

The API pricing structure offers another angle on cost: cache-hit input tokens are priced at about RMB 1.3 per million tokens, cache-miss input at RMB 13, and output at RMB 68. The high-throughput variant maintains the same intelligence level at roughly twice the price of the standard version. These numbers reveal three things:

1. The gap between cache hits and misses is nearly tenfold, which makes context reuse the primary cost lever. Stable system prompts, long-lived codebase summaries, and fixed tool schemas should all be placed in the cacheable prefix whenever possible;
2. Output is far more expensive than input, confirming that the verbosity problem mentioned earlier directly inflates the bill. Constraining output length and curbing redundant intermediate steps is a necessary cost-control measure;
3. Speed can be bought at a premium. The high-throughput variant suits latency-sensitive scenarios such as interactive coding and real-time collaboration, while the standard version is more economical for batch-style analysis tasks.

Under this structure, the cost of a continuously running long-horizon agent can be roughly decomposed as: total cost ≈ cache-miss input × 13 + cache-hit input × 1.3 + output × 68 (in RMB per million tokens). Practical optimization paths include raising the prefix reuse rate, summarizing and compressing historical context, and switching to lighter execution strategies for non-critical steps.

5. Practical Recommendations for Developers

Drawing on the analysis above, capability building for long-horizon agents can proceed in the following order of priority:

• Build evals before choosing a model: construct a small benchmark from real terminal tasks in your own business, covering multi-step execution and tool calls, and avoid making decisions based solely on public scores;
• Treat context as a cacheable asset: place stable, unchanging content at the front of prompts and dynamic content later, maximizing the cache-hit ratio;
• Design checkpoints for long-horizon tasks: state persistence and idempotent retries are the foundation of long-run reliability — don’t rely on a single session to complete all the work;
• Establish cost attribution: record input, output, and cache hits per task, identify where verbose output comes from, and constrain it accordingly;
• Take environment governance seriously: if you plan to do post-training or domain fine-tuning, investment in grader consistency and task solvability validation should be no less than the investment in training itself.

From trillion parameters to million-token contexts, then to reinforcement learning across hundreds of domains and managed long-horizon agents, the evolution of this model generation makes one thing clear: the key metric of model capability is shifting from “the quality of a single answer” to “the reliability of sustained work.” For developers, this means the focus of architecture design must shift accordingly — treat agents as long-running systems that need to be operated and maintained, not as one-off inference calls.