Skip to content
ISSUE 001·LIVE·20:20 IL
← Journal/2026-11-16·9 min·meituan

LongCat-2.5: Meituan open-sources a 1.6T agent model under MIT, trained and served without Nvidia

Meituan's LongCat team released the weights for LongCat-2.5, a 1.6-trillion-parameter mixture-of-experts model with about 48B active parameters per token, native image understanding, a 512K-token context, and an MIT license. Training and the reference deployment run entirely on domestic Chinese accelerators, with W4A4 INT4 quantization that the team says roughly matches full-precision accuracy. Vendor benchmarks put it near Claude Opus 5 on agentic coding, below it on terminal tasks. Self-hosting needs a serious cluster.

By Harel Asaf·AI Builder·Tel Aviv

Meituan's LongCat team released the weights for LongCat-2.5 this week under the MIT license, and the combination matters: a 1.6-trillion-parameter mixture-of-experts with roughly 48B active parameters per token, native multimodality, a 512K-token context window, and agentic-coding benchmarks in Claude Opus 5 territory, trained and deployed without any Nvidia hardware. The weights landed on Hugging Face about a week after the model's official unveiling, alongside a quantized W4A4 variant and an NPU deployment recipe. This is now one of the strongest truly open models you can actually download, modify, and serve yourself, with the caveat that serving it takes a small data center. All benchmark and infrastructure numbers below come from the model card and are vendor-reported.

What LongCat-2.5 actually is

LongCat-2.5 is a native multimodal MoE built for long-horizon agentic work. The config shows 768 routed experts, a 163,840-token vocabulary, and a maximum context of 524,288 tokens. The team positions it for complex codebase development, full-project builds, creative design, and 3D tasks.

The multimodal part is architectural, not bolted on. Building on the LongCat-Next line, native-resolution visual features are converted into discrete tokens and aligned with text in a shared semantic space, so the model reads images through the same pathway as words rather than through a separate encoder grafted on after training.

One operational detail worth knowing: thinking mode is off by default (enable_thinking=False), which the team recommends for better token efficiency.

The benchmarks, all vendor-reported

The model card's table compares LongCat-2.5 against LongCat-2.0 and frontier models including GPT-5.5, Claude Opus 4.8 and Opus 5, GLM-5.3, Kimi K3, and DeepSeek-V4.1-Flash. Numbers marked with an asterisk on the card are cited from external sources rather than run by the team, so treat cross-vendor comparisons with the usual care.

The highlights: Terminal-Bench v2.1 at 88.4, just under Opus 5's 89.1 and DeepSeek-V4.1-Flash's 90.6, and far above LongCat-2.0's 70.8. On the harder Terminal-Bench v4.0 the gap to Opus 5 widens, 38.5 to 53.9, and on Program Bench (Almost Resolved) it scores 25.5 against Opus 5's 37.0. PaperBench is a bright spot at 82.1, near the top of the table, and 3DCodeBench at 55.4 is the highest score listed. Against its own predecessor the jump is dramatic across the board: DeepSWE goes from 9.7 to 64.6, AutomationBench from 15.8 to 51.8, JobBench from 44.4 to 65.4.

The honest reading: this is a frontier-adjacent agent model that trades blows with the best on some evaluations and clearly trails Opus 5 on terminal-heavy work. For an open-weights model under MIT, that is a new watermark.

Trained and served without Nvidia

The infrastructure section of the card is as interesting as the benchmarks. Training ran on domestic Chinese AI accelerators, and the team reports supernode-aware parallelism, sharding, and communication-computation overlap delivering 86% higher per-device throughput than a DDP baseline on long-sequence SFT tasks. The RL infrastructure keeps token log probabilities bitwise-identical across training, prefill, and decoding, which anyone who has debugged train-serve skew will appreciate, and KV cache work nearly doubled decode KV capacity without increasing TPOT on the tested workload.

The W4A4 quantization story is the deployment enabler: expert weights and activations go to native INT4 on domestic accelerators using FlatQuant-style learnable transformations, with accuracy the team says is comparable to the unquantized model on evaluated benchmarks. Against a W8A8 MoE baseline, online stress tests show 43.3% higher prefill throughput, 42.77% higher decode throughput, 15.91% lower TTFT, and 19.72% lower TPOT, with grouped GEMM kernels averaging 1.73x speedup. Combined with KV cache quantization, W4A4KV8 delivers 92% higher decode throughput than W8A8KV16. A separate W4A4 weight release is published alongside the main model.

How to actually run it

Be realistic about the hardware. The reference NPU deployment, documented in the SGLang-FluentLLM repository, targets Huawei's Ascend Atlas A2 platform, and the sample configuration is a 194-card Atlas A2 Pod cluster with 16 cards per prefill/decode machine and 2 cards for the encoder. At 1.6T parameters even INT4 weights are in the hundreds of gigabytes, so this is a cluster model, not a laptop model. The deployment stack is CANN 9.0.0 with torch_npu and torchair matched to PyTorch 2.9.0, which tells you the software path is Huawei-first.

