Meituan’s LongCat 2.5 Bets on Long-Horizon Agents

Meituan’s LongCat API open platform launched LongCat-2.5-Preview on September 25, simultaneously opening access via API and a web interface.

The keywords for this update are not simply “bigger,” but long-horizon tasks, multimodal understanding, and coding. The model retains a Mixture-of-Experts (MoE) architecture, with approximately 1.6 trillion total parameters and around 48 billion parameters activated per inference. It natively supports a context window of 1 million tokens, adds image-understanding capabilities, and has been adapted for development environments such as Claude Code, OpenCode, and Kilo Code.

From a product-positioning perspective, LongCat-2.5-Preview is no longer trying merely to “answer a question.” Instead, it aims to enable models to continuously advance a task over longer periods and within larger contexts. It targets agent workflows such as codebase refactoring, complex document analysis, and multi-tool collaboration.

1.6T Parameters, but Only 48B Are Actually Used in Computation

LongCat-2.5-Preview has approximately 1.6 trillion total parameters, but it follows the MoE approach. When processing each token, the model does not invoke all its parameters. Instead, a routing mechanism selects a subset of expert networks, activating around 48 billion parameters on average.

It can be understood as a consulting firm with numerous specialist teams: the company is large, but when dealing with a specific problem, it does not need every employee to attend the same meeting. Instead, it assembles the teams most relevant to the task.

The advantages of this architecture are straightforward:

• The total parameter capacity can continue to expand, accommodating more knowledge and capabilities;
• A single inference does not incur the full computational cost of a 1.6T-parameter dense model;
• Different experts can separately specialize in coding, reasoning, tool use, or domain-specific capabilities;
• It attempts to control inference costs and latency while maintaining overall model capacity.

However, it is important to note that 1.6T total parameters does not mean every request receives the computational capability of a 1.6T-parameter dense model. When evaluating an MoE model, developers should not focus solely on total parameter count. They should pay greater attention to active parameters, routing performance, actual throughput, long-context degradation, and task completion rates.

At this stage, the publicly available official information mainly consists of capability descriptions. Sufficiently comprehensive third-party evaluations, API pricing, and latency data across different context lengths are still unavailable. Therefore, “1.6T” is better regarded as an indication of architectural scale rather than a scorecard that directly represents performance.

The Value of One Million Tokens Is Not in Stuffing Every File Into the Prompt at Once

LongCat-2.5-Preview natively supports a context window of 1 million tokens, allowing it to accommodate extremely long documents, code repositories, logs, and extensive conversation histories. This capability is more important for agents than it is for ordinary chat scenarios.

For example, when asked to modify a large project, the model may need to read all of the following simultaneously:

1. The project directory and dependencies;
2. Source code from multiple modules;
3. API documentation and database schemas;
4. Test failure logs;
5. The team’s coding standards;
6. Execution results left by previous rounds of operations.

Traditional short-context models must constantly compress, split, or discard information. With a context window expanded to 1 million tokens, an agent can retain more working information throughout a task, reducing the information loss caused by repeated retrieval and summarization.

However, a 1-million-token context window does not mean that all 1 million tokens can be used with equal accuracy. Long-context systems still face several practical challenges:

• The longer the input, the higher the time to first token and invocation cost typically become;
• Critical information may be buried under large amounts of irrelevant content;
• A model being able to “see” a piece of code does not mean it can accurately establish cross-file dependencies;
• Early errors in long-running tasks may continue to compound in subsequent steps;
• The attack surface for prompt injection and sensitive-data leakage also expands.

Therefore, a genuinely practical engineering solution typically does not eliminate RAG. Instead, it combines long context with retrieval, code indexing, access controls, and context compression. The context window is like a larger workbench, but developers must still decide which materials belong on it.

Added Visual Understanding Opens the Door to Multimodal Tasks

LongCat-2.5-Preview adds image-understanding capabilities that can be used for image-content analysis, cross-modal question answering, image summarization, and complex visual reasoning.

This upgrade enables it to participate in more real-world workflows. Developers can give the model error screenshots, architecture diagrams, product prototypes, data dashboards, and scanned documents directly, without first relying on OCR or manual transcription.

In coding scenarios, visual capabilities are particularly suitable for tasks such as:

• Locating CSS or layout issues from webpage screenshots;
• Reading error dialogs and troubleshooting problems in conjunction with a code repository;
• Generating frontend pages from product prototypes;
• Understanding architecture diagrams, flowcharts, and entity-relationship diagrams;
• Comparing an implementation against a design mockup to identify discrepancies.

