Next-Gen LLM Released: Enhanced Inference, Long-Horizon Agents, and Cost Analysis

I. Core Upgrade Logic: Shifting from “Stronger” to “Sustainable Work”

The most significant change in this newly released model version is not simply increasing parameters or stacking more training data. Instead, the upgrade focuses on “long-duration, multi-step, interactive task execution.” Previously, many LLMs excelled in single-turn Q&A or short-text generation. However, they often suffered from goal drift, missed steps, or uncontrolled resource consumption when entering scenarios requiring continuous judgment, repeated tool calls, and execution context maintenance.

The new version’s capabilities are explicitly tailored for Long-Horizon Agent scenarios. A long-horizon agent must continuously execute a goal over an extended period, such as autonomously modifying a code repository, tracking a financial research task, driving a 3D creation pipeline, or completing multi-stage deployments in a terminal environment. These tasks demand high levels of context retention, tool-calling stability, and error recovery from the model.

From a technical perspective, this upgrade is reflected in three main areas:

1. Significant Increase in Post-Training Compute
   Rather than relying solely on massive text from the pre-training phase, the model directs more compute power toward reinforcement learning (RL) and human feedback alignment. RL covers hundreds of downstream domains, enabling the model to exhibit stronger policy selection capabilities across different task types.

2. Agent-Oriented Training Environment Overhaul
   To support large-scale joint training, the R&D team systematically restructured the RL framework, long-context reasoning chain, sandbox execution environment, scheduling system, and environment quality inspection platform. This means the model was exposed to numerous real tool calls and task execution scenarios during training, rather than just learning text-level answers.

3. High-Speed Inference Version
   While maintaining the same intelligence level, engineering optimizations have increased the output speed by roughly 2 to 3 times. This is crucial for real-time interactive scenarios, such as intelligent coding assistants, terminal command interpreters, or financial data analysis tools.

II. Coding Capabilities and Long-Horizon Performance: Real Changes from Benchmarks

In the capability evaluation of the new version, code generation and terminal task execution are among the most noteworthy metrics.

1. Programming Agent Testing in Terminal Environments

In a test known as “Terminal-Bench 4.0,” the new model achieved a score of 65.7%. This test is characterized by running in a real, resource-constrained terminal environment, with specific validation tests for each task. The model must independently complete environment checks, command concatenation, error fixing, and final acceptance, rather than simply generating an isolated piece of code.

For comparison, current leading closed-source models in the industry score between 58% and 66%. The new model has surpassed some top-tier models and is less than 1 percentage point behind the highest-scoring model. This indicates that in the dimension of “actually completing tasks,” the new model has entered the first tier.

2. Internal Long-Horizon Code Benchmark

In an internally constructed “Code Long-Horizon Benchmark,” the new version scored 61.2%, a significant improvement over the previous generation’s 55.95%. This test focuses on multi-step execution, tool calling, and end-to-end problem-solving. For example, the model might need to read an existing project’s directory structure, modify multiple files based on requirements, and finally run tests and fix failed cases.

This test closely resembles real-world development scenarios. Traditional code generation evaluations only focus on whether the model can generate a correct function body, whereas long-horizon code evaluation assesses whether the model can complete an entire workflow like a junior engineer.

3. Remaining Issues: Task Bias and Verbose Output

Despite the capability enhancements, the new model still exhibits “bias” in certain tasks. For instance, in specific financial data parsing or 3D tool calls, the model may lean towards generating lengthy explanations rather than directly outputting executable results. While this verbose output might not be penalized in testing environments, it increases token consumption and response latency in actual production environments.

Therefore, during actual deployment, it is recommended that developers control the structure and length of the generated content through prompt constraints, output format templates, or post-processing parsers.

III. Deployment and Service Models: From APIs to Managed Agents

The new model has covered major product entry points, including web, mobile, desktop, and terminal programming tools. For enterprise users and developers, API integration and managed agent services are more critical.

1. API Pricing Structure Analysis

The API uses a tiered billing model. The specific prices are as follows:

Billing Item	Price (per million tokens)
Cached Input	1.3
Uncached Input	13
Output	68

(Note: Prices are listed in the original currency denomination)

