LongCat 2.0: Meituan Trains a 1.6 Trillion Parameter LLM on Domestic Chips

A Food Delivery Company Disrupts the LLM Landscape

Just a few months ago, training a trillion-parameter model without NVIDIA GPUs or Google TPUs seemed nearly impossible. But that's quietly starting to change.

Meituan — best known for its food delivery and grocery services — has open-sourced a large language model called LongCat 2.0, featuring 1.6 trillion parameters and trained entirely without NVIDIA GPUs or Google TPUs.

Notably, the model had already been quietly available on OpenRouter under the codename "Owl Alpha," and many users who tested it found its capabilities quite impressive. This article breaks down exactly how Meituan pulled it off.

Why "Breaking Free from NVIDIA" Is a Big Deal

Virtually every frontier AI lab today uses NVIDIA hardware — not just for the raw speed and VRAM, but more critically for NVIDIA's battle-tested software ecosystem: CUDA.

CUDA (Compute Unified Device Architecture) is NVIDIA's parallel computing platform and programming model, launched in 2006. It's not just a programming interface — it's a complete ecosystem built over nearly 20 years, encompassing cuDNN (deep learning acceleration), NCCL (multi-GPU communication), cuBLAS (linear algebra), and dozens of other AI training tools. Tens of thousands of engineers worldwide have written optimized code around CUDA, and mainstream frameworks like PyTorch and TensorFlow are deeply coupled to it. This means any team trying to bypass NVIDIA must not only solve the compute problem, but rebuild the entire software supply chain — that's the real technical barrier.

What makes LongCat 2.0 remarkable is that Meituan completed training at this massive scale on custom chips with less VRAM and a far less mature software stack. The strategic implications are clear: if Chinese companies can reduce their dependence on NVIDIA, their models can not only close the capability gap but also scale without hardware constraints.

This aligns with what NVIDIA CEO Jensen Huang has argued — that chip export restrictions simply push China toward domestic hardware. ZhipuAI's GLM 5.2 had already blazed this trail, widely considered the first near-frontier model trained on Huawei chips, completely free from NVIDIA's hardware and software stack. LongCat 2.0 takes another step in the same direction.

Core Innovation: N-Gram Embeddings Instead of Stacking More Experts

Training a large model involves two budget dimensions: parameter count (how big the model is) and compute (how much computation each token requires).

The mainstream approach is to train larger models with more experts. Nearly all modern LLMs use Mixture of Experts (MoE) architecture — for each token, a router activates only a subset of "experts" in the network rather than routing the token through the entire network, improving efficiency. MoE was first proposed by Jacobs et al. in 1991 and has since been widely adopted by top models including GPT-4, Mixtral, and DeepSeek. The core idea is to replace the feed-forward layers of a neural network with multiple parallel "expert" sub-networks, with a lightweight router dynamically selecting a small number of experts (typically 2–8) per token at inference time. This allows the total parameter count to scale dramatically without a proportional increase in compute.

LongCat 2.0 has 1.6 trillion total parameters with 48 billion activated per token. But Meituan discovered a critical problem: simply adding more experts yields diminishing returns — as expert count grows, the router faces increasingly severe load balancing issues, with some experts overloaded and others nearly idle, causing effective network capacity to drop. The sparser the network, the worse the performance.

From Token Embeddings to N-Gram Embeddings

The breakthrough came from embeddings — the numerical representations of words or tokens, and a major source of parameter count. The conventional approach builds embeddings for individual tokens, but LongCat 2.0 instead constructs embeddings for N-grams (combinations of 2 to 5 words).

N-grams are a classic NLP concept referring to sequences of N consecutive words or characters in text. Before deep learning, N-gram language models were the dominant NLP paradigm. The idea of incorporating N-grams into modern Transformer embedding layers isn't entirely new — Meta's CANINE and ByteDance's MegaByte have both explored the value of multi-granularity representations. The core logic is that much of natural language meaning is carried by phrases rather than individual words (e.g., "machine learning," "artificial intelligence"), so assigning dedicated embedding vectors to high-frequency N-grams effectively "hard-codes" their compositional semantics into model parameters, reducing the computational burden on attention layers to infer those combinations.

This design provides richer contextual information. While the vocabulary can balloon from tens of thousands to millions or more, there are two clear advantages:

• Research has shown that scaling vocabulary through N-grams outperforms simply adding more experts;
• The dictionary lookup cost of embeddings is a highly parallelizable matrix operation, with far lower marginal cost than the routing overhead of training more experts.

In short, they traded "cheaper parameters" for better performance.

Making Expensive Long-Context Cheaper