This moves LongCat-2.5-Preview beyond a primarily text-and-code model and brings it closer to a complete software-engineering agent. However, officials have not yet disclosed the supported image-input resolution, the number of images allowed per request, visual-token pricing, or benchmark results for specialized charts and diagrams. Applications that need to read small-text tables, complex scientific images, or dense interfaces should still conduct targeted testing first.

The Key to Coding Capability Is Whether It Can Keep Going Until the Task Is Finished

LongCat-2.5-Preview officially positions coding as one of its core capabilities, emphasizing its performance in code generation, code comprehension, and automated programming tasks. The model has also been adapted for development environments such as Claude Code, Hermes, OpenClaw, OpenCode, and Kilo Code.

The signal here is clear: LongCat does not merely want to be a web-based chat model. It aims to enter the agent toolchains that developers already use.

For programming models, generating a single function is no longer particularly difficult. What truly differentiates them is their capacity for long-horizon execution, such as:

• Searching the codebase before determining which files need to be modified;
• Maintaining interface consistency across multiple files;
• Invoking terminal, testing, and static-analysis tools;
• Continuing to fix issues based on error results;
• Avoiding changes to unrelated code;
• Continuing to follow the original task requirements after dozens of steps.

Such tasks are more like asking the model to independently complete an engineering ticket than having it sit an algorithm exam. A 1-million-token context window, MoE model capacity, and integration with development tools do indeed form a sensible technical combination.

However, the most important factor to observe during the Preview stage is precisely the model’s stability in real repositories: whether it can invoke tools correctly, adjust its plan after encountering failures, avoid drifting away from its objective during long-running tasks, and produce patches that pass tests. Without such data, claims of “outstanding coding capabilities” alone are insufficient to determine whether it can replace mature Claude, GPT, or Gemini programming workflows.

The API Is Available, but Three Types of Testing Should Come First

The LongCat-2.5-Preview API is now available. Because it is a preview model provided through the official service, developers can integrate it using an OpenAI-compatible client. If the corresponding model route has already been enabled in the OpenAI Hub console, the existing OpenAI format can also be used.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="YOUR_OPENAI_HUB_ENDPOINT"
)

response = client.chat.completions.create(
    model="LongCat-2.5-Preview",
    messages=[
        {
            "role": "user",
            "content": "Analyze this project's module dependencies and propose a refactoring plan."
        }
    ]
)

print(response.choices[0].message.content)

The model name and multimodal message format should follow the actual console configuration. Before integrating it into a production environment, developers should focus on testing three categories of metrics:

• Long-context effectiveness: Place critical facts at the beginning, middle, and end of the context to test whether the model can locate them reliably;
• Agent completion rate: Record whether tasks actually pass tests, rather than merely evaluating whether the responses appear reasonable;
• Cost and latency: Test inputs of 10K, 100K, and longer lengths separately to avoid being misled by the maximum context-window figure.

If the application involves code execution, terminal permissions should also be restricted, the runtime environment should be isolated, and approval mechanisms should be established for file writes, network access, and dangerous commands. The more capable the model and the longer the execution chain, the more important permission boundaries become.

Meituan Is Competing to Become the Gateway for Chinese Agent Models

LongCat-2.5-Preview is competing not only with Chinese general-purpose chat models, but also with Claude, GPT, Gemini, and a range of models specifically designed for coding agents.

Its most distinctive differentiator is currently its concentrated bet on long-horizon agents through a combination of 1.6T-parameter MoE architecture, 48B active parameters, a 1-million-token context window, multimodality, and development-tool integration. This direction is more pragmatic than continuing to chase positions on chatbot leaderboards, because developers ultimately pay not for parameter counts, but for task completion rates, stability, and controllable costs.

For Meituan, this also aligns with its engineering background. Complex business systems, massive codebases, and long-running automated processes are themselves ideal environments for validating agent models. If LongCat can transform its internal engineering capabilities into a stable external API, it may secure a clear position in China’s programming-model market.

For now, however, it remains a Preview. The boundaries of its visual capabilities, its actual long-context performance, tool-use stability, pricing, and service concurrency all require further disclosure. LongCat-2.5-Preview appears to have assembled the key components required for a long-horizon agent. Its next task is to prove that these components can work together in real-world projects, rather than merely appearing together on a feature list.

References

• ITHome: Meituan Launches the LongCat-2.5-Preview Model—Introduces the model’s launch date, MoE parameter scale, 1-million-token context window, visual capabilities, and development-tool integrations.
• AI-Compass: Overview of the LongCat Series’ Technical Background—Summarizes the MoE architecture, long-context capabilities, and adaptation to Chinese computing hardware in earlier LongCat versions, providing background on its technical direction.