The price of the high-speed inference version is approximately twice that of the standard version. It is important to note that long-horizon agent tasks often frequently read the same context fragments, so the cache hit rate directly impacts the final cost. When building agents, developers are advised to reuse system prompts, tool descriptions, and task background information as much as possible to increase the cache hit ratio.

2. Managed Agent Service

In addition to direct model API calls, this update introduces a managed agent service. This service opens the execution environment (Harness) that supports long-running agents to enterprises and developers as cloud infrastructure, featuring:

• 24/7 long-cycle task execution support;
• Multi-agent collaboration support;
• Persistence of environment state, task progress, and intermediate results;
• Exception recovery and checkpoint resume capabilities.

This type of service is suitable for scenarios requiring continuous monitoring, scheduled execution, or complex pipeline orchestration, such as regularly generating financial research reports, autonomously maintaining code repositories, or driving 3D asset generation pipelines.

IV. Key Engineering Challenges for Long-Horizon Agents

When a model scales from “single Q&A” to “continuous work,” it faces a new set of engineering problems. Understanding these challenges helps developers design agent architectures more rationally.

1. Context Window Management

Long-horizon tasks often require maintaining a large amount of intermediate information, including executed steps, tool return results, and error logs. Without control, the context will rapidly expand, leading to rising costs and degraded reasoning quality.

The following strategies are recommended:

• Periodic Summary Compression: Every few rounds, compress historical execution records into structured summaries.
• Key Information Extraction: Retain only task goals, completed steps, pending steps, and recent error information.
• External State Storage: Write complete histories to external storage and retrieve them via queries when needed.

2. Tool Calling Stability

During continuous execution, tool calls may fail due to environment changes, permission issues, or parameter errors. The model needs necessary fault tolerance, for example:

def execute_with_retry(tool_call, max_attempts=3):
    for attempt in range(max_attempts):
        try:
            result = dispatch(tool_call)
            return result
        except ToolException as e:
            log_warning(f"attempt {attempt + 1} failed: {e}")
            tool_call = revise_params(tool_call, e)
    raise MaxRetriesExceededError

In actual implementation, the agent framework should have built-in retry, fallback, and degradation mechanisms, rather than relying entirely on the model’s own judgment.

3. Cost and Latency Control

Long-horizon tasks can consume hundreds of thousands or even millions of tokens. If each tool call carries the full history, costs will grow linearly. It is recommended to dynamically adjust the context content based on the task phase—for example, retaining only the high-level plan and the last two tool results during the middle of task execution, and loading the full history during the review phase.

V. Application Scenarios: When to Use High-Performance Long-Horizon Models

In the following scenarios, the new model’s capability advantages can yield significant benefits:

• Automated Programming: Cross-file refactoring, dependency updates, test fixing, and deployment script writing.
• Financial Research: Long-duration data scraping, multi-source cross-validation, and structured report generation.
• 3D Creation Support: Parametric modeling instruction generation, rendering pipeline orchestration, asset organization, and version comparison.
• Complex Process Automation: End-to-end workflows requiring coordination across multiple external systems or APIs.

However, if a task only requires a single short answer or has extremely strict latency requirements, using the high-speed inference version or a smaller-scale model may be more economical.

VI. Practical Recommendations: Reducing the Deployment Cost of Long-Horizon Agents

1. Cache First: Keep system prompts, tool metadata, and task templates consistent to maximize the input cache hit rate.
2. Prune Context: Before each round of tool calls, retain only the currently necessary information to avoid infinitely appending history.
3. Tiered Model Strategy: Use the standard version for simple steps and invoke the high-performance model only at critical decision points.
4. Output Constraints: Use JSON Schema or explicit formatting requirements to reduce invalid verbose outputs.
5. Persistent State: Save task states in external storage so the agent can resume at a low cost after an interruption, rather than re-executing the entire workflow.

VII. Conclusion

This new model version represents a significant advancement in the long-horizon task execution capabilities of large language models. It no longer settles for static knowledge Q&A but extends its capability boundaries to real production scenarios like continuous work, multi-step reasoning, and tool calling. For developers and enterprise users, understanding the capability structure, deployment methods, and cost models of such models will facilitate more pragmatic architectural choices and investment decisions on the eve of an agent explosion.