1.6 Trillion Parameters Under MIT: Meituan Open-Sourced LongCat-2.5, but Your Computer Can't Run It
Meituan released LongCat-2.5, a 1.6-trillion-parameter model, under the MIT license: commercial use, modification, and further training need no extra permission. It scores 88.4 on Terminal-Bench v2.1 and a table-topping 91.9 on BrowseComp. But the BF16 weights weigh 3.56 TB, deployment so far covers NPU only, and the table mixes in-house scores with public ones — read the asterisks.

Let us get one thing straight first, so this piece does not get mixed up with two recent articles that look similar at a glance. In October we covered the open weights of Kimi K3.1 Pro, a coding model from a different company (Moonshot AI). On November 10 we covered the open weights of MiniMax H3-Image, a text-to-image model. Today's subject is Meituan's LongCat-2.5, a native multimodal coding model built for long-horizon agent tasks. Different company, different kind of model, different reason to care: Kimi was about a coding model catching up with closed models, MiniMax was about image speed and a license that excludes whole regions, and LongCat-2.5 is about something else — a 1.6-trillion-parameter giant released under the MIT license, which leaves every reader with the same unavoidable question: your computer cannot run it.
The dates need explaining up front, because they are easy to get wrong. The model itself was released on November 2, 2026; the weights went up on Hugging Face on November 9 (US Pacific time), and Meituan formally announced the open-sourcing on November 10 Beijing time. Three dates, one event, three traces left in three time zones and three stages of the release. Unless a different source level is noted, every fact below comes from the official Hugging Face model card meituan-longcat/LongCat-2.5, read and checked in person on November 16, 2026.
Start by pulling the two numbers in the headline apart. The total parameter count is 1.6 trillion, but only about 48 billion are activated per token. That is the standard deal with MoE (mixture-of-experts) architecture: all the parameters sit there, but each inference wakes up only a small slice to do the work. 48 billion activated parameters is roughly the size of a top-tier dense model on its own. In other words, LongCat-2.5 does not win by using its whole brain every time; it wins by having a very big brain and using only the right part of it each time. That design choice determines everything that follows, the strengths and the headaches alike: a high capability ceiling on one side, and a weight file of frightening size on the other.
What exactly is this model?
The first sentence of the model card pins the positioning down: a native multimodal MoE model for long-horizon agentic tasks. The word "long-horizon" is worth pausing on. Most coding models are good at short, sharp jobs: fill in a function, fix an error, answer a question. Long-horizon agent work is a different tier: hand the model a vague goal and let it break the goal into steps, look things up, write code, run tests, and backtrack and fix its own mistakes when something breaks, for hours at a time. The model card says LongCat-2.5 combines visual understanding with agentic coding for complex codebase development, full-project builds, creative design, and 3D tasks. Note the combination: vision plus coding means it does not only read code, it can look at pictures, interfaces, and rendered output — an extra eye that matters when the job is front-end work, 3D, or design.
Meituan lists four technical selling points in the model card: native visual modeling (native-resolution visual features converted into discrete tokens and aligned with text in a shared semantic space); long-horizon agentic RL (trained on real-world engineering tasks and reproducible agent failures, with safeguards against reward hacking); multi-teacher learning (specialized agent, reasoning, and interaction teachers guiding the model); and efficient long-context training (a claimed 86% higher per-device throughput than the DDP baseline in long-sequence fine-tuning). The first three are capability claims; the fourth is an engineering claim. Readers do not need to unpack every term. The one judgment to take away is this: the story Meituan wants to tell is not "we trained another big model" but "this model was trained specifically to carry long jobs through to the end." If that is true, its rivals are not general chat models but the models already established in agent scenarios, such as Claude Code and GPT-5.6. The big table in the model card is lined up exactly that way: there is not a single pure chat model in the comparison set, only hard cases from agent scenarios.
The model supports thinking mode on and off. With thinking on and all reasoning content kept, performance is better; with it off, token use is lower. The official chat entry point is longcat.ai. Anyone who wants a feel for it should just try the web version first — a few minutes of chatting there tells you more than ten pages of benchmarks.
The MIT license: genuinely generous, but with two lines
The most remarkable part of this release may not be the parameter count but the license. The model weights are released under the MIT License. MIT is the loosest of the common open-source licenses: commercial use is allowed, modification is allowed, using the weights for further training is allowed, and none of it needs an extra authorization from Meituan. For a 1.6-trillion-parameter model, that is an uncommon decision. In recent months, open-weight releases from large model builders have usually carried a community license with strings attached: commercial use depends on scale, modifications need attribution, or whole regions are excluded outright. Meituan did none of that. It went straight to MIT.
Generous as that is, the license section of the model card draws two lines that must be read carefully. First, MIT covers the model weights. Second, the license grants no rights to use Meituan trademarks or patents. In plain language: you can take the weights, make money with them, change them, and train your own version — but you cannot sell them under Meituan's brand, and you should not assume you have received any related patent rights. Those two lines are short, but they carry the most legal weight in the whole model card. Any team planning commercial use should read the LICENSE file in full before downloading, not just glance at the "MIT" badge.
One more detail is worth noting: the model card says any contributions to the repository are licensed under MIT as well, unless otherwise stated. That settles the rules for community work after the release — pull requests, bug reports, improvements, all under the same license framework. For developers who want to take part, that simplicity is good news: fewer rules means fewer arguments.
Read the scoreboard, then read the asterisks
The model card includes a large evaluation table spanning coding agents, general agents, and visual tasks. The headline numbers first: 88.4 on Terminal-Bench v2.1; 91.9 on BrowseComp, the highest score in the whole table; 64.6 on DeepSWE v1.1; 82.1 on PaperBench; 83.1 on MCP Atlas; 78.6 on Vision2Web; and 55.4 on 3DCodeBench (text-to-3D). Taken on their own, those are strong numbers.
But — and this is the most important "but" in this article — the model card draws a line right above the table: scores marked with an asterisk are cited from public technical reports, blog posts, or official leaderboards; unmarked scores were measured in-house by Meituan and are indicative only. Almost all of LongCat-2.5's own scores are unmarked in-house numbers, while many of the comparison scores for Opus 5, GPT-5.6-Sol, and DeepSeek-V4.1-Flash carry asterisks. In the same table, the two kinds of scores do not carry the same weight. Read the table with the asterisks, or you end up comparing Meituan's own test, run under Meituan's own conditions, against other models' public leaderboard scores.
Take Terminal-Bench v2.1 as the example. The chart above lays the gap out plainly: DeepSeek-V4.1-Flash at 90.6 (asterisked), Claude Opus 5 at 89.1 (asterisked), GPT-5.6-Sol at 88.8 (asterisked), and LongCat-2.5 at 88.4 (measured in-house). All four sit inside a narrow 2.2-point band. LongCat-2.5 ranks fourth, but a gap of 2.2 points may mean nothing at all under different test conditions. The footnotes state the in-house conditions transparently enough: thinking mode on, temperature 1.0, top_p 0.95, and the Terminal-Bench v2.1 result averaged over three independent runs. The problem is that the public scores for the comparison models were not necessarily produced under the same setup. Same table, two different rulers — a common flaw in vendor-published benchmark tables, not a Meituan-only problem, but readers need to know there are two rulers.
The BrowseComp score of 91.9 deserves a paragraph of its own. It is genuinely the highest in the table, 1.1 points above Opus 5's 90.8 (asterisked). BrowseComp tests deep web research: give the model a tricky question and let it browse, cross-check sources, and answer with evidence. That is a direct test of long-horizon agent ability, because it examines exactly the skill set of finding its own path, verifying its own work, and not making things up. LongCat-2.5 topping this benchmark lines up with its positioning as a long-horizon agent model. The same caveat still applies, though: 91.9 is an in-house score, and the footnote says it used a custom lightweight harness with only the search and goal-directed browsing tools available, capped at 1,024 exploration rounds. A high score is good news, but treat it as a promising signal rather than a settled first place until an independent party reproduces it under the same public conditions.
The biggest progress is not in the total score, but in the generation gap
The part of the table that really makes you sit up is not how LongCat-2.5 compares with Opus 5, but how it compares with its own predecessor, LongCat-2.0. Terminal-Bench v2.1 rose from 70.8 to 88.4; DeepSWE v1.1 from 9.7 to 64.6, more than sixfold; Terminal-Bench v4.0 from 3.0 to 38.5, more than twelvefold; PaperBench from 45.2 to 82.1; BrowseComp from 79.9 to 91.9; MCP Atlas from 61.8 to 83.1.
DeepSWE and Terminal-Bench v4.0 are the most telling. The previous generation effectively handed in a blank sheet on those two: 9.7 and 3.0 mean it could barely complete genuinely hard software engineering tasks at all. This generation jumps to 64.6 and 38.5. Even after discounting for the possibility that in-house testing runs optimistic, a jump of this size is hard to explain away as friendly test conditions alone. The more likely reading is that the previous generation's agent training pipeline had a real weakness, and this version fixed the long-horizon RL and multi-teacher distillation stages, so the model finally learned to carry a long job from start to finish.
Terminal-Bench v4.0's 38.5 also deserves a cooler look. Version 4.0 is newer and harder than v2.1; Opus 5 scores 53.9 on it (asterisked), leaving LongCat-2.5 more than 15 points behind. In other words, on the hardest tier of tasks, LongCat-2.5 has pushed into the neighborhood of the first tier but has not yet drawn level. The 88.4 on v2.1 looks like a tie; the 38.5 on v4.0 states the real distance. Read both tiers together — that is the complete judgment.
Do not skip the visual results either. Vision2Web scores 78.6, testing the ability to write a web page from a picture; 3DCodeBench scores 55.4, testing text-to-3D generation. These are unusual items for a coding model, and they map directly onto the "creative design and 3D tasks" mentioned at the top of the model card. The 55.4 on 3DCodeBench is also the highest in the table (Opus 5 at 54.3, GPT-5.6-Sol at 52.3). The margin is small, but it at least shows that the vision-plus-coding combination is not decoration: on tasks that require understanding what something looks like before writing code for it, LongCat-2.5 has something real.
3.56 TB: open source does not mean runnable
That was the good news. Now for the second half of this article's headline. The full BF16 weights weigh about 3.56 TB, split across 208 safetensors files. To put 3.56 TB in perspective: a common 4 TB portable drive would have only a few hundred gigabytes left after holding it, and a mainstream high-end PC with a 2 TB SSD could not even store the download. And even if you had the space, the memory and compute needed to run it are far beyond consumer hardware. The W4A4 quantized version is about 1.34 TB — much smaller, but still not a "download it and play" size.
So "MIT license, free for commercial use" and "your computer cannot run it" are not contradictory; they are two sides of the same thing. Meituan has lowered the licensing barrier to the floor; the physical barrier remains sky-high. The people who can actually run this model are institutions and companies with clusters, budgets, and operations teams — not individual developers. That is not cold water; it is what happens when you take the word "open source" apart. Open weights answer the question "am I allowed to use it?" They do not answer the question "can I afford to run it?" For most people, the right way to use LongCat-2.5 is to chat with it on longcat.ai, or wait for a cloud provider to put it behind an API — not to download the weights yourself.
The quantization section does offer institutional users a real step down. The model card says LongCat-2.5 applies W4A4 quantization to expert weights and activations (4-bit), enabling native INT4 computation on domestic AI accelerators. In online stress tests against a W8A8 MoE baseline, prefill throughput is 43.3% higher, decode throughput 42.77% higher, time to first token 15.91% lower, and time per output token 19.72% lower; with KV cache quantization added, W4A4KV8 delivers 92% higher decode throughput than W8A8KV16. These are Meituan's own online test results, not independent reproductions, and they should be quoted with that qualifier attached. But the direction is clear: Meituan is seriously working on making this 1.6-trillion-parameter model cheaper and faster to serve. After all, an open model nobody can afford to run is of no use to anyone, however open it is.
Deployment covers NPU only; NVIDIA users should wait
The deployment section of the model card is two lines long: LongCat-2.5 can be deployed on NPU platforms, and for NPU deployment, see Meituan's SGLang-FluentLLM branch (the longcat-2.5-npu branch). There is no NVIDIA route, no vLLM, no Transformers, no llama.cpp. As of November 12, none of those four mainstream inference frameworks had official support for this architecture. The hands-on deployment guide uses 194 Atlas A2 (Ascend) cards — note that this number comes from the deployment guide, not from the model card text, and the source level matters.
What does that mean in practice? It means LongCat-2.5 is, for now, an open release with a threshold: the weights are yours, the license could not be looser, but the road to actually running them has only been paved once so far, and it is paved on NPU. Teams on NVIDIA cards, teams on vLLM, and teams hoping to load the model directly in Transformers all have to wait — for community ports, for Meituan to add routes, or for someone to take the architecture apart by hand. Community ports usually do not take long for a popular model; someone always takes the job. But "someone always does" is not the same as "it already exists," and the gap between the two is time and a pile of debugging.
That situation is connected to the model's training background, which is the subject of the next section.
"Trained on domestic chips" can only be quoted, not stated as fact
The model card's introduction says LongCat-2.5's capabilities rest on "infrastructure optimizations on domestic AI accelerators," and elsewhere it says the training was completed on domestic chips. Both are Meituan's own claims. The model card offers no independent verification and no public details of the training cluster. When writing this report, that sentence can only be quoted, not presented as a verified conclusion. Why insist on this point? Because "a 1.6-trillion-parameter model trained on domestic chips" would be a significant engineering signal if true — and precisely because it matters, it needs independent evidence rather than a single line in a model card.
The same caution applies to the wording in the quantization section. The model card says the quantization "enables native INT4 computation on domestic AI accelerators," which is consistent with the NPU deployment story — the whole deployment narrative is built around domestic accelerators. But consistency is not verification. Consistency only shows that Meituan's story hangs together; verification needs numbers produced by a third party running on real hardware. Those numbers do not exist yet. Readers should file this as an item pending verification and wait for independent test reports before drawing conclusions.
That is not holding Meituan to an unfair standard; it is the standard every vendor's model card should be held to. A vendor saying its model is strong is advertising; a third party running it and finding it strong is news. LongCat-2.5's evaluation table already marks that distinction with asterisks. The training-hardware claim should be treated by the same standard.
Two numbers do not add up, and one claim never made it into the model card
Reading the model card carefully turns up two discrepancies that have to be stated plainly rather than smoothed over. First, the model card says the total parameter count is 1.6 trillion, but summing the weight tensors on Hugging Face gives roughly 1.78 trillion. The two differ by about 0.18 trillion, and no official explanation has reconciled them so far. Possible causes include different counting conventions (whether embedding layers or shared experts are counted, for example), or the 1.6 trillion in the model card being a rounded figure. But "possible" is not "certain," and until Meituan explains it, this article can only place the two numbers side by side and tell readers they do not match. The 1.6 trillion in the headline follows the model card's official figure; this paragraph supplies the unreconciled 1.78 trillion so readers can judge for themselves.
Second, two claims circulating online — a 1M context window and a limited-time API price of $0.30 per million input tokens and $1.20 per million output tokens — do not appear in the model card at all. The figure 1M does show up once in a footnote: the DeepSWE v1.1 evaluation settings list a maximum sequence length of 1M. But that is a setting used during evaluation, not a context window claimed by the model card, and the two must not be confused. As for the API price, it appears only in secondary sources; the model card is silent, and the pricing page on longcat.ai is the right place to verify it. Until secondary sources are verified, this article only records that the claims exist and the model card does not contain them — it does not repeat them as fact.
Neither discrepancy changes the value judgment on LongCat-2.5 itself, but both change how it should be read: this is an open release worth paying attention to, yet many of the numbers around it still sit somewhere between "the vendor says so" and "the community is passing it on," not yet at "verified fact." Good reporting does not hide those seams; it points at them, so readers know what is confirmed and what is still waiting.
Who should try it now, and who should wait
If you are an individual developer, the best move is to go to longcat.ai and just use it. The web version needs no 3.56 TB download and no 194 cards; a few minutes is enough to find out how it performs on your tasks. Test two kinds of work in particular: first, long, multi-step coding jobs, such as "refactor this old project and add tests along the way"; second, visual jobs, such as "write a page from this design mockup" or "generate a 3D model from this description." Those two are exactly the strengths LongCat-2.5 claims, and they are the fastest way to find out whether the claims hold up.
If you are a tech lead choosing an agent coding model for your team, LongCat-2.5 belongs on the shortlist, but do not rush to replace your current main model. Three reasons: first, the benchmark table leans heavily on in-house scores, so it is safer to wait for independent reproductions before deciding; second, the deployment route currently covers NPU only, and whether your existing infrastructure is NPU-based directly sets the adoption cost; third, the MIT license is genuinely friendly and legal friction is low, but that is only the first step — the real cost sits in deployment and operations. Start with small-scale side-by-side tests on the API or the web version, using your own tasks and your own codebase. That tells you more than any benchmark table.
If you work on inference frameworks or hardware ports, LongCat-2.5 is instead the model most worth jumping on right now. 1.6 trillion parameters, an MIT license, and heavy community attention add up to this: whoever ships vLLM, Transformers, or llama.cpp support first will catch the first wave of traffic and reputation. The NPU branch in the model card is already public, the architecture details are not a black box, and all that is missing is someone to carry it onto more hardware.
Back to the headline. Meituan releasing a 1.6-trillion-parameter model under the MIT license deserves credit — the looser the license, the more genuine the open-sourcing, and the more the community can do with it. But generosity is not the same as usability. 3.56 TB of weights, a deployment guide built around 194 Ascend cards, and still no official NVIDIA route: those facts decide who this release is for first — institutions with clusters — and who it is for second — everyone else. The right move for ordinary developers is not to download the weights, but to try the web version first, wait for the community to bring the deployment bar down, and then decide whether to bring it into their own toolbox. The model is open now; the excitement has only just started, and the real show begins when independent reproductions and community ports arrive.
Comments (0)
Sources
Related articles
On 20 November 2026, Thinking Machines Lab released Inkling 2 Mini: a 26.4B-parameter looped transformer that runs its middle 12 layers three times per token, fits in about 20GB, and runs offline on a laptop. It leads open-weights models of its size on DeepSWE and SWE-bench Verified — with the caveats printed in the same announcement.
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.