Meituan LongCat-2.0 Open Source: Trillion-Parameter Effort Focused on Agentic Coding

Meituan officially released and open-sourced LongCat-2.0 today. It has been exactly two months since the quiet Preview beta test back in April.

This is a 1.6 trillion total parameter MoE model, with an average activation of around 48 billion, a dynamic range between 33B and 56B, natively supporting 1M context length. But the numbers aren’t the most noteworthy thing today—what’s worth talking about are two points: First, it’s the industry’s first trillion-parameter model to run the entire pipeline from pretraining to inference on a 50,000-card domestic compute cluster; Second, its architecture design was aimed squarely at Agentic Coding from day one.

A food delivery company open-sourced a trillion-parameter model

This needs some backstory.

When Meituan open-sourced LongCat-Flash in September last year, the reaction was basically: “Oh, a 560B parameter MoE with a zero-compute expert mechanism—interesting—but compared with DeepSeek and Qwen, not particularly eye-catching.” At the time, people were more concerned whether Wang Xing was serious about upgrading the Meituan app into an AI-powered app, or just telling a nice story.

The answer came four months later. On April 20th this year, the LongCat.ai changelog quietly listed LongCat-2.0-Preview, with no announcement, no technical report, just three lines: targeted at Agent development, good at code generation and automated workflows, deeply integrated with Claude Code, OpenClaw, OpenCode, and Kilo Code. Offering 10 million free tokens per day, invite-only beta.

Media leaks caught up several days later: parameters over a trillion, MoE, 1M context, 50–60 thousand domestic cards, zero NVIDIA share.

And today, with model weights officially open-sourced and the technical report released, Meituan has taken its parameter count from 560B in Flash to 1.6T in just nine months—and completely removed NVIDIA from its supply chain. This pace is uncommon in China’s large model scene—usually such parameter jumps come with stories of large H100 cluster purchases.

1.6T isn’t just stacking—it’s “adapting”

To understand LongCat-2.0’s engineering value, you have to acknowledge an awkward reality: domestic accelerator cards have single-card HBM capacity of about 60GB, NVIDIA H800/H100 is 80GB; bandwidth is even further behind; and CUDA’s 20-year moat isn’t bridged in a year or two.

Training a trillion-parameter model on this hardware is like fitting a business-class passenger into economy-class legroom—you have to work at the system design level. The LongCat-2.0 team’s key decisions are worth noting:

N-gram Embedding: Moving part of the FFN expert layers’ parameters forward into the embedding layer, introducing phrase-level modeling. High-frequency language patterns hit directly without full MoE routing. The point isn’t “smarter,” but to reduce cross-node communication overhead—the most expensive part of trillion-parameter modeling is always the all-to-all communication across tens of thousands of cards. If HBM bandwidth isn’t enough, then minimize the traffic that needs the bandwidth.

Lightweight sparse attention + cross-layer flow-aware indexing: Native 1M context with full attention would blow up memory. The team sparsifies and reuses across layers to avoid redundant computation. This is conceptually similar to DeepSeek’s NSA and Kimi’s MoBA, but getting it stable at trillion scale is an order of magnitude harder.

Deterministic FAG operators + Scatter operator rewrite: Controlled performance loss within 5%, and Scatter-type operator speedups by tens of times. This is pure grunt work—no CUDA kernels to copy—had to be written from scratch.

Fault tolerance and recovery: Link awareness, automatic rescheduling, multi-layer anomaly detection. Running tens of thousands of cards for months without dropping a link is tough even on NVIDIA clusters; on domestic cards, it means rewriting the entire stack—PyTorch + NCCL + scheduler.

Put together, LongCat-2.0’s real value isn’t parameters—it’s an engineering manual for training trillion-parameter models on domestic compute infrastructure. In this sense, it complements DeepSeek V3/V4: DeepSeek pushes model limits via algorithmic efficiency, Meituan advances engineering limits via hardware adaptation.

The real bet: Agentic Coding

Now back to the model’s positioning.

LongCat-2.0 is not a general chat model—its architecture was chosen from day one to serve Agentic Coding. This is the most crowded and critical track in 2026—the market Claude 4.5, GPT-5.5, and Gemini 3 are all chasing.

Meituan’s logic for this path is straightforward:

