Meituan Releases LongCat-2.0: A 1.6T-Parameter Open MoE Model with Native 1M Context and LongCat Sparse Attention

Meituan has released LongCat-2.0, an open-source Mixture-of-Experts language model containing 1.6 trillion total parameters and activating approximately 48 billion per token. The system is designed for agentic coding, handling code understanding, generation, and execution within automated workflows. It supports a native context window of one million tokens and was trained and served entirely on domestic AI ASIC superpods, avoiding Nvidia hardware.

What is LongCat-2.0?

This release follows LongCat-Flash, a 560-billion parameter model introduced in September 2025. Pretraining consumed more than 35 trillion tokens across millions of accelerator-hours. Meituan reports no rollbacks or irrecoverable loss spikes during the process, a claim of stability that is particularly relevant for non-Nvidia hardware where tooling remains less mature.

Architecture and efficiency

The design combines four techniques to reduce the cost of scale. Each component addresses a specific bottleneck in running large models.

• Zero-computation experts: Simple tokens, such as punctuation, route to a zero-computation expert and return unchanged. Complex tokens engage more expert capacity. A PID controller adjusts expert bias to hold the average activation in a dynamic window of 33 billion to 56 billion parameters, rather than using a fixed cost. The MoE backbone uses a shortcut-connected design (ScMoE) for higher throughput.
• LongCat Sparse Attention (LSA): Standard attention scales quadratically with context length. LSA selects only the most relevant tokens, dropping the scaling closer to linear. Meituan describes it as an evolution of DeepSeek Sparse Attention (DSA). It layers three orthogonal indexing methods. Streaming-aware Indexing turns fragmented memory reads into contiguous blocks. Cross-Layer Indexing reuses attention saliency across adjacent layers. Hierarchical Indexing applies coarse-to-fine two-stage filtering. Together they sustain the 1M-token window without a memory wall.
• N-gram Embedding: The design adds a 135-billion-parameter N-gram embedding module. It sits orthogonal to the MoE experts in sparse dimensions. Meituan says it captures dense local token relationships and reduces memory I/O during large-batch decoding.
• Post-training (MOPD): A dedicated pipeline fuses three teacher expert groups. These cover Agent, Reasoning, and Interaction capabilities into one unified model.

For serving, Meituan uses a 6D parallelism scheme and a prefill-decode disaggregated architecture. It also employs ‘super kernels’ and L2-cache weight prefetching to hide I/O latency.

Benchmarks

Meituan positions LongCat-2.0 as an agentic coding model. Every figure below comes from Meituan’s own testing.

On SWE-bench Pro, Meituan reports LongCat-2.0 edging GPT-5.5 (58.6). Meituan also claims overall performance comparable to Google’s Gemini 3.1 Pro. The reported edge is concentrated in software engineering. On broader general-agent benchmarks such as FORTE and BrowseComp, coverage indicates it trails leading frontier systems. Independent leaderboard confirmation is not yet available.

Comparison with LongCat-Flash

The jump from the previous generation is large on paper. This table uses each model’s published specifications.

Use cases with examples

LongCat-2.0 is tuned for agent-style software work, not casual chat. A few concrete patterns fit its strengths.

• Whole-repository reasoning: Feed an entire mid-sized codebase into the 1M-token window. Ask the model to trace a bug across many files at once. This avoids the summarization hacks that shorter windows force.
• Multi-step terminal tasks: Run the model inside an agent loop with shell access. It can execute commands, read errors, and retry until a task passes. The Terminal-Bench 2.1 focus targets exactly this workflow.
• Repository-level edits: Ask for a refactor that spans several modules and tests. The model reasons over the full context before proposing coordinated changes.
• Cross-language migration: Use the SWE-bench Multilingual strength for polyglot repositories. The model can port logic between languages while preserving behavior.

These patterns run inside standard agent harnesses. Dev teams can therefore adopt the model without building new tooling.

How to access it

LongCat-2.0 is reachable through the LongCat API Platform. It exposes both OpenAI-compatible and Anthropic-compatible endpoints. The model is also on OpenRouter and in harnesses like Claude Code, OpenClaw, OpenCode, and Codex. Local self-hosting is not yet possible, since weights remain pending.

The OpenAI-compatible endpoint uses the model ID LongCat-2.0. Maximum output length is 131072 tokens (128K). The snippet below calls the documented chat-completions endpoint.

# pip install openai
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_LONGCAT_API_KEY",
    base_url="https://api.longcat.chat/openai/v1",
)

resp = client.chat.completions.create(
    model="LongCat-2.0",
    messages=[
        {"role": "system", "content": "You are a coding agent."},
        {"role": "user", "content": "Refactor utils.py to remove duplicate I/O logic."},
    ],
    max_tokens=4096,  # LongCat-2.0 supports up to 131072 (128K)
)

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

Pricing is reported at $0.75 per million input tokens and $2.95 per million output. A launch promotion lists $0.30 and $1.20, with cached context reads free. These figures come from third-party coverage and may change.

What it means

Developers can now run complex codebase analysis without summarising files into summaries first. The 1M-token window allows a single pass over a full repository. Local teams using domestic hardware can train and serve the model without relying on Nvidia GPUs.