Meituan has released the trillion-parameter model LongCat-2.0, along with inference code for domestic GPUs.

Today (July 6), Meituan officially dropped LongCat-2.0 — a 1.6T total-parameter MoE model with an average activation of around 48B. The weights, multi-precision versions, and inference code optimized for domestic computing hardware have all been fully open-sourced at once.

Strictly speaking, this is not its first appearance. LongCat-2.0 was already announced on June 30. Before that, it had been running in gray-scale testing on OpenRouter under the codename "Owl Alpha." According to Meituan, its monthly call volume had already entered the global top three, behind only Hermes and Claude Code. Today’s release packages together the training results and inference optimization code for domestic GPUs, making it clear they were building up to a major move.

First, the conclusion: how strong is this model really?

Let’s go straight to the programming benchmark scores it published itself:

• SWE-bench Pro: 59.5, surpassing Gemini 3.1 Pro (54.2), GPT-5.5 (58.6), and Claude Opus 4.6 (57.3)
• SWE-bench Multilingual: 77.3, essentially tied with Claude Opus 4.6 (77.8)
• Terminal-Bench 2.1: 70.8, focused on real terminal command interaction
• BrowseComp: 79.9, RWSearch: 78.8, FORTE: 73.2

These numbers stand out sharply. SWE-bench Pro is widely regarded this year as the hardest engineering benchmark, and until now there have been almost no open-source models capable of surpassing both GPT-5.5 and Claude Opus 4.6 together. Of course, benchmarks are benchmarks; real-world experience still depends on community feedback over the next couple of weeks. But at minimum, Meituan did not misplay its hand this time.

One result worth highlighting separately is the 70.8 on Terminal-Bench 2.1. This benchmark evaluates whether a model can continuously execute commands in a real terminal environment and self-correct after encountering errors — arguably the toughest requirement for practical Agentic Coding deployment. Previously, only a handful of closed-source models had crossed 70.

Architecture: a three-piece stack designed for Agentic Coding

The architectural direction of LongCat-2.0 is very clear: instead of building a general-purpose “can do everything” model, it focuses intensely on Agentic Coding scenarios. The core consists of three major components:

1. LongCat Sparse Attention (LSA)

Native support for 1M context length. Traditional dense attention starts suffering from “selective amnesia” after around 100K tokens. LSA reduces computational complexity from quadratic to linear scale. Conceptually, it resembles the NSA approach proposed earlier by DeepSeek — instead of “reading every word,” it selectively reads key blocks.

What does this mean for Agent scenarios? A medium-sized project’s entire codebase (say, around 300,000 lines) can finally fit into context all at once. The Agent can “see” the full project structure before acting, instead of relying on fragmented RAG stitching. This has been one of the biggest bottlenecks in Agentic Coding over the past six months.

2. Zero-Compute Experts + ScMoE

Dynamic activation range: 33B–56B. The key insight here is that token complexity varies enormously in coding tasks. Writing a line like import numpy as np and deriving a dynamic programming state transition equation require completely different levels of “brainpower.”

The zero-compute expert approach routes simple tokens directly to zero experts, skipping actual computation and unnecessary communication. Only complex tokens invoke the full expert resources. This idea appeared in research papers in late 2024; Meituan’s contribution this time is scaling it to the trillion-parameter level and actually making it work in production.

3. MOPD Architecture: Agent / Reasoning / Interaction Expert Groups

• Agent Experts: specialized in tool usage and autonomous error correction
• Reasoning Experts: mathematics and STEM reasoning
• Interaction Experts: instruction following and interaction quality

Explicitly distributing “capabilities” into different expert groups is still not mainstream in the industry. Most MoE systems let routing learn everything on its own. Meituan’s design effectively adds inductive bias to the router. Whether this is fundamentally the right direction remains unclear, but based on the benchmark results, it certainly does not seem harmful.

4. N-gram Embedding

Introduces n-gram information into token-level representations, enabling more nuanced understanding of “compound semantic units” such as variable names and function names in code.

The real headline: a trillion-parameter model trained on a 50,000-card domestic cluster

Beyond the benchmark scores, the more significant aspect of LongCat-2.0 is that it is the industry's first trillion-parameter model to complete full-process training and inference on a 50,000-card domestic computing cluster.

Pretraining exceeded 30T tokens, with stable throughput reaching 1T tokens per day. Meituan’s team has been working on domestic accelerators since 2023, and this release includes several key metrics:

• Stability: inter-card communication anomaly handling, elastic scaling, automatic fault recovery; average daily failure rates reduced by over 70%
• Correctness: deterministic operators and bitwise consistency validation
• Efficiency: training MFU improved by 1.5×

For China’s AI industry, this signal may matter more than the model itself. For the past two years, a major unresolved question has been whether domestic accelerators can truly support training trillion-scale MoE models from scratch. Most publicly demonstrated cases previously stayed below the hundred-billion-parameter range or relied on continued training from existing models. Meituan has now completed both “pretraining + inference” entirely on domestic clusters, effectively giving the industry a clear answer.