If you do not run Ascend hardware, the practical routes are the hosted API on the official LongCat platform, which sits behind a Meituan account login so I could not verify pricing without signing up, or waiting for community inference support. GPU-oriented serving stacks have not published verified LongCat-2.5 recipes at the time of writing, and I would not assume vLLM or stock SGLang handles the architecture without checking.

What I would check

If you have Ascend access, reproduce the W4A4 deployment and measure per-token cost against your current serving stack, since the throughput claims are the whole point of the quantization work. Test the model on your own agentic coding harness with thinking mode off and on, and watch token consumption in both modes. Verify the MIT license terms on the model card cover your intended use, including the quantized variant. And track whether third-party leaderboards and serving frameworks pick the model up over the next weeks, since that determines whether this becomes infrastructure or stays a research artifact.

What I would not conclude

Vendor tables with asterisked competitor numbers are not independent evaluations, and several strong results here are self-run only. Do not assume the model is cheap to serve because it is efficient on Ascend: the reference deployment is a 194-card pod, and nothing about the release suggests single-node practicality. And the MIT license covers the weights, not the compute you would need to use them.

Frequently asked questions

What is LongCat-2.5?

LongCat-2.5 is Meituan's open-weights flagship model for agentic tasks: a native multimodal mixture-of-experts with 1.6 trillion total parameters, about 48B active per token, 768 routed experts, and a 512K-token context window. It was released under the MIT license in November 2026.

Is LongCat-2.5 really open source?

The weights are published on Hugging Face under the MIT license, including a quantized W4A4 variant, which permits commercial use, modification, and redistribution. That is about as open as model releases get. Training code and data are not part of the release, which is standard for open-weights models.

Can I run LongCat-2.5 on my own GPU?

Realistically no. Even with W4A4 INT4 quantization, 1.6 trillion parameters need hundreds of gigabytes of accelerator memory. The only documented deployment is a 194-card Huawei Atlas A2 NPU pod. For individuals and small teams, the hosted API on the LongCat platform is the practical entry point.

How good is it at coding compared to Claude Opus 5?

On the vendor's table, LongCat-2.5 nearly matches Opus 5 on Terminal-Bench v2.1 (88.4 versus 89.1) but trails clearly on Terminal-Bench v4.0 (38.5 versus 53.9) and Program Bench (25.5 versus 37.0). It leads the table on 3DCodeBench and is near the top on PaperBench. These are vendor-reported figures, so wait for independent evaluations before betting a migration on them.

Was it really trained without Nvidia hardware?

Yes, according to the model card and consistent reporting: training ran on domestic Chinese accelerators, and the only documented serving stack is Huawei Ascend with CANN. The card frames the parallelism, RL infrastructure, and quantization work around that hardware.

What is the W4A4 variant for?

W4A4 quantizes expert weights and activations to native INT4 on domestic accelerators. Meituan reports roughly 43% higher prefill and decode throughput versus W8A8 with accuracy comparable to the unquantized model on its evaluated benchmarks, and a 92% decode-throughput gain when combined with KV cache quantization. It exists to make serving the model economically viable.

How much does the hosted API cost?

I could not verify pricing: the LongCat platform's usage page requires a Meituan account login. If you evaluate the hosted route, check the pricing page after signing up rather than relying on third-party summaries.

Sources

Related reading

  • Qwen4-Max: Alibaba's 2.4T flagship API model claims 62% lower cost per task than its predecessor

    Alibaba's Qwen team released Qwen4-Max, the first model in the Qwen4 family: a 2.4-trillion-parameter sparse MoE with 71B active parameters, a 1M-token context window, thinking modes with tunable effort, and both OpenAI-compatible and Anthropic-compatible endpoints. Vendor-reported numbers show up to 49% fewer tokens on agentic coding tasks and a 62% drop in average cost per task versus Qwen3.8-Max. Input starts at 1.5 dollars per million tokens.

  • Inkling 2 Small: Thinking Machines ships a 594B open-weights MoE that runs on 17B active parameters

    Thinking Machines Lab released Inkling 2 Small with open weights under Apache 2.0: a natively multimodal 594B mixture-of-experts model with 17B active parameters, 1M tokens of context, and agentic-coding benchmarks that beat most open flash-class rivals. Self-hosting needs a GPU cluster; Ollama Cloud offers it at 0.30 dollars per million input tokens.

  • Gemini 4 Hydrogen: Google's fast execution model undercuts Argon on price and beats it on intelligence

    Google launched Gemini 4 Hydrogen on November 12: a fast everyday coding and agentic model that scores 51 on the Artificial Analysis Intelligence Index at its default thinking level, above Gemini 4 Argon's 50, at 1.50 dollars per million input tokens and 7.50 per million output tokens. What the three-model Gemini 4 ladder means, how Orchestrator splits work in Antigravity, and what to verify.

The build log

Follow the work.

New essays and prototypes, in your feed reader. Email subscriptions are paused while I connect a working delivery service. No email is collected here.

Follow via RSS