Introduction: the model I did not expect from a food-delivery company
I will be honest about my first reaction. When I hear "Meituan," I think of food delivery, not frontier AI models. That is exactly why LongCat-2.5 caught my attention. Meituan, the Chinese delivery and local-services company, has now put a 1.6-trillion-parameter model into general availability, and it is not positioned as a chatbot toy. It is positioned as a workhorse for long-horizon agent tasks: multi-step jobs where an AI does not just answer one question, but works through a terminal, a browser, a spreadsheet, or a design tool until something is actually done.
The timing matters too. LongCat-2.5 follows a preview released on September 25, 2026, and reached general availability on its developer platform on November 2, 2026. It builds on LongCat-2.0, which debuted in June 2026. So this is not a one-off announcement; it is the second major step in a product line Meituan is clearly investing in. For those of us who build websites and ship code every day, the question is not whether a delivery company can train a big model. It is whether this model changes the economics of running a coding agent — and on the numbers published so far, it might.
What Meituan actually shipped
Let us start with the verified facts, because model launches are where hype usually outruns the spec sheet.
LongCat-2.5 is a mixture-of-experts model with 1.6 trillion total parameters, of which approximately 48 billion are active per token. That distinction matters more than the trillion number. The total is the size of the whole model; the active count is what actually runs for each token, and it shapes speed and cost. By that measure, LongCat-2.5 is a roughly 48-billion-active-parameter model with a very large routing system around it — about 3% of its total parameters active at any moment.
It is natively multimodal, built to handle more than plain text from the start. It supports a 1-million-token context window, with a maximum output of 128,000 tokens. A million tokens is hundreds of thousands of words, enough to hold a large codebase, a long set of documents, or a multi-stage workflow in working memory at once. The 128,000-token output ceiling matters just as much for agents, because long runs do not just read a lot — they write a lot, in plans, tool calls, diffs, and summaries.
Meituan positions the model for work across terminals, browsers, graphical interfaces, spreadsheets, and design tools. That list is a clue to the intended user. This is pitched at someone handing an agent a repository and a task and expecting it to keep going, not at someone asking for a poem.
Access, for now, is through Meituan's chat service and its API platform. The API speaks both the OpenAI and the Anthropic request formats, a practical detail I appreciate: the model can drop into an existing Claude Code or OpenAI-compatible harness by changing a base URL rather than rewriting a client. It is also listed on Vercel's AI Gateway at the same headline rates, giving teams outside China a familiar route to try it.
One thing to be clear about: the weights are not open yet. Meituan marks the GitHub and Hugging Face releases as "coming soon." So today you cannot download LongCat-2.5 and self-host it. You use it through an API, and anyone telling you otherwise is getting ahead of the release.
The price is the real story
Model announcements usually bury the price. Here, the price is the story.
On Meituan's own platform, LongCat-2.5 is listed at limited-time discounted rates of $0.30 per million uncached input tokens, $0.006 per million cached input tokens, and $1.20 per million output tokens. No end date for the discount has been published, and the platform notes that prices may change — so treat those numbers as today's launch pricing, not a permanent promise.
Let me make that concrete with the kind of run I actually do. Suppose an agent session reads 500,000 tokens of uncached context — a decent chunk of a WordPress theme and its plugins — and writes 50,000 tokens of output in plans, edits, and summaries. At the listed rates, the input costs $0.15 and the output costs $0.06, for a total of $0.21 for that session. If the same context is largely cached on a follow-up run, the input side collapses to almost nothing, and the bill is dominated by output. That is the shape of the deal: cheap reading, with output as the thing you actually pay for.
That shape fits how agents really work: a long run re-reads context again and again, and a cache-hit rate of $0.006 per million tokens changes that arithmetic completely, at least while the discount lasts. A cheap model that needs three attempts is still not cheaper than a pricier model that gets it right first time, so the headline rates are a reason to test, not a verdict.
The benchmarks: read them with the caveats attached
Every model launch comes with a benchmark table, and LongCat-2.5 is no exception. I want to handle this carefully, because benchmark claims are where launches most often mislead.
Meituan's own benchmark table, as counted by independent coverage, puts LongCat-2.5 above OpenAI's GPT-5.6-Sol on 20 of 27 tests where both models have a score, and above Claude Opus 5 on 10. Those are Meituan's numbers. Rival scores in the table come from public reports or leaderboards, and the rest were run by Meituan itself and described as indicative only. They have not been independently verified. My rule for benchmark tables is simple: treat them as a reason to test, never as a verdict. If a model claims strength on agent benchmarks, the test that matters is your repository, your task, and your definition of done.
There is also a useful counterweight published in the same week. SemiAnalysis launched GDPx on November 2, a benchmark built around tasks drawn from real economic work across 11 domains, from chip design and cybersecurity to legal work and quantitative trading. The best model in that benchmark, Anthropic's Claude Opus 5.5, scored 12.0%, with finance and legal scoring zero across the board. That is a sobering number, and a good antidote to launch-week excitement: even the strongest agents today complete only a small fraction of genuinely hard, real-world work unaided. A million tokens of context does not fix that. It gives the agent more room to work — and more room to go wrong in interesting ways.
What this means if you build on WordPress and Elementor
So what does a 1-million-token agent model mean for someone whose daily work is WordPress sites, Elementor layouts, and client deadlines? More than you might think, and less than the hype suggests.
The obvious use is the whole-project agent run. A WordPress build is not one file; it is a theme, a child theme, a set of plugins, custom post types, Elementor templates exported as JSON, and configuration that only makes sense together. A small context window forces an agent to work file by file and forget the rest. A million-token window lets it hold the whole picture: the template hierarchy, the plugin that registers the post type, the CSS that already handles the breakpoint, and the client requirement that changed halfway through. That is the difference between an agent that edits a file and an agent that understands a site.
But a bigger window is not a bigger brain. The GDPx result above is the warning label. An agent with a million tokens of context can still misunderstand the task, overwrite the wrong template, and produce a confident, plausible, broken result. The longer the run, the more you need guardrails: version control before the agent starts, a staging site rather than production, tests that actually run, and a human reading the diff before anything ships. The rule that has saved me most often is the simplest one: never let an agent touch production, and never merge a diff you have not read.
There is also a practical angle in the API compatibility. Because LongCat-2.5 speaks OpenAI- and Anthropic-format APIs, you do not need a new toolchain to try it. Point an existing agent harness at a new base URL, run it against a staging copy of a real site, and compare the result with whatever you use today. That low switching cost is, to me, the most developer-friendly part of this launch.
For freelancers and small agencies, that pricing also changes scoping: a model that reads a whole codebase for cents and charges mainly for what it writes makes an agent first pass, boilerplate, and consistency checks across dozens of templates cheaper — without removing the need for human review, which is still the valuable part.
What I would test first, and what I would not do yet
If I were trying LongCat-2.5 this week, I would start with three bounded tests, all on staging. First, a refactoring pass across a real theme: rename a pattern, update every template that uses it, and check that nothing else breaks. Second, a documentation task: feed it the whole plugin and ask for accurate, file-by-file notes on what each part does, then verify the notes against the code. Third, a bug hunt with a known answer: give it a repository with a planted bug and see whether it finds it, and how much context it actually needed.
What I would not do yet: hand it production credentials, let it run unsupervised on a client site, or build a product that depends on the discounted price lasting forever. The discount has no published end date, the weights are not out, and the benchmarks are self-reported. Those are three good reasons to experiment now and commit later.
I would also watch whether the promised weight releases actually appear, and whether independent benchmarks confirm the launch table on agent tasks. If both land, this launch looks very different in a month. If neither does, the verdict is a cheap, large-context API with unproven claims — still useful, just not revolutionary.
Conclusion
LongCat-2.5 is not the most famous model launch of the year, and that is part of why it is interesting. A company known for delivery has shipped a 1.6-trillion-parameter, natively multimodal agent model with a 1-million-token context window, a 128,000-token output ceiling, and launch pricing of $0.30 per million input tokens and $1.20 per million output tokens — with cached input at a fraction of a cent per million. It works through familiar API formats, it is available now through chat and API, and its weights are promised but not yet released.
For developers, the takeaway is practical: test it on a real task, on staging, against the model you use today, and measure the failures, not just the bill. Remember the GDPx lesson: the best agents still complete only a small share of hard, real-world work unaided. A million tokens is a bigger workshop, not a smarter craftsman — and at launch pricing, it is cheap enough to find out for yourself.
Frequently asked questions
What is LongCat-2.5?
Meituan's natively multimodal, mixture-of-experts model for long-horizon agent work: 1.6 trillion total parameters, about 48 billion active per token, a 1-million-token context window, and up to 128,000 tokens of output. Generally available November 2, 2026, after a September 25 preview.
How much does LongCat-2.5 cost?
At limited-time discounted launch pricing: $0.30 per million uncached input tokens, $0.006 per million cached input tokens, and $1.20 per million output tokens. No end date is published, so check the pricing page before budgeting around these rates.
Can I download and self-host LongCat-2.5?
Not yet. GitHub and Hugging Face releases are marked "coming soon." Today it is available through Meituan's chat and API platform, and through gateways such as Vercel's AI Gateway.
Should WordPress and Elementor developers care?
Yes, cautiously. A 1-million-token window can hold a whole theme and plugin set at once, and OpenAI- and Anthropic-format API support means it drops into existing agent harnesses. But keep agents on staging, review every diff, and never let one touch production unsupervised.
Is LongCat-2.5 better than GPT-5.6 or Claude Opus 5?
Meituan's own table puts it above GPT-5.6-Sol on 20 of 27 shared tests and above Claude Opus 5 on 10, but those are company-reported, unverified scores. Run the same real task on each model and compare the results yourself.
