K3.1 Pro Technical Deep Dive: Long-Horizon Agent Breakthroughs and Inference Cost Challenges

1. Overall Direction of Model Capability Upgrades

A 3-trillion-parameter large language model has recently been officially released, supporting a million-token context window and placing heavy emphasis on code generation, 3D content creation, financial research, and long-horizon agent capabilities. A high-speed variant launched alongside it delivers roughly 2–3× higher output speed at the same intelligence level, offering a better option for latency-sensitive scenarios.

According to publicly available evaluation data, the model has reached or approached the level of the strongest current closed-source models on coding, agent, and knowledge benchmarks. Compared with the previous generation, the most notable change is a further increase in post-training compute and the extension of reinforcement learning to hundreds of downstream domains. To support this large-scale joint training, the research team systematically reworked the reinforcement learning framework, long-context inference, training efficiency, sandbox infrastructure, scheduling system, and environment quality-checking platform.

This upgrade direction sends a clear signal: leading model vendors are investing more post-training compute into agent environments where models genuinely need to work continuously—including programming, financial research, 3D tool invocation, and long-duration task execution.

2. Coding and Long-Horizon Agent Capabilities: Key Breakthroughs

2.1 Evaluation Performance of Terminal-Environment Coding Agents

Coding and long-horizon agents are among the most visible areas of improvement in this upgrade. On the terminal-environment coding agent benchmark, the model scored 65.7%. This benchmark tests a coding agent’s ability to complete complex tasks in realistic, resource-constrained terminal environments, with dedicated tests for each task. For comparison, two other top-tier closed-source models in the same evaluation scored 58.2% and 66.4% respectively. This means the new model has surpassed one of them and trails the other by less than 1 percentage point.

Behind this result is a systematic improvement in the model’s multi-step execution, tool invocation, and end-to-end problem-solving capabilities. Coding tasks in terminal environments often involve file system operations, process management, dependency installation, error diagnosis and repair, and other steps, placing extremely high demands on the model’s planning ability and context retention.

2.2 Progress on Internal Long-Horizon Coding Tests

On internal long-horizon coding tests, the model scored 61.2%, a further improvement over the previous generation’s 55.95%. These tests cover multiple engineering domains and focus on evaluating the model’s multi-step execution, tool invocation, and end-to-end problem-solving capabilities. The difficulty of long-horizon tasks lies in the fact that the model must maintain goal consistency across hundreds of interaction rounds while dynamically adjusting strategies in response to environment feedback.

From an engineering practice perspective, improving long-horizon agent reliability requires coordinated optimization at three levels:

• Planning layer: Decompose complex tasks into verifiable sub-goals and dynamically re-plan during execution;
• Execution layer: Safely invoke tools, execute code, and read/write files within a sandbox environment;
• Reflection layer: Perform self-correction based on execution results to prevent error accumulation from causing task failure.

# Typical execution loop for a long-horizon agent
while not task_complete:
    plan = model.plan(current_state, history)
    action = model.select_action(plan, available_tools)
    result = sandbox.execute(action, timeout=30)
    history.append((action, result))
    if result.error:
        model.reflect_and_retry(result.error)

2.3 Issues That Still Require Attention

Despite the substantial improvement in coding capability, concerns remain about uneven performance across domains and verbose output. “Uneven performance” refers to imbalanced results across certain programming languages and frameworks, where code generation quality in some niche areas still lags behind the top tier. Verbose output manifests as a tendency to generate excessive explanatory text and comments, which can hurt efficiency in scenarios requiring concise output. These issues need to be gradually addressed through optimized post-training data mixing ratios and output control strategies during inference.

3. Infrastructure: The Key to Supporting Large-Scale Agent Operation

3.1 Systematic Rework of the Reinforcement Learning Framework

Extending reinforcement learning to hundreds of downstream domains means the training system must simultaneously manage a large number of environment instances, policy updates, and reward computations. This places extremely high demands on the framework:

• Environment isolation: Each RL environment requires an independent sandbox to prevent interference;
• High-concurrency scheduling: Parallel execution and resource allocation for thousands of environment instances;
• Reward signal aggregation: Cross-domain reward standardization and weighting strategies;
• Training stability: Gradient synchronization and fault tolerance in large-scale distributed training.

3.2 Long-Context Inference Optimization

A million-token context window poses severe challenges for inference systems. The computational complexity of attention mechanisms grows quadratically with sequence length, and KV cache memory footprint becomes a bottleneck. Common industry optimization approaches include:

• Chunked attention and sliding window mechanisms;
• Quantization compression and tiered storage for KV cache;
• Separated scheduling of prefill and decode phases;
• Prefix cache reuse to reduce redundant computation overhead.

These optimizations directly affect API pricing structure. Taking cache hits as an example, when a request’s prefix matches an existing cache, input costs can be substantially reduced, which encourages developers to design agent applications with stable system prompts.

3.3 Hosted Agent Services

In addition to directly offering model APIs, the platform has also launched a hosted agent service that provides the harness supporting long-running agents as cloud infrastructure for enterprises and developers. Such services typically feature:

• 24/7 long-horizon task execution: Support for continuous task execution lasting hours or even days;
• Multi-agent collaboration: Message passing and task coordination among multiple agent instances;
• State persistence: Recovery and continuation of tasks after interruption;
• Observability: Complete execution logs, call chain tracing, and performance monitoring.

For enterprise users, this means they can host long-horizon tasks in the cloud without building complex agent runtime environments themselves, focusing instead on business logic development.

4. Product Coverage and Cost Structure

4.1 Multi-Platform Product Integration

The model has been integrated across major product lines: general users can experience it directly on the web and in mobile apps; the desktop client provides model capabilities across major operating systems; and coding tools in terminal and desktop environments can also invoke the model for code generation and debugging. Full model weights are planned for release in the near future, which will further drive community ecosystem development.

4.2 API Pricing and Cost Optimization

For the API, per-million-token pricing for cache-hit input, cache-miss input, and output shows a clear gradient. The high-speed variant offers the same model capabilities at roughly 2× the price of the standard version. For developers, the core of cost optimization lies in improving cache hit rates:

• Place stable system prompts and tool definitions at the request prefix;
• Maintain prefix consistency across multi-turn conversations;
• Set reasonable cache expiration policies to balance hit rate and storage cost.

In a long-horizon agent scenario, for example, if system prompts and tool definitions occupy tens of thousands of tokens, cache hits can reduce this portion of cost to one-tenth of the original, significantly lowering the overall overhead of high-frequency calls.

5. Summary and Outlook

This upgrade of the trillion-parameter model marks a shift in large model competition from “single-point capability breakthroughs” to the systematic construction of “sustained working capability.” The improvement in coding and long-horizon agent capabilities, the expansion of reinforcement learning scale, and the introduction of hosted agent infrastructure all point to one trend: models are no longer just Q&A tools but are becoming the agent core capable of autonomous planning, tool invocation, and continuous execution of complex tasks.

For developers, this means a new application paradigm is taking shape—shifting from “calling APIs to get answers” to “hosting agents to complete work.” In this transition, how to design efficient agent loops, how to optimize inference costs, and how to ensure the reliability of long-horizon tasks will become core engineering challenges. With the opening of model weights and the maturation of hosted services, building sustainable agent systems will become increasingly feasible.