Trillion-Parameter Model Upgrade: Faster and More Capable, But Long-Horizon Task Costs Remain a Challenge

From “Answering” to “Acting”: The Evolution of Trillion-Parameter Models

The capability boundary of large language models is shifting from simple question answering toward complex task execution. A recently released K-series flagship model pushes this trend further with a parameter scale in the trillions and a context window reaching the million-token level. The model demonstrates strength approaching top-tier closed-source models in specialized domains such as code generation, 3D creation, and financial research. More importantly, the shift in its training paradigm—extending reinforcement learning from a single domain to hundreds of downstream tasks—marks a key leap from “knowledge storage” to “autonomous action.”

Performance Gains: Code and Long-Horizon Agents Take Center Stage

In real terminal environment tests, the new model scored 65.7%, surpassing a mainstream cloud provider’s GPT series (58.2%) and narrowing the gap with another top closed-source model (66.4%) to within 1 percentage point. The value of this result lies in the test environment simulating real working scenarios with limited resources and requiring self-directed debugging, with dedicated validation for each task—avoiding the “memorized answers” pattern that produces inflated scores in conventional benchmarks.

Even more notable is the model’s performance on long-horizon code tasks. In an internally designed long-horizon test, the model scored 61.2%, an improvement of nearly 6 percentage points over the previous generation. This means the model can sustain tracking of multi-file, multi-module development tasks lasting several hours, understanding dependencies between阶段性 goals, rather than merely handling single function generation. For scenarios such as financial research and 3D tool invocation, this ability to “stay correct over long periods” often carries more business value than single-response accuracy.

Under the Hood: Nonlinear Post-Training Compute and a Rebuilt RL Framework

The performance improvement is not simply a matter of stacking more parameters but a systematic upgrade of training methodology. The core change is the nonlinear growth of compute in the post-training phase—turning reinforcement learning from “small-scale fine-tuning” into “large-scale joint training” spanning hundreds of real application domains. This requires four key infrastructure upgrades:

1. Distributed RL framework: Supports tens of thousands of parallel environment samplings, processing hundreds of millions of state transitions per minute to ensure stable policy gradient updates.
2. Long-context inference optimization: Through sparse attention and key-value cache compression, memory usage under million-token inputs is kept within single-GPU deployment range.
3. Sandbox infrastructure: Provides isolated container environments for each agent task, supporting code execution, browser operations, and other external tool calls, while preventing “runaway” behavior through resource quota management.
4. Environment quality inspection platform: Automatically verifies the solvability of each training environment’s tasks, removes ambiguous samples, and ensures the signal-to-noise ratio of RL signals.

The cost of this “full-stack” overhaul is high—training a single stage may cost 5 to 10 times that of the previous generation. But the benefits are equally significant: in tests like Terminal-Bench that require trial and error, the model demonstrates stronger self-correction and tool-invocation capabilities.

Pricing and Resource Consumption: A Sword of Damocles

The API pricing strategy reveals the model’s market positioning: cached input at roughly 1.3 yuan per million tokens, uncached input at 13 yuan, and output at 68 yuan. The so-called “high-speed version” costs nearly double. On the surface, this pricing is on par with high-end models from mainstream cloud providers, but real-world usage exposes a pressing issue—resource consumption for long-horizon tasks far exceeds expectations.

In agent mode, a single task may require dozens of rounds of tool calls, each accumulating context. At 20 interaction rounds per hour, a single workday’s token consumption can reach tens of millions. At output pricing, the full-day operating cost of a single agent may exceed one thousand yuan. Some test users reported that after enabling high-speed mode, prepaid credits were exhausted within 10 minutes—highlighting a deep tension between compute consumption and business value.

Technical recommendations: Developers should adopt a “tiered strategy” to control costs—

• Use smaller models to filter simple queries, invoking the flagship model only for complex reasoning;
• Enable semantic caching to preload repeated context fragments (such as project codebase descriptions), reducing high-cost uncached input fees;
• Set a “budget ceiling” for each agent step, downgrading to rule-based fallback processing once exceeded, to prevent runaway compute usage.

On-Device Deployment and Ecosystem Openness: Paving the Way for Inclusive AI

To lower the barrier to use, the service provider has integrated model capabilities into desktop clients, command-line tools, and cloud APIs. Notably, full model weights are planned to be released within two weeks of launch. This means enterprise users can deploy the model in private environments and fine-tune it with internal knowledge bases, completely eliminating dependence on public cloud services—for data-sensitive industries such as finance and healthcare, this is more attractive than benchmark scores.

Conclusion: A Sober Look Behind the Capability Leap

The breakthrough of trillion-parameter models in code and agent domains is essentially a阶段性 victory of trading “brute-force compute” for “intelligence breadth.” When a model can stably run long-horizon tasks for hours, we must be wary of three costs: the marginal benefit of compute consumption is diminishing, error accumulation over long contexts still lacks effective suppression, and high trial-and-error costs may hinder innovation participation by smaller teams.

For developers, rather than chasing leadership on individual metrics, it is more valuable to deeply understand the core paradigm of “reinforcement learning + environment interaction”—it will determine the product forms and commercial ceilings of AI applications over the next three years. Choosing which scenarios to invest “high-end compute” in and which steps to handle with “efficient lightweight solutions” will become key trade-offs in architecture design.