Open-source commitment: genuinely generous this time

All precision variants are being released together:

• BF16: preferred for mainstream high-end GPUs
• FP8: the sweet spot for next-generation hardware
• INT8: a lifesaver for VRAM-constrained scenarios

More importantly, inference code deeply optimized for domestic accelerator chips is also being open-sourced simultaneously. That means users can run it directly on existing domestic hardware without waiting for community reverse engineering. For enterprise users, this solves a major pain point: previous open-source trillion-parameter models often released only “weights,” without deployment solutions that could actually run — especially on domestic hardware, where teams usually had to figure things out themselves.

Inference-side optimizations include:

• Large-scale expert parallel aggregation memory bandwidth optimization for low-latency trillion-scale MoE decoding
• Integrating zero-compute experts into EP communication pipelines, allowing tokens routed to zero experts to skip transmission entirely
• Scheduling optimizations for communication, Attention, and GEMM core operators
• Pre-dispatch and weight prefetching to reduce waiting overhead

Compared with competitors, where does LongCat-2.0 sit?

A quick horizontal comparison with current open-source competitors:

| Dimension | LongCat-2.0 | Latest DeepSeek | Qwen 3 Max | |------|-------------|---------------|------------| | Total Parameters | 1.6T | ~700B class | ~1T class | | Context Length | 1M | 128K+ | 256K | | SWE-bench Pro | 59.5 | Around 55 | Around 56 | | Primary Focus | Agentic Coding | General reasoning | General + multimodal | | Domestic GPU Inference | Officially open-sourced | Requires adaptation | Requires adaptation |

LongCat-2.0’s differentiation strategy is very clear: it is not chasing all-around dominance. Instead, it is relentlessly focused on Agentic Coding while also fully addressing domestic compute infrastructure. That strategy makes sense — the race for first place on general-purpose leaderboards is already overcrowded, whereas deeply owning a sufficiently large niche may be more effective.

Real-world applications: not just code generation

Several internal use cases shared by Meituan are particularly interesting:

• AI SQL Agent: business users query data in natural language; the model automatically handles intent understanding, query planning, and result interpretation
• Enterprise-level complex tasks: multi-step planning + tool usage + long-range retrieval
• Code refactoring: AI-driven refactoring practice on a 310,000-line codebase (previously discussed by Meituan’s engineering team)

The term “Agentic Coding” is now somewhat overused, but LongCat-2.0’s definition is relatively precise — not Copilot-style inline completion, but a full autonomous agent loop capable of receiving a vague requirement, planning independently, invoking tools, correcting itself, and completing tasks autonomously. The combination of 1M context and 70+ Terminal-Bench capability is what makes that claim credible.

Practical questions developers care about

How many GPUs are needed to run it? Inference for a trillion-scale MoE is not cheap. Full BF16 deployment requires at least eight 80G H-series GPUs; FP8 can reduce that to four; the INT8 version can theoretically start with 2–3 GPUs, though latency suffers. For domestic hardware, the exact configurations should follow recommendations from Meituan’s open-source repository.

Compatible with Claude Code? The official release explicitly mentions compatibility with interfaces used by mainstream developer tools such as Claude Code, meaning existing Agent workflows can migrate with minimal friction.

On the OpenAI Hub side, we plan to integrate LongCat-2.0 once the weights and inference pipeline are stable. At that point, developers will be able to invoke it using the same API key alongside GPT-5.5, Claude Opus 4.6, and Gemini 3.1 Pro for direct side-by-side testing. Developers who want immediate access can also pull the weights directly from Meituan’s open-source repository and deploy it themselves.

Worth paying attention to — but don’t rush to overhype it

A few sober observations to close:

• The benchmark scores look impressive, but the SWE-bench family has long faced accusations of “overfitting”; better to wait for a week or two of private benchmark testing from the community
• The “effective” utilization of 1M context still needs verification — not all sparse attention systems maintain accuracy over ultra-long ranges
• Inference costs for trillion-scale models remain too high for many teams; smaller players may still prefer models in the 100B range
• Running training successfully on domestic accelerators is a milestone, but the ecosystem maturity gap versus CUDA still exists

That said, the fact that the AI team of a food delivery company trained a trillion-parameter model from scratch on domestic hardware and surpassed GPT-5.5 on coding benchmarks is, by itself, something worth everyone’s serious attention.

References

• ITHome: Meituan open-sources trillion-parameter model LongCat-2.0, simultaneously releasing domestic GPU inference code - Core open-source information and multi-precision version details for LongCat-2.0
• Zhihu: Meituan officially releases LongCat-2.0: a trillion-parameter model fully trained and inferred on a domestic computing cluster - Complete technical architecture, training details, and benchmark data