Long-Horizon AI Agent Models Explained: Zhipu's New General LLM for Multi-Step Agent Tasks

    Zhipu AI released a general-purpose large language model optimized for agent workflows on March 16, 2026. This article explains its public specifications, training method, and significance for agent development. It covers the shift from text generation to task execution, the model's sparse mixture-of-experts architecture (about 744 billion total parameters, 40-44 billion active parameters, 28.5 trillion pretraining tokens, a 200K-token context window, and a 128K-token maximum output), and its agent-oriented asynchronous reinforcement learning. It also shows how to build reliable agents on top of such models by managing tool calling, instruction following, persistent tasks, and multi-agent collaboration. It then covers which metrics to track and which security, governance, and rollout practices to follow.

    Generative AI has been moving from answering questions to executing tasks, and the criteria used to evaluate models are changing with it. In the past, users mainly cared about whether a model could produce fluent, accurate text. Today, in scenarios such as office automation, software development assistance, information retrieval, and workflow orchestration, models are also expected to call external tools, track instructions over many turns, handle long contexts, recover from failure states, and complete multi-step tasks.

    In response to this trend, Zhipu AI released a general-purpose large language model optimized for agent workflows on March 16, 2026. This article refers to it as a “long-horizon agent model” and focuses on its publicly available technical features and their practical significance.

    1. Positioning: From Text Generation to Task Execution

    The long-horizon agent model is not built for a single vertical industry. It is a general-purpose model whose key optimizations target tasks that require continuous decision-making and multiple rounds of execution. Such tasks typically have the following characteristics:

    1. The goal cannot be achieved in one pass and must be broken down into multiple steps.
    2. Execution requires frequent calls to external tools such as search, code, databases, file processing, or business systems.
    3. User instructions may be supplemented, corrected, or re-prioritized during execution.
    4. The task runs for a long time, so the model must remember what has already been done, the current state, and the remaining plan.
    5. When a step fails, the model needs to identify the cause and decide whether to retry, adjust parameters, or switch to an alternative approach.

    Traditional models generally perform well on short conversations and single-turn content generation. In long-running tasks, however, they can make tool parameter errors, miss instructions, repeat actions unnecessarily, suffer context decay, or drift away from the goal midway. The core value of long-horizon agent models is therefore not simply answering better. It is completing work more reliably within complex workflows.

    2. Public Parameters and Architecture

    According to public information, the model has approximately 744 billion total parameters and around 40-44 billion active parameters. It uses a mixture-of-experts (MoE) architecture with 80 layers and 256 experts. It was pretrained on roughly 28.5 trillion tokens.

    The basic idea behind MoE is to keep a large parameter capacity while activating only a subset of the expert networks when processing each token. This approach improves the model’s ability to capture different types of tasks and helps control the compute cost of each inference. For agent tasks, different experts may specialize in code generation, planning and reasoning, tool selection, natural language understanding, or error repair. Sparse activation allows the model to balance a larger parameter capacity against inference efficiency.

    The model supports a maximum output length of 128K tokens and has a context window of 200K tokens. A large context window, however, does not mean that the model can handle every long input with consistently high quality. Actual performance also depends on how the context is organized, where key information is located, how historical messages are compressed, and how task state is managed.

    In engineering practice, techniques such as summarization, hierarchical memory, state tables, and structured logs should still be used to limit the impact of irrelevant context on reasoning quality.

    3. Training Method: Reinforcing Continuous Execution Over Long Sequences

    During training, the model uses an agent-oriented asynchronous reinforcement learning method together with a dedicated agent training framework. Unlike traditional training that focuses only on the final answer, agent training places more weight on the entire execution process, including:

    • Whether the model correctly understands the user’s goal
    • Whether it creates a reasonable task plan
    • Whether it selects appropriate tools
    • Whether tool parameters meet the interface requirements
    • Whether it can adjust subsequent steps based on returned results
    • Whether it validates the results after completing the task
    • Whether it can avoid pointless repetition when an exception occurs

    Public information indicates that the model was trained on single sequences containing roughly 3,000 to 6,000 messages. The purpose of such training is to help the model adapt to interactions and execution processes that span longer time horizons, rather than only produce locally correct answers within a few turns. For scenarios such as scheduled tasks, continuous monitoring, batch processing, and complex workflow automation, long-sequence training helps improve the model’s ability to retain task state.

    Asynchronous agentic reinforcement learning also lets multiple task samples run in parallel. Feedback from different execution trajectories, including successes, failures, timeouts, and tool exceptions, can then be used to optimize the model’s policy. Compared with training only on static question-answer data, this approach is closer to real workflows and covers more uncertainty and exception paths.

    4. Key Capability Analysis

    4.1 Tool Calling

    Tool calling is one of the key capabilities that set agent models apart from ordinary conversational models. The model must not only decide whether a tool needs to be called. It must also determine the call order, the parameter format, and how to use the results.

    In complex tasks, a single request may go through multiple stages, such as information retrieval, data cleaning, code execution, file generation, and result validation. A parameter error in any one stage can cause the rest of the task to fail.

    The model therefore needs a clear sense of tool boundaries. It should know what each tool can and cannot do, and when it should stop calling tools.

    From an engineering perspective, we recommend the following:

    • Define a clear input and output schema for each tool.
    • Validate parameters strictly.
    • For high-risk operations, add human confirmation, permission checks, and idempotency controls. These measures prevent repeated execution from overwriting data or causing unintended business actions.

    4.2 Instruction Following and Command Tracking

    Instructions in a long-horizon task usually come in more than one form. A user might first state an overall goal, then add formatting requirements, time limits, or permission constraints. The model needs to distinguish core goals, temporary requirements, and prohibited actions, and stay consistent with them throughout execution.

    A good approach is to break the task into five categories of information:

    • Goal
    • Constraints
    • Current state
    • Completed steps
    • Pending items

    This structure helps the model understand the task. It also makes it easier for the system above it to audit and recover the task. When the user changes requirements, the system can clearly determine which steps can be kept and which must be rerun.

    4.3 Persistence and Scheduled Tasks

    Persistent tasks require the model to keep working toward its goal after a single interaction ends. Examples include:

    • Periodically checking certain types of data
    • Continuously tracking task progress
    • Triggering a follow-up action once a condition is met

    This capability cannot rely on the model alone. It also needs supporting system components, such as a scheduler, task queues, persistent storage, and monitoring and alerting. The division of responsibilities is as follows:

    • The model interprets the goal and generates an action plan.
    • The scheduling system wakes the task when needed.
    • The state store records progress.
    • The monitoring system detects timeouts and anomalies.

    A reliable mechanism for continuous execution is possible only when these components work together.

    4.4 Long-Horizon Tasks and Multi-Agent Collaboration

    A complex task can be completed by a single agent or split across multiple roles. For example, one agent could handle planning, another could gather and organize information, a third could validate the code, and a review agent could summarize the final results.

    Multi-agent collaboration can increase task parallelism, but it also introduces communication overhead, state consistency issues, and unclear ownership boundaries.

    When designing a multi-agent system, clearly define each role’s inputs, outputs, permissions, and completion conditions. This prevents multiple roles from duplicating work on the same task. Key results should also be independently validated, rather than simply stitching together the outputs of multiple models.

    5. Benchmarking: Look at the Process, Not Just the Answer

    Public information shows that the model outperformed the previous generation in internal evaluations focused on agent tasks. It also scored 93.9 on a global agent benchmark.

    Results like this should not be viewed as a single number in isolation. They should be analyzed alongside the following factors:

    • The types of tasks tested
    • The number of tools involved
    • Task length
    • Failure recovery mechanisms
    • Evaluation criteria

    A more complete set of evaluation metrics should include at least:

    • Final task completion rate
    • Tool call accuracy
    • The proportion of invalid and redundant calls
    • Instruction retention rate in long tasks
    • Recovery success rate after exceptions
    • Average execution latency and token consumption
    • Interception rate for high-risk operations
    • Result explainability and audit completeness

    In real production environments, canary testing and replay testing should also be conducted. Replaying historical tasks lets teams observe how the model behaves under different versions, tool states, and context lengths. This helps prevent teams from moving directly to production based on lab results alone.

    6. Security and Governance in Enterprise Deployment

    Agents with stronger execution capabilities also pose higher security risks. Enterprises should put at least the following mechanisms in place:

    1. Enforce least privilege. The model should only access the resources required for its current task. Sensitive data and high-risk operations should require separate authorization.
    2. Maintain an operation audit trail. Logs should be kept for all model inputs, tool calls, parameters, returned results, and final actions. These records support accountability, troubleshooting, and post-incident reviews.
    3. Add human confirmation. Actions such as transferring funds, deleting data, sending outbound messages, or changing production configurations should require final confirmation from a human.
    4. Set execution limits. Caps on the number of calls, runtime, maximum budget, and concurrency prevent the model from getting stuck in loops or consuming resources abnormally.
    5. Ensure data isolation. Contexts should be clearly separated between users, departments, and tasks, so that sensitive information is not mistakenly carried into other tasks.

    7. Deployment Recommendations and a Practical Path

    Enterprises should not start by putting the model directly into fully automated critical workflows. A phased rollout is more prudent:

    • Phase 1: Use the model for read-only tasks, such as retrieval, summarization, classification, and drafting reports.
    • Phase 2: Enable low-risk tools, such as file organization, data analysis, and code execution in test environments.
    • Phase 3: Introduce complex workflows, controlling risk through approval, rollback, and monitoring mechanisms.
    • Phase 4: Evaluate whether closed-loop automation is suitable within clearly defined boundaries.

    At the same time, the model’s capabilities should be combined with surrounding engineering systems. Context management, task queues, state databases, permission systems, logging platforms, and alerting systems are all essential parts of running long-horizon agents reliably. Even a highly capable model will struggle to meet enterprise-grade reliability requirements without proper state management and security controls.

    Conclusion

    Overall, this general-purpose large language model, optimized for agent scenarios, concentrates its technical efforts on long context, tool calling, sustained execution, and the coordination of complex tasks. It reflects a shift in the competition among large models, from parameter scale and single-turn performance toward real task completion rates and system-level execution capabilities.

    For developers, the key point is not the model’s parameters themselves. It is how to build an agent application system around the model that is observable, controllable, recoverable, and auditable.