• 1M context is hard currency for Agent tasks: Reading an entire monorepo, tracking dozens of tool call logs, maintaining a multi-hour task state—all impossible without million-level context.
• MoE dynamic activation fits the non-uniform load of Agents: In an Agent pipeline, planning, coding, and debugging phases demand vastly different model abilities; 48B average activation with 33B–56B dynamic adjustment is far more efficient than dense models.
• Deep integration with Claude Code, OpenClaw, OpenCode, Kilo Code: This says more than any technical report—Meituan isn’t building LongCat to replace ChatGPT for chatting, but to give your coding Agent a domestic brain.

According to the official capability map, LongCat-2.0 has native optimization for tool invocation, multi-step reasoning, and complex instruction execution. The real value of these optimizations needs verification via Agent benchmarks like SWE-bench Verified, Terminal-Bench, and TAU-bench. The technical report provides comparative data—significant improvement over Flash in coding tasks—but head-to-head with Claude Sonnet 4.5 and GPT-5.5 in Agentic scenarios will need third-party community tests.

Open source strategy: this time it’s real open source

Back in April, only APIs were released—no weights—prompting criticism for “quiet release, no announcement, no open source.” This time, Meituan delivered everything owed:

• Complete model weights open-sourced, with license permitting commercial use per official announcement
• Technical report released in sync, covering training framework, operators, fault tolerance systems, and other engineering details
• LongCat.ai platform continues free API quotas, for developers who prefer direct integration over self-deployment
• Hugging Face release in sync, enabling community fine-tuning and quantization

By 2026, this approach—weights + report first, letting the community build the ecosystem—was already a tacit norm shared by DeepSeek and Qwen. For developers, self-deploying a 1.6T model is extremely challenging, but 4-bit quantized, distilled, and various LoRA versions will quickly emerge in the community.

If you don’t want to bother with local deployment, OpenAI Hub has also integrated LongCat-2.0—in OpenAI-compatible format, like GPT-5.5, Claude 4.5, and DeepSeek V4—allowing quick switching with one key, accessible from within China.

Some judgments

A few attitude points.

First, LongCat-2.0’s real weight lies in engineering, not SOTA. If you only look at benchmark scores, it likely won’t blow you away—Claude 4.5 and GPT-5.5’s lead in Agentic Coding is unlikely to be challenged short-term. But if you care about “whether and how trillion-parameter models can run on domestic chips,” this open-source release is far more valuable.

Second, Meituan’s move is an industry play, not an academic one. 1.6T, 50,000 cards, domestic compute—each number has capital expenditure behind it. Wang Xing said in 2024 they’d invest billions to secure compute—and now the results are on the table: Meituan isn’t treating large models as a side business, they’re actually building infrastructure-level capability. Given the massive real-life Agentizable scenarios in food delivery, local services, travel and hospitality, the business logic is closed-loop.

Third, the domestic compute story has reached a new inflection point. In recent years, “domestic replacement” was more of a posture; in the first half of 2026—DeepSeek’s algorithm breakthroughs plus Meituan’s engineering breakthroughs—made it an executable engineering path. This doesn’t mean NVIDIA is useless, but it does mean if export controls tighten further, leading domestic companies now have a Plan B.

Fourth, should developers use it? If you’re building a Coding Agent toolchain, LongCat-2.0 is worth running—especially since native integration with tools like Claude Code and OpenCode is already done, keeping migration cost manageable. If you’re just making general chat apps, its value ranking comes after GPT-5.5 and Claude 4.5. Model choice isn’t about parameters—it’s about scenarios.

The trillion-parameter open-source wave in 2026 keeps pushing forward. LongCat-2.0 won’t be the endpoint, but it has moved “trillion-parameter model on domestic compute” from PPT to GitHub.

References

• ITHome: Meituan trillion-level large model LongCat-2.0-Preview open for testing – Early coverage during April’s beta, including compute scale disclosure
• Hugging Face: LongCat model repository – Official Meituan model weights and technical docs
• GitHub: LongCat project homepage – Inference code, deployment scripts, and community issue tracking
• Juejin: LongCat-Flash technical interpretation – Summary of domestic compute training experience for the first-generation LongCat-Flash
• Zhihu: Engineering practice discussion on trillion-parameter MoE models – Community technical analysis of N-gram Embedding and sparse attention