Expanding N-grams introduced a new challenge: the cost of attention. Attention is essentially the model reviewing everything it has read so far to decide what to focus on next. Standard self-attention in Transformers has O(n²) time and space complexity — at context lengths of one million tokens, the compute and memory cost of revisiting the entire history for each new token becomes completely unacceptable.

The common fix is sparse attention — letting the model focus only on what matters. The research community has developed multiple strategies: Longformer introduced local sliding windows plus global tokens; BigBird combined random, local, and global attention; FlashAttention dramatically reduced VRAM usage through IO-aware block computation. DeepSeek introduced a related approach (DSA) with dynamic routing, deciding attention patterns in real time based on content.

But sparse attention has a hidden risk: it requires a "helper" to judge which parts are important, and that helper can itself become a bottleneck for speed and latency. LongCat's solution is to make this helper lighter, achieved in three steps:

• Read memory in regular, predictable block patterns rather than random jumps;
• Cache computation results across layers rather than recomputing each time;
• Do a coarse pass first, then a fine-grained one.

The throughline is consistent: make the most expensive parts of long-context processing cheaper. This is especially critical when running on bandwidth-constrained custom chips.

Speculative Decoding for Faster Inference

Beyond N-gram embeddings and sparse attention, LongCat 2.0 also incorporates Speculative Decoding, formally proposed by Google DeepMind in 2023. The workflow has two steps: first, a "draft model" that is 1–2 orders of magnitude smaller autoregressively generates several candidate tokens (typically 4–8); then, those candidates are fed in parallel to the main model for a single forward pass for verification — tokens matching the main model's probability distribution are accepted, and the first mismatch triggers resampling by the main model. Since the inference bottleneck in large models is memory bandwidth, verifying multiple candidates in parallel can increase effective throughput by 2–4×, while mathematically guaranteeing that the output distribution remains identical to the original model. In LongCat 2.0, N-gram embeddings naturally provide high-quality short-sequence prediction for the draft model, creating a synergistic gain that further reduces latency and improves throughput.

Hardware and Software Stack: The Real Moat

LLM workloads are typically divided into two phases:

• Prefill (processing the prompt): compute-intensive, demanding strong compute;
• Decode (generating the response): memory-intensive, demanding high bandwidth.

The differing hardware requirements between these phases provide architectural justification for using different ASIC configurations to handle each stage. ASICs (Application-Specific Integrated Circuits) are chips deeply customized at the circuit level for specific tasks, and can theoretically far outperform general-purpose GPUs in power efficiency and performance. Google's TPU is the most successful example of an AI training ASIC to date. However, using ASICs for LLM training presents far greater challenges than inference: training involves irregular gradient computations, dynamic graph execution, and frequent cross-node communication, demanding high programming flexibility — an area where ASICs are inherently weaker than GPUs.

Meituan's approach was to use custom ASIC chips tuned for different phases, completing the entire training process on over 50,000 custom AI chips with more than 35 trillion tokens of text. This meant solving a series of distributed training challenges — gradient synchronization across chips, pipeline parallelism, tensor parallelism — with all the relevant operator libraries and communication libraries built from scratch.

But what's truly impressive isn't the hardware itself — it's the software stack they had to build from the ground up. NVIDIA's deepest moat is precisely the CUDA ecosystem accumulated over many years. The most remarkable story behind LongCat 2.0 is building the complete software infrastructure to train a network at this scale, entirely without NVIDIA.

Benchmark Results and Industry Implications

In terms of results, LongCat 2.0 is a genuinely competitive model, capable of going head-to-head with mainstream offerings from OpenAI, Google, and Anthropic. That said, the numbers currently available are all official internal benchmarks, which — as with other labs — carry some degree of optimization for the evaluation itself.

The real story isn't in the benchmark numbers, but in the fact that a previously relatively low-profile lab produced such a competitive model.

In hands-on testing, the author used a challenging prompt: "Create a real-time 3D ISS (International Space Station) orbital tracker using a free API to get its position." After a brief thinking phase, the model quickly began generating code at a smooth pace. After a few rounds of corrections, the final rendered ISS was satisfying — the movement speed was slightly fast and may not reflect precise real-time coordinates, but the overall experience exceeded expectations.

LongCat 2.0 currently supports text input only and can be tried directly at longcat.chat, with competitive API pricing. Model weights will soon be uploaded to Hugging Face — consistent with the broader trend among recent Chinese open-source models.

Conclusion

The core signal from LongCat 2.0 is that more and more teams are breaking free from NVIDIA dependency. Scaling trillion-parameter models without NVIDIA GPUs or Google TPUs is moving from "unimaginable" to reality.

Following GLM 5.2, LongCat 2.0 further validates the viability of the domestic chip route. More algorithmic and optimization innovations from Chinese labs are sure to follow. This isn't just a divergence in technical approaches — it could profoundly reshape the competitive landscape of global AI compute.