K3.1 Pro Trillion-Parameter Model: Long-Horizon Agent Breakthroughs and the Inference Cost Challenge

1. Release Context and Core Specifications

A new trillion-parameter large language model has been released, representing the strongest version in its series to date. The model supports a million-token context window and places particular emphasis on code generation, 3D content creation, financial research, and long-horizon agent capabilities. A high-speed version has also been launched simultaneously, delivering approximately 2–3× faster output while maintaining the same intelligence level.

Key technical specifications:

• Parameter scale: 3 trillion (sparse activation architecture)
• Context window: Million-token level
• Primary capability focus: Code engineering, 3D tool invocation, financial research, long-horizon agent execution
• Deployment format: Standard edition + high-speed edition, dual-track

This release reflects a key trend in large-model competition: simply scaling parameter count is no longer the only path forward. Compute investment in the post-training phase is becoming the decisive variable in determining real-world usability.

2. Scaling Post-Training Compute: From General Alignment to Domain Specialization

2.1 Scaling Reinforcement Learning Across Domains

Compared to the previous generation, the most notable change is a further increase in post-training compute and the expansion of reinforcement learning (RL) across hundreds of downstream domains. The technical rationale deserves closer examination.

Traditional post-training for large models typically concentrates on general alignment—instruction following, safety alignment, basic reasoning. But when models are deployed in specific industry scenarios, general alignment alone is often insufficient for professional-grade tasks. By extending RL training across hundreds of vertical domains, the model is optimized through environment feedback within each domain.

The engineering challenges:

1. Environment construction cost: Each domain requires verifiable reward signals and a task environment
2. Training stability: Large-scale multi-domain joint training is prone to gradient conflicts and capability forgetting
3. Compute scheduling: RL training across hundreds of domains requires an efficient distributed scheduling system

2.2 Systematic Infrastructure Overhaul

To support this scale of joint training, the development team made systematic changes to the following infrastructure:

• RL training framework: Must support parallel sampling and policy updates in heterogeneous environments
• Long-context inference: The million-token window places high demands on attention mechanisms and KV cache management
• Training efficiency optimization: Including hybrid parallel strategies, gradient checkpointing, and communication compression
• Sandbox infrastructure: Provides secure, isolated execution environments for agent tasks
• Scheduling system: Coordinates resource allocation across thousands of training tasks and environment interactions
• Environment quality validation platform: Automated verification of task environment correctness and reward signal soundness

The essence of these changes is a shift from “supervised learning on static datasets” to “interactive learning in dynamic environments.” This transition places far higher demands on infrastructure than traditional training paradigms.

3. Long-Horizon Agent Capability: Benchmark Results and Technical Breakdown

3.1 Terminal-Environment Programming Agent Benchmark

On the terminal-environment programming agent benchmark, the model scored 65.7%. This benchmark tests programming agents in real, resource-constrained terminal environments, with dedicated tests for each task.

For reference, competing models at the same level scored 58.2% and 66.4% respectively on the same test. The new model has surpassed one major competitor and trails the top scorer by less than one percentage point.

The technical implication: the model’s end-to-end pipeline—tool invocation, output parsing, error handling, and iterative correction—has reached a notable level of maturity in real terminal environments. Terminal environments are characterized by large state spaces, sparse feedback signals, and difficult error recovery. Consistent completion of multi-step tasks under these conditions suggests the model’s planning and tool-use capabilities have crossed a critical threshold.

3.2 Long-Horizon Code Task Evaluation

On internal long-horizon code tests, the new model scored 61.2%, a significant improvement over the previous generation’s 55.95%. The test spans multiple engineering domains and evaluates:

• Multi-step execution: Decomposing complex requirements into executable subtask sequences
• Tool invocation: Correct use of external tools and APIs during code generation
• End-to-end problem solving: The full loop from requirement understanding to code delivery

The improvement from 55.95% to 61.2% (approximately 5.25 percentage points) represents meaningful progress in long-horizon task evaluation. These tasks have the property that “a single mistake breaks the chain,” so score improvements typically reflect qualitative capability shifts rather than incremental gains.

4. Managed Agent Service: Agent Runtime as Infrastructure

4.1 Service Architecture

Beyond providing direct model APIs, the platform offers a managed agent service that exposes the infrastructure required for long-running agents as a cloud service to enterprises and developers. Core features include:

• 7×24 long-horizon task execution: Agents can run continuously without human supervision
• Multi-agent collaboration: Coordination and communication between multiple agent instances
• State persistence: Intermediate task state can be saved and restored, preventing loss of work due to unexpected interruptions

4.2 Technical Challenges and Engineering Practices

Infrastructuralizing the agent runtime introduces the following core challenges:

State management: Long-horizon tasks may run for hours or days, requiring reliable checkpointing. A typical implementation approach:

