LongCat-2.5: Meituan Opens 1.6T-Parameter MoE Under MIT
Meituan released the weights of LongCat-2.5 on 9 November, one week after it introduced the model. The checkpoint went up on Hugging Face under the MIT licence, which permits commercial use, modification and redistribution, and it is a big one: 1.6 trillion total parameters in a mixture of experts, with about 48 billion active per token. Meituan has also published a technical write-up and an API guide, which is where the numbers in this piece come from.
The timing matters as much as the size. Chinese labs have spent the year closing the gap on frontier coding and agentic work. LongCat-2.5 is Meituan's attempt to make the open-weight route competitive at a price that hosted frontier models cannot match. Whether it succeeds depends on three questions. How good is the model actually, what does it cost to run, and will the politics of a Chinese checkpoint get in the way?
What LongCat-2.5 is, and what shipped
The account below draws on VentureBeat's close reading of the launch and on MLQ's summary of the same material, alongside Meituan's own documentation.
LongCat-2.5 is a multimodal model built on LongCat-2.0, Meituan's earlier flagship. It represents visual information as tokens and processes them alongside text. The API accepts screenshots, charts, images and video, with one constraint worth noting: images can be embedded in the request or supplied by URL, while video must be supplied by URL, which complicates workflows that use internal screen recordings.
The intended workload is agentic coding that needs eyes. The clearest use case is handing the model a screenshot of a broken interface, pointing it at a repository, and asking it to find the relevant components, propose a patch and verify the result. Meituan demonstrated exactly that pattern, alongside demos that included a car launch site, a fantasy game interface and a shop management tool.
Everything ships under MIT. For teams that were waiting on licence terms before touching a Chinese open-weight model, this is the most permissive licence short of public domain, and it does not restrict commercial deployment.
The vision workflow, in practice
The interesting use cases are the ones where a screenshot is the input, and Meituan's material suggests a specific pattern for them.
A visual regression test with a known fix is the best starting point for judging LongCat-2.5. Give the model the failing screenshot, access to a test repository, and a way to render the patched page. Then check whether it finds the cause, makes a targeted change, and preserves keyboard navigation and responsive behaviour. That last part is where most demonstrations fall short: a generated page can look right in a screenshot and still break the component library and interaction rules a production storefront depends on.
The same workflow runs in reverse for design-to-code work. Turn a design reference into a prototype, then score the result against the team's component library rather than against the screenshot alone. Meituan's own examples include an interactive fluid simulation and a 3D exhibition, which are good leads for demos and internal tools. A demo and a production deployment have different acceptance criteria, and the second one is the test that matters.
The video constraint deserves a note in planning. Because the documented video interface takes a URL rather than an upload, teams working with internal screen recordings need somewhere to host those recordings first, which is a data governance question as much as a technical one.
What the benchmarks actually say
Meituan's own numbers show a large jump over its predecessor and a more complicated picture against the frontier.
Against LongCat-2.0, the gains are unambiguous, and they are the strongest argument for taking LongCat-2.5 seriously. Terminal Bench v2.1 rises from 70.8 to 88.4, DeepSWE v1.1 goes from 9.7 to 64.6, and the SWE Atlas codebase test moves from 33.1 to 58.3. Whatever else is true, LongCat-2.5 is a different class of coding model than the one Meituan shipped last time. Teams that ruled out LongCat-2.0 for repository work have the most reason to retest, because LongCat-2.5 is a different model on exactly the tasks that failed last time.
Against the frontier, the honest summary is: close on some tasks, behind on others. On Terminal Bench v2.1, LongCat-2.5's 88.4 sits within a point of GPT-5.6 Sol at 88.8 and Claude Opus 5 at 89.1. On the harder v4.0 version, it scores 38.5 against Opus 5's 53.9, and the current leaderboard leaders, GPT-6.1 Sol at 58.2 and Claude Opus 5.5 at 64.8, are well ahead. DeepSeek-V4.1-Flash beats it on Terminal Bench and DeepSWE, while LongCat leads that group on 3DCodeBench.
There is a catch in the comparison that Meituan's own table makes visible. The company chose GPT-5.6 Sol and Claude Opus 5 as its proprietary reference points, but both models have successors that shipped before LongCat-2.5 was announced. GPT-6.1 Sol arrived on 29 September and Opus 5.5 on 22 September. Measuring against the previous generation is a legitimate choice, and it suggests the real claim is sub-frontier performance at a fraction of the price rather than parity with the best models on the market.
Vision results split the same way. LongCat-2.5 scores 78.6 on Vision2Web against Opus 5's 80.2, and leads its peer group on 3DCodeBench at 55.4. For screenshot-to-code work at this size class, that is competitive rather than dominant.
One methodological note belongs here, because the table mixes two kinds of numbers. Meituan combines its own runs with published leaderboard results, and the leaderboard entries for GPT-6.1 Sol and Opus 5.5 were produced with maximum effort settings and their respective coding tools, Codex and Claude Code. Those are reference points for the same benchmark version under different test setups, not a clean head-to-head. Where a cell shows a dash, no verified result exists at all. Anyone quoting these numbers in a procurement document should quote the setup alongside them.
The pricing is the real story
Meituan's hosted rate card is aggressive. The limited-time rate is 0.30 dollars per million uncached input tokens and 1.20 dollars per million output tokens, with cached input at 0.006 dollars per million.
The worked example makes the gap concrete. A run with 200,000 uncached input tokens and 100,000 billable output tokens costs 0.18 dollars on LongCat-2.5. The same token volume costs 0.09 dollars on DeepSeek at off-peak rates, 1.40 dollars on GPT-6.1 Sol, 2.80 dollars on Opus 5.5, 5.60 dollars on Claude Fable 5.2 and 7 dollars on GPT-6 Astra.
Even against the cheaper successors, LongCat keeps a large advantage. GPT-6.1 Sol charges half of GPT-5.6 Sol's promotional rate, and Opus 5.5 costs less per token than Opus 5, and LongCat-2.5 still undercuts both by a wide margin.
Two cautions belong next to that arithmetic. First, models spend different amounts of tokens on reasoning, tool calls and retries, so cost per run is not cost per accepted result. Second, DeepSeek's off-peak price is the real benchmark for what downloadable weights plus a cheap API should cost, and against that comparator the advantage narrows to a factor of two rather than thirty.
For agent workloads that repeatedly send a stable prompt prefix or large repository context, cache hit rate matters more than the headline input price, and the only way to measure it is inside the tool the team actually uses.
The metric that should end the evaluation is cost per accepted result. Include retries, browser or sandbox time, any fallback call to a stronger model, and the engineering time spent reviewing patches. A cheap model that produces rejected patches is more expensive than a costly one whose patches land, and the only way to know which side LongCat-2.5 falls on for a given team is to measure it on that team's own tasks.
Self-hosting is a different calculation
The MIT licence makes the weights free. Running them is not.
A mixture of experts model routes each token through a subset of its experts. Serving it still requires the full checkpoint in memory. At two bytes per parameter, 1.6 trillion parameters implies roughly 3.2 terabytes for weights alone in a uniform 16-bit representation, before runtime buffers and context. The Hugging Face metadata shows 1.8 trillion total, Meituan's technical description says 1.6 trillion, and the honest answer is to size a deployment from the actual files and serving format rather than from either number.
Meituan's own deployment notes describe quantising expert weights and activations to four bits on Chinese accelerators, with an SGLang based guide for neural processing units. That is evidence about Meituan's tested setup, not about what the model will do on an Nvidia fleet or a heterogeneous cluster. Teams with different hardware need to validate that the serving runtime loads the checkpoint and preserves the visual and tool-use behaviour before believing any benchmark.
The practical split is therefore simple. If the visual coding workload is large or sensitive enough to justify owning a multi-terabyte serving stack, the weights are worth evaluating seriously. If the workload is occasional prototyping, the hosted API at these prices is the cheaper experiment by a wide margin, with the caveat that company code and screenshots end up on someone else's infrastructure.
What Meituan gets out of giving it away
Releasing weights under MIT is not charity, and it is worth being clear about what Meituan buys with the gesture.
The first return is ecosystem pull. Every developer who builds a tool, an agent or a product on LongCat-2.5 becomes someone who evaluates the next LongCat release, and the hosted API is positioned so that the natural path from weights to revenue runs through Meituan's own rate card. The second is standard-setting. A 1.6 trillion parameter model at 0.30 dollars per million input tokens sets an expectation that other Chinese labs now have to meet or beat on their next releases. The third is feedback at scale, because thousands of independent deployments surface failure modes that an internal evaluation never will.
There is also a defensive reading. Open weights make a model harder to exclude from a market, because the technology is already distributed before any order can name it. Whether Meituan intends that effect or not, the DeepSeek episode shows why a distributed checkpoint is a different policy object than a hosted service.
None of this requires the model to beat the frontier. It requires enough capability that the price difference does the persuading, which is exactly the position LongCat-2.5 occupies.
The Washington question
No discussion of a Chinese open-weight model in late 2026 can skip procurement politics.
In October, the United States Department of Homeland Security disclosed an order directing federal civilian agencies to exclude DeepSeek from procurement. The same order requires agencies to remove that technology from covered systems, including versions supplied through third parties. VentureBeat found no publicly disclosed restriction that names Meituan or LongCat-2.5 as of 9 November. The DeepSeek order shows how quickly that can change, and how a restriction can follow the technology into a third-party deployment.
The story has an unexpected domestic echo. In late February, the Defense Secretary announced the designation of Anthropic as a supply-chain risk to national security, formalising it in early March. The lesson from both cases is the same: eligibility is a policy variable, not a technical one, and it can move between one procurement cycle and the next.
For anyone serving United States government clients, the checklist is therefore contract terms first, applicable federal supply-chain orders second, and model quality a distant third. For everyone else, the relevant question is data governance on the hosted API: retention, access and deletion terms should be established before uploading proprietary code or screenshots, and a sandbox with synthetic artifacts is enough to learn whether the model merits a deeper review.
How to trial it without fooling yourself
The failure mode with LongCat-2.5 is a benchmark-driven decision. The better trial holds everything constant and measures what the team cares about. A two-week trial on ten real tasks will tell you more about LongCat-2.5 than any published table.
Give each model the same repository state, browser, test suite, tool permissions and time limit. Repeat tasks to see how often each succeeds, because single runs hide variance. For screenshot-to-code work, score the rendered result and the code separately, since a page that looks right can be built from components the team cannot maintain. For bug fixes, check whether the patch addresses the cause and whether a reviewer has to redo it, because a polished answer can hide a failed tool call.
Start with three tasks: a screenshot-driven bug fix, a design-to-code conversion, and a text-only repository task as a control. If LongCat-2.5 gets more of the visual work through review at a lower all-in cost, route that work to it and keep a stronger model as the fallback for the cases it fails. A cluster purchase can wait until the trial shows how often the advantage appears and what it is worth.
For teams that already route between models by task, gateway tooling makes this kind of two-model strategy cheap to operate, and automatic routing is moving in the same direction: the unit of decision is shifting from which vendor to which model per task.
What it means for the open-weight market
LongCat-2.5 is the strongest signal yet that the open-weight tier is becoming a product category with its own price point, rather than a discount version of the frontier. The pattern is now familiar. A Chinese lab ships a model within a point or two of last generation's frontier on selected agentic benchmarks. It prices the hosted API an order of magnitude below the frontier. It puts permissive weights on Hugging Face.
The interesting question is what that does to the models above it. If LongCat-2.5 establishes that a sub-frontier model at a fraction of the price can hold the routine workload, the premium tier shrinks to genuinely hard cases, and the economics of every model above it change with that shift. If a 0.18 dollar run covers the majority of routine maintenance work, the premium models get reserved for genuinely hard cases, which changes their economics too. Meituan is not trying to beat GPT-6.1 Sol. It is trying to make the frontier unnecessary for most work, and at these prices the argument is at least worth testing.
Teams building on Qwen-derived stacks or running open models behind their own serving layer should find LongCat-2.5 straightforward to evaluate, because nothing about the licence or the tooling is unusual. The barrier is operational, not legal.
Questions readers are asking
Is LongCat-2.5 open source?
The weights are released under the MIT licence, which allows commercial use, modification and redistribution subject to notice requirements. The training data and code are not fully open in the way some smaller releases are, so open-weight rather than open-source is the accurate description.
Can it run on consumer hardware?
No. With roughly 1.6 trillion total parameters and a full checkpoint required at serving time, self-hosting is a multi-terabyte, multi-GPU undertaking. LongCat-2.5 is a datacentre model, and the realistic consumer path is the hosted API.
How does it compare with DeepSeek?
On Meituan's table, DeepSeek-V4.1-Flash scores higher than LongCat-2.5 on Terminal Bench and DeepSWE, while LongCat-2.5 leads on 3DCodeBench and costs more per token than DeepSeek's off-peak rates. If the workload is text-heavy maintenance coding, DeepSeek remains the cheaper first comparator. If it is visual work, LongCat-2.5 is the stronger candidate of the two.
Should United States companies avoid it?
There is no published restriction naming LongCat-2.5 as of 9 November. The prudent position is to treat eligibility as a standing question, keep a second model tested on the same tasks, and check contract terms before putting any Chinese checkpoint into government-facing work.
The bottom line
LongCat-2.5 is a competent, competitively priced multimodal coding model with permissive weights, and its benchmarks were built to make exactly that case. It is not frontier, and Meituan's choice of older reference models tells you the company knows it. That honesty about positioning is more useful than a benchmark table trying to hide it, and LongCat-2.5 will live or die on the workflow question rather than on the leaderboard.
The decision it forces is about workflow, not quality. At 0.30 dollars per million input tokens, the cheap path to finding out whether it handles a team's visual coding work is to test it, measure cost per accepted result, and route accordingly. The expensive path is buying a serving cluster for a 1.6 trillion parameter checkpoint before the trial has earned it.