---
title: "LongCat-2.5: Meituan’s 1.6T MoE on Chinese chips, read carefully"
description: "LongCat-2.5 is Meituan's 1.6T MoE with 48B active, trained on domestic accelerators with W4A4 inference. What the benchmarks and price really say."
canonical_url: https://www.oguzhan.co/meituan-longcat-2-5-1-6t-moe-chinese-chips/
author: "Oğuzhan Koçaklı"
author_url: https://www.oguzhan.co/about/
date_published: 2026-11-04T07:20:15+00:00
date_modified: 2026-11-04T07:20:15+00:00
language: en
translations:
  tr: https://www.oguzhan.co/tr/meituan-longcat-2-5-yerli-cip-moe/
---

# LongCat-2.5: Meituan’s 1.6T MoE on Chinese chips, read carefully

Meituan, yes, the food delivery company, has shipped LongCat-2.5. It is a mixture-of-experts model with 1.6 trillion parameters in total and about 48 billion active per token, multimodal from the ground up, and trained on what Meituan calls “domestic AI accelerators”. The English [launch post](https://longcat.ai/blog/longcat-2.5) is dated 1 November, and the [API changelog](https://longcat.ai/platform/docs/change-log) lists the model as available from 2 November. The number that made me read the whole thing: on Terminal Bench v4.0, LongCat-2.0 scored 3.0 and LongCat-2.5 scores 38.5, per [Meituan’s own table](https://longcat.ai/blog/longcat-2.5). Same size. No new parameters.

So the leaderboard is the least interesting part of this release. The training recipe and the hardware are where the news is.

## What does “1.6 trillion total, 48 billion active” actually mean?

A mixture-of-experts (MoE) model is a large pool of specialist sub-networks with a router in front. For every token, the router picks a few experts and the rest sit idle. LongCat-2.5 holds 1.6 trillion parameters, but [according to Meituan’s blog](https://longcat.ai/blog/longcat-2.5) only about 48 billion of them do work on any given token.

That split drives two different bills. Total parameters decide how much memory you need to keep the model loaded. Active parameters decide how much compute each token costs. A 1.6T MoE can therefore be served far cheaper per token than the headline count suggests, as long as someone has the memory to hold every expert.

This is also not a bigger model than the last one. As [Jack Qiu’s row-by-row count](https://www.jackqiu.co/en/blog/meituan-longcat/) points out, LongCat-2.0 had the same shape, 1.6T total and about 48B active, and it was released under the MIT license. Whatever changed between 2.0 and 2.5 came from training.

![Vast grid of dim blocks with a small amber cluster lit as a streak of light passes through](https://oguzhanco.s3.eu-west-3.amazonaws.com/wp-content/uploads/2026/11/04072009/longcat-2-5-mixture-of-experts-active.webp)

*In an MoE, a router wakes a few experts per token. LongCat-2.5 uses about 48B of its 1.6T.*

## How did the same-size model get so much better at coding?

Long-horizon reinforcement learning, and a lot of it. [Meituan’s blog](https://longcat.ai/blog/longcat-2.5) describes adding more long-horizon trajectories to long-sequence training, then running large-scale RL aimed at complex codebase development and full-project builds.

The tasks come from GitHub. Meituan filters pull requests and their linked issues, turns them into tasks, and validates each one with fail-to-pass and pass-to-pass tests. The first kind proves the fix works. The second proves nothing else broke. Real agent failures get recycled as well: trajectories where an agent went wrong in real use are converted into reproducible, verifiable training tasks.

The part I found most useful for builders is the list of anti reward hacking rules. An RL agent will cheat whenever cheating pays, so Meituan closes the obvious doors:

- Network access is disabled inside task environments.
- Git history and cached files are removed, so the answer can’t be looked up.
- An LLM judge audits trajectories for exploits.
- Repetitive reasoning and repeated tool calls are penalized.
- Reward is redistributed among positive samples to push back on overthinking and runaway response length.

Rollouts are asynchronous and partial, and training mixes tasks and harnesses, which Meituan says improves generalization.

After RL comes multi-teacher distillation, which Meituan calls MOPD. LongCat-2.0’s expert groups for agents, reasoning, interaction and safety were kept as domain teachers, and they train the student through full-vocabulary KL divergence. A technique called Tree Attention lets every student sample in a group go through a single forward and backward pass.

Meituan also says it gets bitwise-identical per-token log probabilities between training, prefill and decode, building on IsoExec, GLM-5 and XoRL. If the numbers the trainer sees drift away from the numbers the server produces, the RL signal gets noisy. Pinning them together is unglamorous work, and easy to skip.

## The numbers, and how to read the asterisks

Start with the settings. Per [Meituan’s blog](https://longcat.ai/blog/longcat-2.5), every LongCat-2.5 result was run with `enable_thinking` on, temperature 1.0 and top_p 0.95. The coding evals (Terminal Bench, Program Bench, NL2Repo) used the Claude Code harness v2.1.280 with max_seq_length 512K. DeepSWE used mini-swe-agent with max_seq_length 1M.

Then the asterisks. Meituan’s table mixes two kinds of competitor numbers. An asterisk means the score was taken from that vendor’s public report, blog or leaderboard. No asterisk means Meituan ran the competitor itself, and Meituan calls those numbers “indicative only”. The LongCat-2.0 column is Meituan’s too.

| Benchmark | LongCat-2.5 | LongCat-2.0 | Claude Opus 5 | Claude Opus 4.8 | GPT-5.6-Sol | DeepSeek-V4.1-Flash |
| --- | --- | --- | --- | --- | --- | --- |
| Terminal Bench v2.1 | 88.4 | 70.8 | 89.1\* | 74.6\* | 88.8\* | 90.6\* |
| Terminal Bench v4.0 | 38.5 | 3.0 | 53.9\* | 23.6\* | 37.3\* | 31.2\* |
| Program Bench (Almost Resolved) | 25.5 | 2.5 | 37.0\* | 16.5\* | 23.0\* | 20.3\* |
| DeepSWE v1.1 | 64.6 | 9.7 | 68.8\* | 59.0\* | 72.7\* | 74.2\* |
| NL2Repo | 60.5 | 40.9 | 75.3\* | 69.7\* | 56.8\* | 65.4\* |
| BrowseComp | 91.9 | 79.9 | 90.8\* | 84.3\* | 90.4\* | 91.5 |
| MCP Atlas | 83.1 | 61.8 | 85.8\* | 82.2\* | 81.8\* | 84.4 |
| AutomationBench v1.0.6 | 51.8 | 15.8 | 50.3\* | 41.0\* | 45.8\* | 54.8\* |
| HLE w/ tools | 63.1 | 37.5 | 64.7\* | 57.9\* | 58.0\* | 63.9\* |

*Selected rows from [Meituan’s table](https://longcat.ai/blog/longcat-2.5). An asterisk marks a number Meituan took from that vendor’s public report or leaderboard. No asterisk means Meituan’s own run. All LongCat figures are Meituan’s claims.*

![Two groups of glass bars on a dark floor, short dim bars on the left and tall glowing teal bars on the right](https://oguzhanco.s3.eu-west-3.amazonaws.com/wp-content/uploads/2026/11/04072011/longcat-2-5-benchmark-jump.webp)

*Same size, very different scores: LongCat-2.0 against LongCat-2.5 on Meituan’s table.*

Read the two LongCat columns side by side first. DeepSWE v1.1 goes from 9.7 to 64.6. Program Bench goes from 2.5 to 25.5. AutomationBench goes from 15.8 to 51.8. For a model that did not grow by a single parameter, that is the real story of this release.

Against other labs the picture is more mixed. [Jack Qiu’s row-by-row count](https://www.jackqiu.co/en/blog/meituan-longcat/) across the 27 rows LongCat-2.5 shares with each rival comes out like this:

- Claude Opus 5: 10 wins, 17 losses
- Claude Opus 4.8: 18 wins, 6 losses
- GPT-5.6-Sol: 20 wins, 7 losses
- DeepSeek-V4.1-Flash: 12 wins, 14 losses

On its own vendor’s table, then, LongCat-2.5 lands between Claude Opus 4.8 and Claude Opus 5. A respectable spot. Not the top.

The losses cluster where coding gets hardest. On Terminal Bench v4.0, Opus 5 scores 53.9 against LongCat’s 38.5. On NL2Repo it is 75.3 against 60.5, and even Opus 4.8 is ahead there at 69.7. On DeepSWE v1.1, a model with “Flash” in its name, DeepSeek-V4.1-Flash, posts 74.2 against 64.6.

The wins are real but narrower. BrowseComp at 91.9 and AutomationBench at 51.8 both edge past Opus 5’s reported scores. On BrowseComp, though, DeepSeek’s 91.5 carries no asterisk, which means Meituan ran it, and that row deserves a little extra salt.

I recently went through another round of [Terminal-Bench 4 claims around Factory’s Droid 1](https://www.oguzhan.co/factory-droid-1-programmatic-tool-calling/), and the same habit applies here: check the harness and the settings before you quote the score.

## What does W4A4 on domestic chips buy you?

W4A4 means 4-bit weights and 4-bit activations. Plenty of deployments squeeze weights down to 4 bits and keep activations wider, which means the multiply still runs at higher precision. Meituan’s [blog](https://longcat.ai/blog/longcat-2.5) says it quantizes both expert weights and activations to 4 bits and runs the matrix multiplications on native INT4 units. The method builds on FlatQuant’s learnable equivalent transformations, and Meituan claims “performance comparable to the unquantized model on all evaluated downstream tasks”.

The serving numbers, again Meituan’s own, come from online stress tests against a W8A8 INT8 baseline:

- Prefill throughput: up 43.3%
- Decode throughput: up 42.77%
- Time to first token (TTFT): down 15.91%
- Time per output token (TPOT): down 19.72%

The grouped matrix multiply (GMM) kernel averages a 1.73x speedup over W8A8. If those figures hold outside Meituan’s own stress tests, the same hardware pushes out a lot more tokens. Inference cost is where a lot of this race is now fought, and DeepSeek’s [DeepInfer serving stack](https://www.oguzhan.co/deepseek-deepinfer-eagle-4-muse-glimmer/) is another example of a lab treating serving as a first-class research problem.

![Dense server rack of unbranded accelerator cards under cool blue light](https://oguzhanco.s3.eu-west-3.amazonaws.com/wp-content/uploads/2026/11/04072013/longcat-2-5-w4a4-accelerator-rack.webp)

*Meituan says LongCat-2.5 trains and serves on domestic AI accelerators with W4A4 inference.*

On training, Meituan says the model trains with “less than 80 GB of memory per domestic AI accelerator”. Parallelism is aligned with the supernode topology, with FSDP and expert parallel (EP) degree set equal to the number of accelerators per supernode. Add dual-shard FSDP and Muon optimizer sharding, and Meituan reports 86% higher per-device throughput than its DDP baseline in long-sequence SFT.

The blog does not name the chip vendor or the chip model, so I won’t either. What it does show, in Meituan’s own words, is a model of this size trained and served on domestic AI accelerators with its recipe written out in public. That part will outlast any leaderboard row.

## Images as tokens

LongCat-2.5 represents visual input as multi-level discrete tokens, using Residual Vector Quantization on native-resolution features. The backbone then sees images and text in one token format.

The practical win is on the training side. Because visual token IDs can be precomputed and cached offline, [Meituan explains](https://longcat.ai/blog/longcat-2.5), the vision encoder drops out of the training graph. Fewer moving parts, simpler load balancing across a huge MoE. Note that the demo videos on the launch page still say “Demo footage coming soon”, so for now the vision claims are text only.

## Can you actually use it today?

Through the API and chat, yes. Through weights, no.

The [pricing page](https://longcat.ai/platform/docs/pricing/longcat-2.5) lists a pay-as-you-go “Discounted Price (limited-time)” per 1M tokens: $0.30 for uncached input, $0.006 for cached input and $1.20 for output (¥2, ¥0.04 and ¥8). The page also says “Prices are subject to change.” Treat those numbers as a launch discount, not a rate card you can build a budget on.

The [changelog entry](https://longcat.ai/platform/docs/change-log) says the model works across agent harnesses including Claude Code, Codex and Hermes.

On weights, the GitHub and Hugging Face buttons on the launch page both read “Coming soon”. I checked Hugging Face directly. The newest model repo under meituan-longcat is LongCat-Flash-Lite-Sparse from 31 Jul 2026, and LongCat-2.0 dates from 5 Jul 2026. There is no LongCat-2.5 repo, and no license for 2.5 has been published. LongCat-2.0 shipped under MIT, but that tells you nothing certain about what 2.5 will get.

Qiu’s advice is the right one: test it on your own tasks, and compare total token cost per finished task rather than the per-token price. A cheap model that needs far more turns to close a ticket is not cheap.

## What to watch

The weights first. Until LongCat-2.5 shows up on Hugging Face with a license attached, it is a hosted product, whatever happens to 2.0’s MIT terms. Then the price, because “limited-time” has an end date that nobody has stated. And then independent reruns, especially of the unmarked rows Meituan scored itself, and of Terminal Bench v4.0, where the jump from 3.0 to 38.5 is the claim this whole release rests on.

The recipe is already public. That alone makes this worth reading, even if you never send it a token.

## Sources

- [Meituan LongCat, “Introducing LongCat-2.5”](https://longcat.ai/blog/longcat-2.5)
- [Meituan tech team, Chinese version (2 Nov 2026)](https://tech.meituan.com/2026/11/02/Meituan-LongCat-2.5.html)
- [LongCat API changelog, “Version: 2026-11-02, LongCat-2.5 Now Available”](https://longcat.ai/platform/docs/change-log)
- [LongCat API pricing for LongCat-2.5](https://longcat.ai/platform/docs/pricing/longcat-2.5)
- [Jack Qiu, row-by-row analysis of the LongCat-2.5 table](https://www.jackqiu.co/en/blog/meituan-longcat/)
