Trillion-Parameter Model Race Enters a New Phase: Balancing Long-Horizon Agent Capability and Inference Cost

From Conversation to Sustained Work: The Shift in LLM Capability Focus

Over the past two years, large language model development has centered on general conversation quality and knowledge coverage. Since 2025, however, the focal point of competition has been undergoing a structural shift: whether a model can reliably complete multi-step tasks in real environments over extended periods is replacing single-turn answer fluency as the new yardstick of practical value.

This judgment has a clear engineering basis. In code generation, financial research, and 3D tool calling, users do not need a one-off answer - they need a “digital worker” that can retry, call tools, read feedback, and adjust its strategy under constrained resources. These tasks place very different demands on a model than conversation does:

• Context length determines whether the model can stay aware of historical state across long-running tasks;
• Tool-calling reliability determines whether it can execute operations correctly in real terminal environments;
• Post-training compute determines how thoroughly its strategies converge in specialized domains;
• Inference cost determines whether those capabilities can be used frequently and for long durations.

A new-generation trillion-parameter model recently released by one vendor is a systematic upgrade along exactly this line. Its core approach can be summarized as: investing more post-training compute to push the model from “able to answer” to “able to do the work,” while easing the cost pressure of continuous operation through a high-speed variant and hosted infrastructure.

Architecture and Training: Post-Training Compute Scaling and RL Generalization

Parameter Scale and Context Capability

The model has around 3 trillion parameters and supports million-token contexts. Together, these two numbers signal that it targets not lightweight chat but complex tasks that must carry large volumes of code files, research documents, or tool-call histories within a single inference pass.

In practice, million-token contexts present challenges well beyond memory usage. Long-context inference substantially amplifies attention computation, and latency grows nonlinearly with sequence length. Long-context capability therefore has to be paired with inference optimization and scheduling strategies to work in production.

Post-Training Compute and Reinforcement Learning Expansion

Compared with the previous generation, the most visible change in this upgrade is a further increase in post-training compute and the extension of reinforcement learning to hundreds of downstream domains. The engineering implications are worth unpacking:

• More post-training compute means the model continues to be optimized through extensive supervised fine-tuning and reinforcement learning after pretraining, rather than relying on pretrained knowledge alone;
• RL across hundreds of domains means optimization is no longer confined to general chat or a single coding task; it now spans programming, financial research, 3D tool calling, long-horizon task execution, and other verticals;
• Joint multi-domain training requires a framework that can orchestrate heterogeneous environments and manage diverse reward signals simultaneously, placing higher demands on training stability.

To support this training system, the vendor systematically reworked its reinforcement learning framework, long-context inference, training efficiency, sandbox infrastructure, scheduling systems, and environment quality-check platform. None of this shows up directly in benchmark scores, yet it determines whether the model’s capabilities can be reproduced reliably and iterated continuously.

For developers, the key lesson is that model capability now depends more on the systems engineering behind the training infrastructure than on any single algorithmic breakthrough. When evaluating a model, look beyond benchmark scores to the engineering maturity of its training and inference pipeline.

Performance: Observed Results in Coding and Long-Horizon Agent Tasks

Terminal Coding Tasks

In agentic coding benchmarks set in realistic, resource-constrained terminal environments, the model scored 65.7%. These benchmarks assign dedicated verification to each task: the model must complete complex operations under limited resources rather than merely generate code snippets.

For reference, one closed-source model scored 58.2% on the same benchmark, while another leading closed-source model reached 66.4%. The model therefore outperforms the former and trails the latter by less than one percentage point.

The significance of this result: an open-weight model has now closed in on the strongest closed-source models in terminal coding, one of the most demanding scenarios. For teams that require private deployment or deep customization, this substantially lowers the capability barrier.

Long-Horizon Coding Tasks

On the vendor’s internal long-horizon coding benchmark, the model scored 61.2%, a clear improvement over the previous generation’s 55.95%. The benchmark spans multiple engineering disciplines and focuses on multi-step execution, tool calling, and end-to-end problem solving.