# Pseudocode: Agent state checkpoint mechanism
class AgentRuntime:
    def execute_long_running_task(self, task):
        checkpoint = self.load_checkpoint(task.id)
        if checkpoint:
            state = checkpoint.state
            step = checkpoint.step
        else:
            state = self.initialize_state(task)
            step = 0
        while not self.is_complete(state):
            action = self.model.plan(state)
            result = self.sandbox.execute(action)
            state = self.update_state(state, result)
            step += 1
            if step % self.checkpoint_interval == 0:
                self.save_checkpoint(task.id, state, step)
        return self.finalize(state)

Resource isolation: Each agent task runs in an independent sandbox to prevent cross-task interference and security risks.

Elastic scaling: Agent workloads fluctuate significantly; resource allocation must adjust dynamically based on load.

Observability: Debugging and monitoring long-horizon tasks requires complete logging, metrics, and distributed tracing capabilities.

5. Inference Cost Analysis: Balancing Performance and Economics

5.1 Pricing Structure

The API pricing follows a tiered model:

Billing item	Price (per million tokens)
Cache hit input	1.3 CNY
Cache miss input	13 CNY
Output	68 CNY
High-speed edition	Approximately 2× standard edition

This structure reveals several key points:

1. Importance of caching: The 10× price gap between cache hit and miss indicates strong support for prefix caching in the architecture. For multi-turn conversations and agent tasks with substantial repeated prefixes, cache hit rate directly determines usage cost.

2. Output cost dominance: Output is priced at over 5× the input rate, consistent with the cost structure of autoregressive generation, where decoding compute far exceeds parallel encoding.

3. High-speed edition premium: 2× price for 2–3× throughput is cost-effective for latency-sensitive applications.

5.2 Token Consumption in Practice

Some users report exhausting their quota in about 10 minutes. This warrants technical analysis. In long-horizon agent tasks, token consumption is far higher than in typical conversational scenarios:

• Tool invocation overhead: Every tool call requires tool definitions, invocation arguments, and return values to be included in the context
• Cumulative multi-step reasoning: Each step in a long task must carry historical state, causing rapid context growth
• System prompt overhead: Agent scenarios typically require lengthy system prompts to define behavioral norms

Consider a typical long-horizon programming task:

• System prompt: 2,000 tokens
• Average tool call per step: 3,000 tokens (arguments + return values)
• Average task steps: 50
• Total consumption: 2,000 + 50 × 3,000 = 152,000 tokens

Using cache-miss input pricing of 13 CNY/million tokens and output pricing of 68 CNY/million tokens, a single task costs approximately 2 CNY for input and 2 CNY for output (assuming output is 20% of total), totaling around 4 CNY. Running multiple tasks in parallel, costs accumulate quickly.

6. Technical Trends and Engineering Implications

6.1 Strategic Value of Post-Training Compute

The most important signal from this upgrade: post-training compute investment is shifting from general capabilities toward sustainable agent environments. This includes programming, financial research, 3D tool invocation, and long-duration task execution.

The underlying logic: pre-training determines the model’s knowledge ceiling, while post-training determines its usability in real tasks. Once pre-training reaches trillion-parameter scale, post-training offers higher marginal returns—because it directly shapes the model’s “behavioral patterns” rather than its “knowledge base.”

6.2 Standardization Requirements for Agent Infrastructure

As agent capabilities move from demos to production, the following infrastructure capabilities are becoming essential:

• Sandbox execution environment: Secure, isolated, auditable code execution
• State persistence: Support for task pause, resume, and migration
• Multi-agent coordination: Task decomposition, role assignment, result aggregation
• Cost control: Token budget management, cache strategy optimization, model routing

6.3 Practical Recommendations for Developers

For developers planning to build agent applications with such models, the following engineering practices are recommended:

1. Optimize cache strategy: Place stable system prompts and tool definitions at the beginning of the context to maximize cache hit rates
2. Manage context windows: Design state compression and summarization mechanisms to prevent unbounded context growth
3. Monitor costs: Implement real-time token consumption tracking and budget alerting
4. Design task granularity: Split long tasks into appropriate subtask sizes, balancing per-call cost against task success rate
5. Build degradation paths: For non-critical steps, consider using more economical model versions

7. Conclusion

The latest iteration of the trillion-parameter model demonstrates a clear technical trajectory: through massive post-training compute investment and domain-expanded reinforcement learning, the model’s capability is advancing from “answering questions” to “sustained work.” Benchmark results in terminal-environment programming agents and long-horizon code tasks confirm that this direction is yielding measurable progress.

At the same time, the introduction of managed agent services and the design of the inference cost structure indicate that agent deployment is moving from the technical validation phase into the engineering phase. For enterprises and developers, understanding model capability boundaries, optimizing inference costs, and building reliable agent runtimes will be core engineering challenges in the coming period.

The announced open-source release of the full model weights will further lower the barrier for researchers to reproduce and build upon the work, accelerating the development of the long-horizon agent technology ecosystem.