LongCat-2.5: Meituan's 1.6T open agent model and its chip claim
Meituan has released MIT-licensed weights for LongCat-2.5, a 1.6T-parameter agent model it says was trained on Chinese accelerators. What its documents say about the hardware, what they leave out, and what self-hosting takes.
Meituan’s LongCat team has published the weights of LongCat-2.5, a 1.6-trillion-parameter mixture-of-experts model built for long-running agent work, under the MIT licence. The company says the model was trained on Chinese AI accelerators rather than Nvidia GPUs, and that claim, more than the model itself, has driven the coverage. Meituan’s own documents support a narrower version of it than the headlines suggest. They say long-sequence training and fine-tuning ran on “domestic AI accelerators” with less than 80 GB of memory each, and a page description that longcat.ai uses site-wide, including on the LongCat-2.5 blog, says training was completed entirely on domestic chips. They do not name the chip, its vendor or the size of the cluster.
The only hardware Meituan names is for running the model, not training it. Its self-hosting guide deploys a 4-bit version on 194 Huawei Ascend Atlas A2 accelerators, and the model card offers no GPU deployment instructions. For builders, that is the practical consequence: a frontier-scale open model whose documented serving path is Huawei hardware.
This article sets out what Meituan released and when, what each primary document says about hardware, where the coverage goes beyond it, the architecture as far as the files reveal it, what self-hosting takes, and how much weight the benchmark table can bear. GenAI Brief has not run the model.
What Meituan released, and when
The release came in stages over two weeks, which explains why reports carry different dates.
| Date | Event | Source |
|---|---|---|
| 30 Jun 2026 | LongCat-2.0 released: 1.6T total, about 48B active, MIT licence | LongCat-2.0 blog and model card |
| 1 Nov 2026 | LongCat-2.5 technical blog dated this day | longcat.ai blog |
| 2 Nov 2026 | TechNode reports the LongCat-2.5 launch | TechNode |
| 4 to 5 Nov 2026 | Hugging Face repository created; weight shards uploaded | Hugging Face commit history |
| 9 to 10 Nov 2026 | Model card and documentation updates | Hugging Face commit history |
| 10 Nov 2026 | Meituan technical team announces the open-source release | tech.meituan.com |
| 15 Nov 2026 | The Decoder reports the weights release | The Decoder |
Compiled by GenAI Brief from the sources listed, read 18 November 2026.
TechNode reported on 2 November that Meituan had released LongCat-2.5 with “1.6 trillion total parameters, with approximately 48 billion activated for each token”. Tech Times wrote on 3 November that open-weight releases “are planned but had not yet been published”. Meituan’s technical team then posted its open-source announcement on 10 November, and The Decoder reported the weights on 15 November under the headline “Meituan releases a 1.6-trillion-parameter agent model that never touched an Nvidia GPU”.
Two repositories hold the weights. The main LongCat-2.5 repository contains 208 numbered BF16 safetensors shards plus two multimodal weight files, totalling about 3.56 TB by our sum of the file sizes Hugging Face reports. The LongCat-2.5-W4A4 repository holds the 4-bit version, about 1.34 TB. Both are tagged MIT.
The licence
The 10 November announcement says, in our translation, that Meituan “is officially open-sourcing LongCat-2.5 under the MIT licence, supporting commercial inference deployment and further training, with no additional authorisation required.” It explains the choice: the team wants the model “to be freely used, modified and redistributed”. The model card adds one limit: the licence “does not grant any rights to use Meituan trademarks or patents.”
That makes LongCat-2.5 one of the least restricted frontier-scale open models. Our October survey of open-weight models found that three of the top five carried revenue thresholds for model-as-a-service businesses. LongCat-2.5 has none.
What Meituan says about the hardware
The hardware claim appears in four Meituan documents, and each says something slightly different. Reading them together is the only way to see what is actually claimed.
The model card. The Hugging Face card says that “long-sequence training, large-scale RL, multi-teacher learning, and infrastructure optimizations on domestic AI accelerators underpin these capabilities.” It reports “86% higher per-device throughput than the DDP baseline in reported long-sequence SFT tasks” and says W4A4 quantisation enables “native INT4 computation on domestic AI accelerators.” It does not mention Nvidia.
The technical blog. The longcat.ai blog has a section titled “Long-Context Training on Domestic AI Accelerators”. It says LongCat-2.5 “uses long-sequence training during both mid-training and SFT” and that “with less than 80 GB of memory per domestic AI accelerator, the training system prioritizes memory efficiency and aligns its parallelism with the supernode architecture.” The page’s metadata description, shown when the link is shared, reads in Chinese “1.6万亿总参大模型,训练全程由国产芯片完成”: in our translation, a model with 1.6 trillion total parameters whose “training was completed entirely on domestic chips.” That description is not specific to LongCat-2.5: a comment in the page’s HTML says all routes share the same share-card metadata, and the identical text appears on the longcat.ai home page and the LongCat-2.0 blog.
The open-source announcement. The 10 November post says, in our translation, that “for domestic computing chips constrained by memory and bandwidth, we carried out deep co-optimisation of model architecture, chip adaptation and deployment strategy.” Its section on domestic compute repeats the under-80 GB constraint for long-sequence training and fine-tuning, and adds that these trade-offs “were completed together with industry partners”, without naming them.
The deployment guide. The NPU guide in Meituan’s SGLang-FluentLLM repository is the only document that names hardware. It says the code supports deployment on “昇腾Atlas A2 Pod”, Huawei’s Ascend Atlas A2 platform, with driver version Ascend HDK 25.0.RC1.1 or a driver matching CANN 9.0.0.
What is documented, claimed and missing
| Question | What Meituan’s documents say | Status |
|---|---|---|
| Was training on Chinese accelerators? | Yes: “domestic AI accelerators” for long-sequence mid-training and SFT; a site-wide page description, not specific to 2.5, says all training | Claimed by Meituan |
| Which chip or vendor for training? | Not stated | Not documented |
| How many accelerators trained LongCat-2.5? | Not stated | Not documented |
| Memory per training accelerator | Less than 80 GB | Claimed by Meituan |
| Was any Nvidia hardware used anywhere? | Not addressed in those words | Not documented |
| Which chips run inference? | Huawei Ascend Atlas A2, 194 accelerators in the sample | Documented |
| GPU deployment path | None in the LongCat-2.5 card | Not documented |
GenAI Brief’s reading of the LongCat-2.5 model card, technical blog, 10 November announcement and NPU deployment guide, 18 November 2026.
The gap between the claim and the headlines is specific. “Trained entirely on domestic chips” is Meituan’s statement. “Never touched an Nvidia GPU” is a stronger one: it would also cover data processing, teacher models, evaluation runs and the reward models used in reinforcement learning. Meituan’s documents do not address those. The LongCat-2.5 card says the model learned from specialised “agent, reasoning, and interaction teachers”, the blog says those expert groups were retained from LongCat-2.0, and the blog adds that an LLM judge audited training trajectories for reward hacking. It does not say what hardware those ran on.
Our inference about the training chips
The training sections contain clues that GenAI Brief reads as consistent with Huawei’s Ascend platform, though Meituan does not say so. The blog describes calling “AIV-based communication to alleviate AI-CPU task-expansion bottlenecks”. AI Vector (AIV) cores and AI CPU are terms from the architecture of Huawei’s Ascend NPUs and its CANN software stack. The deployment guide’s build step targets ascend910b. Combined with the under-80 GB memory figure and the “supernode” topology language, this is suggestive, but it is our inference, not Meituan’s statement, and it does not establish which Ascend generation trained the model or whether other vendors’ chips were also used.
What the training notes reveal about working under 80 GB
The most useful part of Meituan’s hardware disclosure is not the claim itself but the engineering it describes, because it shows what a team had to change to train a model of this size on accelerators with less memory than an 80 GB GPU. The blog’s account, which GenAI Brief has not been able to verify independently, covers four areas.
Parallelism that follows the hardware. Meituan says it aligned its parallel groups with the “supernode” topology, setting fully sharded data parallelism and expert parallelism equal to the number of accelerators in a supernode, so that parameter all-gathers, expert token exchanges and KV all-gathers stay “within the high-bandwidth supernode interconnect.” It adds “hybrid vocabulary parallelism”, sharding the embedding layer, output head and N-gram embeddings, to save memory.
Memory-first sharding. The blog describes “dual-shard FSDP”, which keeps parameter sharding inside each supernode while sharding FP32 master weights and optimiser states further across replicas. It describes contiguous flattened buffers to support uneven sharding and the Muon optimiser, and zero-copy collective operations to avoid intermediate copies. The reported result is the 86 per cent per-device throughput gain over a DDP baseline on long-sequence fine-tuning.
Load balancing for experts. Meituan says it added “threshold-based dynamic expert replication built on MoonEP”, which copies busy experts only when imbalance crosses a set threshold, because replication’s communication cost can otherwise exceed its benefit or cause out-of-memory failures.
Reproducible reinforcement learning. For agentic RL, the blog says training, prefill and decode engines keep “bitwise-identical per-token log probabilities” through batch-invariant kernels, and that rollouts use asynchronous partial trajectories, saved and resumed between steps, with corrections for the staleness this introduces. Reward-hacking controls include disabling network access in task environments, removing git history and cached files, and an LLM judge that audits trajectories.
None of these techniques is unique to Chinese hardware; several are cited to open-source work. What the account shows is that the constraint Meituan names, memory per device, shaped nearly every system decision. That is consistent with the claim that the training ran on accelerators smaller than the GPUs most labs use, though it does not prove which ones.
Where the 50,000-accelerator figure comes from
Much of the coverage repeats that Meituan trained on more than 50,000 Chinese chips. That figure belongs to LongCat-2.0. Its technical blog, dated 30 June 2026, says that “LongCat-2.0 is pre-trained on over 50K AI ASICs.” The LongCat-2.0 model card adds that “both the full training run and the large-scale deployment are built entirely on AI ASIC superpods”, that pre-training spanned “millions of accelerator-days across more than 35 trillion tokens”, and that it ran “with no rollbacks or irrecoverable loss spikes.”
The LongCat-2.0 blog also gave more hardware detail than its successor. It said “our accelerators have significantly less per-device memory than an H800 (80 GB)”, and described physical superpods of “up to 48 machines each, with all-to-all high bandwidth inside and a RoCE fabric between them”. Like the 2.5 documents, it did not name the vendor. Tech Times, citing community discussion, says the chip was likely Huawei’s Ascend 910C, and notes that Meituan’s announcement “uses the phrase ‘alternative hardware platforms’ without naming a vendor.”
The link between the two models matters for the claim. LongCat-2.5 “builds on LongCat-2.0”, according to its card, and has the same 1.6 trillion total and about 48 billion active parameters. Meituan’s 2.5 documents describe mid-training, supervised fine-tuning and reinforcement learning, not a new pre-training run. A reasonable reading is that LongCat-2.5 continues from LongCat-2.0’s pre-trained base on the same class of hardware, which would make the 50,000-accelerator figure relevant context. Meituan does not state this directly, so the cluster size for LongCat-2.5’s own training remains undocumented.
The architecture, from the files
Meituan has not published a technical report for LongCat-2.5. The card, blog and config.json together describe the main features.
Mixture of experts. The configuration file lists 768 routed experts with 12 selected per token (moe_topk), plus 128 “zero experts” of type “identity”. Zero experts, used in earlier LongCat models, let the router send some tokens through an identity path, which is one way the number of active parameters can vary around the stated average of about 48 billion.
Attention. The configuration uses multi-head latent attention (attention_method: MLA) with sparse-attention indexer settings, including index_topk: 2048. The blog credits LongCat Sparse Attention (LSA) with reusing “each even-numbered layer’s top-k indices in the next odd-numbered layer” during inference.
N-gram embedding. The configuration includes oe_ parameters for an N-gram embedding module. LongCat-2.0’s blog said its model included 135 billion N-gram Embedding parameters.
Vision as tokens. LongCat-2.5 adds image understanding by converting images into discrete tokens. The blog describes applying “Residual Vector Quantization (RVQ) to native-resolution features”, following Meituan’s LongCat-Next research, and the configuration’s visual quantiser has eight codebooks of 16,384 entries. Because image tokens are precomputed, the blog says, “the backbone therefore processes pretokenized sequences”, which removes the vision encoder from the training graph.
Multi-token prediction. The configuration sets three MTP layers, used for speculative decoding.
1.6 trillion or 1.78 trillion?
The Hugging Face safetensors metadata for the BF16 repository counts 1,779,752,648,320 parameters: about 1.778 trillion in BF16 and 1.2 billion in FP32. Meituan describes the model as 1.6 trillion. Its documents do not explain the gap. One plausible explanation, which is our inference, is that the headline figure excludes components such as the N-gram embeddings (135 billion in LongCat-2.0), the multi-token prediction layers and the visual modules. For anyone sizing storage or memory, the file sizes are the reliable number: about 3.56 TB in BF16 and 1.34 TB in W4A4.
Context length
Meituan’s API documentation lists “1M token context window with a maximum output length of 256K tokens” for LongCat-2.5. The open-source announcement also says the model supports a million tokens of context. The configuration file sets max_position_embeddings to 524,288 and uses YaRN rope scaling with a factor of 120 on an original 8,192 positions, which multiplies to 983,040. The Decoder reported a 128,000-token maximum output; Meituan’s API page says 256,000, and we use Meituan’s figure. Self-hosters should test long contexts on their own deployment, because the configuration’s default and the API’s limit are not the same number.
What self-hosting takes
Meituan’s NPU guide, written in Chinese, documents one reference deployment of the W4A4 model with encoder, prefill and decode disaggregated.
| Role | Accelerators | Parallelism (from the guide) |
|---|---|---|
| Image encoder | 2 | TP=2 |
| Prefill | 64 (4 machines of 16) | PP=8, attention TP=8 |
| Decode | 128 (8 machines of 16) | KVP=8, DP=16, EP=128 |
| Total | 194 Atlas A2 | W4A4 weights, INT8 KV cache, MTP |
From Meituan’s LongCat 2.5 W4A4 NPU deployment guide, read 18 November 2026.
The software stack is Huawei’s: CANN 9.0.0 toolkit and operator packages, the NNAL ATB acceleration library, torch_npu and torchair for PyTorch 2.9, Python 3.11, and a custom kernel package built for ascend910b. Meituan’s own SGLang fork, on a longcat-2.5-npu branch, provides the serving code. The guide’s scripts distribute code over SSH with rsync and start prefill, decode and a load balancer across twelve machines.
On W4A4, Meituan’s card reports that “compared with 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 a 1.73 times kernel speedup, and that combined with KV-cache quantisation, “W4A4KV8 delivers 92% higher decode throughput than W8A8KV16.” It says accuracy is “comparable to the unquantized model on evaluated benchmarks.” These are Meituan’s measurements on its hardware.
One gap in the guide matters for anyone following it. The encoder step points MODEL_PATH at a separate set of weights, /data/meituan-longcat/LongCat-2.5-Encoder, but the Hugging Face organisation listed no LongCat-2.5-Encoder repository when we checked on 18 November 2026; it listed only LongCat-2.5 and LongCat-2.5-W4A4 for this model. Both repositories do include visual-model weights in two separate multimodal files (about 8.1 GB), which may be what the encoder loads, but the guide does not say how to assemble that directory. Self-hosters who need image input should confirm with Meituan where the encoder weights come from. LongCat-2.0, by comparison, shipped BF16, FP8 and INT8 repositories; LongCat-2.5 has BF16 and W4A4 only.
The card also documents how to call the model once it is running. LongCat-2.5 is a hybrid model with thinking on or off through enable_thinking in the chat template, and Meituan recommends keeping all earlier reasoning in the conversation (save_history_reasoning_content=True) “for better performance” when thinking is on, and turning thinking off “for better token efficiency.” Unless otherwise specified, Meituan’s reported scores use thinking on, temperature 1.0 and top-p 0.95, so a deployment that turns thinking off should not expect the table’s results.
If your cluster runs Nvidia
The LongCat-2.5 card says only that it “can be deployed on NPU platforms,” and links the Ascend guide. There is no GPU section. That is a change from LongCat-2.0, whose card said it “can be deployed on both GPU and NPU platforms” and pointed GPU users to an SGLang cookbook. The 2.5 model uses a custom model type (pro_v), and its config.json points auto_map at modelling files (modeling_longcat_oe.py) that neither LongCat-2.5 repository contained when we checked on 18 November 2026, so a framework needs that code or native support before it can run the model.
The practical options for a team on Nvidia hardware are limited and, as far as Meituan documents, untested: run the BF16 weights on enough GPUs to hold 3.56 TB once compatible modelling code is available, wait for framework support, or use the hosted API. The self-hosting guide covers the general sizing arithmetic; at this scale, the answer is a multi-node cluster before any KV cache is counted.
Sizing arithmetic for other hardware
For teams on other hardware, the file sizes give a floor. Holding the 3.56 TB of BF16 weights on accelerators with 80 GB of memory each takes at least 45 of them, which is six eight-accelerator nodes, before any memory for the KV cache, activations or the serving framework. The 1.34 TB W4A4 checkpoint needs at least 17 such accelerators for weights alone, but Meituan’s quantisation targets native INT4 matrix units, and its throughput figures were measured on Ascend; whether the 4-bit checkpoint runs efficiently, or at all, on other hardware is not documented. These are GenAI Brief’s minimum calculations, not a deployment recipe. Real deployments, like Meituan’s own, use far more accelerators than the floor, because disaggregated prefill and decode replicate parts of the model and long contexts need cache memory.
The hosted API
Meituan’s API accepts OpenAI-format requests at /v1/chat/completions and Anthropic-format requests at /v1/messages, with the model name LongCat-2.5. Rate-limited requests return HTTP 429 with a retry_after value, and the documentation recommends exponential backoff. The Decoder reports a limited-time promotional price; we could not find a price on the public API documentation pages we were able to read, so we do not repeat a figure here. Tech Times reported in early November that the platform’s documentation did not state a data-retention policy; teams sending sensitive code should confirm the current terms before use.
How much the benchmark table can bear
Meituan’s evaluation table compares LongCat-2.5 with LongCat-2.0, GPT-5.5, GPT-5.6-Sol, Claude Opus 4.8, Claude Opus 5, GLM-5.3, Kimi K3 and DeepSeek-V4.1-Flash across 31 benchmarks. The card’s footnote sets the rules: “Scores marked with * are cited from public technical reports, blog posts, or official leaderboards; unmarked scores are measured in-house and are indicative only.”
Every LongCat-2.5 score is unmarked, so every LongCat-2.5 score is in-house. Most competitor scores on the coding rows are cited from elsewhere. That means each row typically compares Meituan’s run of its own model with someone else’s run of a competitor, under a harness Meituan describes in its footnotes.
| Benchmark (Meituan’s table) | LongCat-2.5 | LongCat-2.0 | Claude Opus 5 | GPT-5.6-Sol | DeepSeek-V4.1-Flash |
|---|---|---|---|---|---|
| Terminal Bench v2.1 | 88.4 | 70.8 | 89.1* | 88.8* | 90.6* |
| Terminal Bench v4.0 | 38.5 | 3.0 | 53.9* | 37.3* | 31.2* |
| DeepSWE v1.1 | 64.6 | 9.7 | 68.8* | 72.7* | 74.2* |
| NL2Repo | 60.5 | 40.9 | 75.3* | 56.8* | 65.4* |
| BrowseComp | 91.9 | 79.9 | 90.8* | 90.4* | 91.5 |
| AutomationBench v1.0.6 | 51.8 | 15.8 | 50.3* | 45.8* | 54.8* |
| HLE (with tools) | 63.1 | 37.5 | 64.7* | 58.0* | 63.9* |
| ALE v1.1 | 38.5 | n/a | n/a | 30.3* | n/a |
From the LongCat-2.5 model card. An asterisk marks a score Meituan cites from a public source; unmarked scores are Meituan’s own runs.
Three cautions follow.
The comparison set is a generation old. The table includes Claude Opus 5 and GPT-5.6-Sol but not GPT-6 Astra, GPT-6.1 Sol, Claude Opus 5.5 or Claude Fable 5.2. The Decoder makes the same point. Being close to Opus 5 on Terminal Bench v2.1 says little about the current frontier.
Harnesses vary by row. The footnotes list Claude Code at version 2.1.280 for Terminal Bench and NL2Repo, an older Claude Code version for SWE Atlas and HLE, mini-swe-agent for DeepSWE, a custom harness capped at 1,024 exploration rounds for BrowseComp, and the Codex harness for SkillsBench. The BrowseComp score of 91.9, the highest in its row, comes from Meituan’s own harness with only search and browse tools.
Some gains are very large. DeepSWE rises from 9.7 for LongCat-2.0 to 64.6, and Terminal Bench v4.0 from 3.0 to 38.5. Gains of that size between versions of the same base deserve an independent rerun before anyone relies on them.
No independent evaluation was available when we checked on 18 November 2026. Artificial Analysis had a page for LongCat-2.0 but none for LongCat-2.5. The Agents’ Last Exam leaderboard, updated 16 November, did not list LongCat-2.5, although Meituan reports an in-house ALE v1.1 score of 38.5. Tech Times reported that an independent index gave LongCat-2.0 a notably different picture from its self-reported coding scores; we did not verify that report.
Why the hardware claim matters, and what it does not prove
The hardware story is significant for two reasons that do not depend on the benchmark table. First, if the claims hold, a Chinese company outside the chip industry has now trained and post-trained two successive 1.6-trillion-parameter models on non-Nvidia accelerators (“AI ASICs” in the LongCat-2.0 documents, “domestic AI accelerators” in the 2.5 documents) and published both under MIT. Second, the inference path Meituan documents runs on Huawei hardware with Huawei’s software stack and Meituan’s own serving fork. An open model whose first-class deployment target is not Nvidia is a different kind of release from one that merely could run elsewhere. Our analysis of TorchNeuron and AWS Trainium argued that the chip contest is increasingly a software contest; LongCat-2.5’s release is an example of a model shipping with its own non-Nvidia software path already built.
The documents do not prove three things. They do not show how efficient the training was: Meituan gives a relative throughput gain for its FSDP configuration but no accelerator-hours, no cluster size and no comparison with GPU training. They do not establish capability parity: the benchmark table is in-house and dated. And they do not show that the release is free of Nvidia hardware in every stage, because they never say so in those terms.
What would settle the question
Three kinds of evidence would turn Meituan’s hardware claim from an assertion into a documented fact. A technical report stating the accelerator model, count and accelerator-hours for LongCat-2.5’s training stages would answer the open questions directly. Confirmation from the chip supplier, presumably among the industry partners Meituan’s announcement mentions without naming, would establish the vendor. And independent reproduction of the published inference results on Ascend hardware would show that the documented deployment path works as described. Until one of those appears, the accurate summary is Meituan’s own: trained on domestic accelerators, served on Huawei Ascend.
What builders should do
- Treat the licence as the headline. MIT with no revenue thresholds is rare at this scale. If you are choosing an open base for fine-tuning and can host it, LongCat-2.5 is worth a licence-led shortlist.
- Plan for Ascend or the API. The only documented self-hosting path is 194 Atlas A2 accelerators. Teams on Nvidia should not assume a working recipe exists.
- Size from file sizes, not the headline. Budget 3.56 TB for BF16 weights or 1.34 TB for W4A4, before KV cache.
- Rerun the benchmarks that matter to you. Every LongCat-2.5 score in Meituan’s table is in-house and compared with older models. Test against the current models you would otherwise use.
- Test long context on your deployment. The API’s 1-million-token limit and the configuration’s 524,288-position default differ.
- Check API terms before sending sensitive data. Confirm data handling and pricing directly with Meituan; we could not find either on the public documentation pages we read.
- Quote the hardware claim precisely. Meituan’s 2.5 documents say domestic accelerators with under 80 GB of memory, and its site-wide page description says training ran entirely on domestic chips. It names Huawei only for inference.
LongCat-2.5 is a large, permissively licensed agent model with an unusual hardware story, and most of that story is Meituan’s own account. The weights are real and downloadable. The rest, from the training chips to the benchmark gains, is waiting for someone outside Meituan to check.
Sources
- LongCat-2.5 model card Meituan LongCat team, via Hugging Face
- Introducing LongCat-2.5 (technical blog) Meituan LongCat
- 美团 LongCat-2.5 正式开源:从看见,到抵达 (LongCat-2.5 open-source announcement) Meituan technical team
- LongCat-2.5-W4A4 model card Meituan LongCat team, via Hugging Face
- LongCat 2.5 W4A4 NPU inference deployment guide Meituan LongCat team on GitHub
- LongCat-2.5 config.json Meituan LongCat team, via Hugging Face
- LongCat-2.5 licence Meituan LongCat team, via Hugging Face
- LongCat API Platform quick start Meituan LongCat
- LongCat-2.0 model card Meituan LongCat team, via Hugging Face
- LongCat-2.0 technical blog Meituan LongCat
- LongCat-Next (arXiv 2603.27538) arXiv
- Agents' Last Exam leaderboard (ALE v1.1) Agents' Last Exam
- Meituan releases a 1.6-trillion-parameter agent model that never touched an Nvidia GPU The Decoder
- Meituan launches LongCat-2.5 multimodal AI model for extended coding tasks TechNode
- Meituan Releases LongCat 2.5 on Chinese Chips; Benchmark Claims Await Independent Tests Tech Times
Frequently asked questions
Was LongCat-2.5 trained without Nvidia GPUs?
Meituan says its training used domestic Chinese AI accelerators. A share-card description used across longcat.ai, including on the LongCat-2.5 and LongCat-2.0 blogs, states that training was completed entirely on domestic chips, and its technical sections describe long-sequence training and fine-tuning on domestic accelerators with under 80 GB of memory. Meituan does not name the chip or say in so many words that no Nvidia hardware was used anywhere; that phrasing comes from press coverage.
What chips did Meituan use for LongCat-2.5?
For training, Meituan's documents say only 'domestic AI accelerators' arranged in supernodes. For inference, its self-hosting guide names Huawei's Ascend Atlas A2 series and deploys the 4-bit model on 194 of them: 2 for image encoding, 64 for prefill and 128 for decoding.
Is LongCat-2.5 open source?
The weights are released under the MIT licence. Meituan's 10 November announcement says commercial inference deployment and further training are allowed without additional authorisation. The licence does not grant rights to Meituan trademarks or patents, according to the model card.
How big is LongCat-2.5?
Meituan describes 1.6 trillion total parameters with about 48 billion active per token. The Hugging Face safetensors metadata counts about 1.78 trillion parameters and the BF16 repository is about 3.56 TB; the 4-bit W4A4 repository is about 1.34 TB. Meituan does not explain the difference between 1.6 and 1.78 trillion.
What is LongCat-2.5's context window?
Meituan's API documentation lists a 1-million-token context window and a maximum output of 256,000 tokens. The model's config.json sets max_position_embeddings to 524,288, with a YaRN scaling factor of 120 on an 8,192-token original length.
Can I run LongCat-2.5 on Nvidia GPUs?
Meituan does not document it. The LongCat-2.5 model card says the model can be deployed on NPU platforms and links only an Ascend guide. LongCat-2.0's card, by contrast, offered a GPU path through SGLang. Its config.json also references custom modelling code that the repository does not include. Teams on Nvidia hardware should wait for a supported recipe or framework support.