The difficulty of long-horizon tasks lies not in single-step accuracy but in controlling error accumulation. A task requiring 20 steps ends with less than 36% end-to-end success even at 95% per-step accuracy. Gains in long-horizon capability therefore typically come from targeted post-training optimization of error recovery, state tracking, and strategy correction.

Remaining Concerns

Two issues continue to draw attention: lopsided capabilities and verbosity. From an engineering standpoint, these correspond to two concrete challenges:

• Lopsided capabilities: the model is exceptionally strong in specific domains such as coding and finance, but may be less balanced elsewhere. Developers should define task boundaries clearly during selection to avoid capability gaps when generalizing across domains;
• Verbosity: longer outputs increase token consumption and latency, and inside an agent loop verbose output compounds cost. Output constraints, structured prompting, or post-processing strategies are needed to keep it under control.

Cost Structure: A Dual-Track Strategy of High-Speed Variants and Hosted Infrastructure

API Pricing and the High-Speed Variant

API pricing is RMB 1.3 per million tokens for cache-hit input, RMB 13 for cache-miss input, and RMB 68 for output. A high-speed variant offers the same model capabilities with roughly 2-3x faster output at about twice the standard price.

The engineering logic behind this dual-track approach is worth analyzing:

• The standard tier suits batch workloads that are cost-sensitive but latency-tolerant;
• The high-speed tier suits latency-sensitive scenarios such as interactive coding and real-time agent loops;
• Cache-hit pricing is far lower than cache-miss pricing, signaling that the vendor encourages users to reuse fixed prefixes such as system prompts and tool definitions. This matters especially for agents, which typically carry large amounts of fixed tool descriptions and system instructions - the cache hit rate directly affects the cost per task.

Hosted Agent Service

Beyond the raw model API, the vendor has launched a hosted agent service that provides the execution framework behind long-running agents as cloud infrastructure, capable of running long-horizon tasks around the clock and supporting multi-agent collaboration.

The positioning is clear: the bottleneck for agents often lies not in the model itself but in the runtime environment. Long-running tasks need stable sandboxes, state persistence, tool-call orchestration, failure retries, and resource isolation. Hosting these capabilities significantly reduces the engineering burden on developers.

For enterprise users, this means focusing on business logic and tool integration instead of repeatedly building agent runtimes.

Product Coverage and Availability

The model is now available across the vendor’s main product lines:

• General users can access it directly through the web and mobile apps;
• The desktop app brings the model’s capabilities to mainstream operating systems;
• Terminal and desktop coding environments can use the model for programming;
• Full model weights will be released before November 4.

The weight release matters to developers because it enables private deployment, domain-specific fine-tuning, and deep integration - particularly valuable for scenarios with strict data-security or customization requirements.

Practical Advice for Developers

Based on the above, several actionable recommendations:

1. Define task boundaries: the model is clearly strengthened in coding, agents, and financial research. Match it to those scenarios first, and watch for capability gaps when generalizing across domains;
2. Control output length: use structured output constraints in agent loops to reduce the token consumption and latency caused by verbose output;
3. Exploit caching: place stable content such as system prompts and tool definitions at the prefix to raise cache hit rates and lower the cost per task;
4. Evaluate the hosted service: for long-running agent workloads, prefer hosted infrastructure over building sandboxes, scheduling, and persistence yourself;
5. Watch the weight release: if you need private deployment or fine-tuning, evaluate deployment options and inference-optimization headroom as soon as the weights ship.

Conclusion

Competition among trillion-parameter models is shifting from parameter scale and conversation quality toward sustained work capability and cost per task. The core signal of this upgrade: post-training compute is tilting toward real agent environments, while the high-speed variant and hosted infrastructure attempt to absorb the cost and engineering complexity of continuous operation.

For developers, the selection criteria need updating: stop looking only at benchmark scores and start looking at reliability in real task loops, cost structure, and integrability. Advances in long-horizon agent capability are pushing large language models from tools toward orchestratable units of productivity - and how well you put that capability to use depends on the rigor of your engineering practice.