meituan-longcat/LongCat-2.0

TL;DR: Meituan's LongCat-2.0 is a 1.6T-parameter MoE (~48B active) trained on 35T+ tokens, released under MIT, with two ideas worth your attention: LongCat Sparse Attention (LSA), a hardware-aware sparse-attention design that fixes real bottlenecks in DeepSeek-style indexed attention and enables training on hundreds of billions of 1M-context tokens, and the quietly enormous claim that the entire frontier-scale run — training and deployment — happened on AI ASIC superpods, not NVIDIA GPUs, with no rollbacks or loss spikes.

What it is

This is Meituan's frontier-scale successor to the LongCat-Flash line: 1.6T total parameters, ~48B activated per token, pretrained on 35T+ tokens across "millions of accelerator-days." Post-training targets coding and agentic work, with integration into Claude Code, OpenClaw, and Hermes harnesses. Weights are MIT-licensed — genuinely permissive, no custom-license gotchas — which at this scale is still uncommon.

The README is a summary; the details live in a linked tech blog. What follows is what the README itself says.

LongCat Sparse Attention

LSA is the most interesting technical content. It's a response to concrete problems with the Lightning Indexer in DeepSeek Sparse Attention (DSA): output discontinuity and a quadratic scoring bottleneck. Three orthogonal fixes:

• Streaming-aware Indexing (SI): reshapes the token-selection budget to mix contiguous, hardware-aligned block access with dynamic random selection — turning fragmented KV-cache reads into coalesced sequential HBM access.
• Cross-Layer Indexing (CLI): exploits the empirical stability of attention saliency across adjacent layers. One indexing pass serves multiple consecutive layers at inference (every 2 layers in the target model), enabled by cross-layer distillation during training rather than just hoping it holds.
• Hierarchical Indexing (HI): coarse-to-fine scoring — block-level approximate recall first, then token-level selection within recalled candidates — shrinking the quadratic indexer's candidate space.

All three extend to the 3-step multi-token-prediction module for speculative decoding, where all three draft steps share a single indexing pass.

The other architectural note: 135B parameters of N-gram Embedding (inherited from LongCat-Flash-Lite), framed as expanding parameters along a sparse dimension orthogonal to MoE. Their stated rationale — MoE sparsity has "crossed the sweet spot," so additional capacity is better spent on n-gram tables than more experts — is a scaling claim worth checking against the blog. If it holds up, it's a useful counterpoint to reflexively scaling expert count.

Evidence

In-house evals (unified harness, asterisked numbers cited from official reports) put it in the same neighborhood as current proprietary frontier models on code-agent benchmarks, behind on knowledge/reasoning:

The pattern: competitive on SWE-bench Pro (59.5, beating GPT-5.5's cited 58.6), solid on Terminal-Bench, clearly behind the frontier on GPQA-diamond (88.9 vs 93–94) and IMO-AnswerBench. Treat in-house numbers with the usual salt; independent evals aren't out yet.

Notably absent: any long-context benchmark. For a model whose headline feature is 1M-context sparse attention, there's no RULER/needle/long-doc number in the README. That's the first thing to verify.

What's actually there, and what it costs

Weights on HuggingFace (MIT), chat template with tool-calling and a thinking-mode toggle, GPU deployment via SGLang, NPU via SGLang-FluentLLM, and a hosted chat at longcat.ai. No training code, no data, and details deferred to the blog.

Be realistic about hardware: 1.6T total parameters means roughly 1.6TB of weights even at FP8 — this is a multi-node/rack deployment, not something for a workstation. The ASIC-superpod claim (widely assumed to be Huawei Ascend given the FluentLLM path) is itself the headline for anyone tracking whether frontier training has decoupled from NVIDIA: 35T tokens, zero rollbacks, on alternative silicon.

Try it

Easiest path is the hosted chat at https://longcat.ai/. For self-hosting, follow the SGLang cookbook; for prompt formatting:

from transformers import AutoTokenizer
tok = AutoTokenizer.from_pretrained("meituan-longcat/LongCat-2.0", trust_remote_code=True)
prompt = tok.apply_chat_template(
    [{"role": "user", "content": "Calculate 1+1"}],
    tokenize=False, enable_thinking=True, add_generation_prompt=True,
)

Note the non-standard tool-call format (arguments as a dict, not a JSON string) and the save_reasoning_content=True flag, which keeps prior-turn reasoning in context — they claim better performance at higher token cost.