Meituan released LongCat 2.5 on November 2, 2026, and it arrived with a clear job in mind. The model handles long, multi-step agent work across /terminals, browsers, graphical interfaces, spreadsheets, and design tools. In addition, it reads text, images, and video in a single context window of one million tokens. As a result, teams that run coding agents all day finally get a budget-priced option with room for very large codebases. However, the launch numbers come from Meituan itself, so this guide separates vendor claims from verified facts and shows you how to test the model on your own work.
What Is LongCat 2.5?
LongCat 2.5 is a mixture-of-experts model from Meituan’s LongCat team, and it carries 1.6 trillion total parameters with roughly 48 billion active for each token. Because only a small slice of the network switches on per token, the model stays affordable to run despite its size. In contrast to a standard chat model, Meituan built this release for long-horizon agent tasks, meaning work that runs for many steps without human help. For instance, an agent can explore a repository, run tests, fix failures, and report back, all inside one session. Similarly, the model supports native multimodal input, so screenshots, diagrams, and short video clips enter the same context as code and text. Meanwhile, Meituan offers the model through its own API platform and chat service, and the weights remain marked as coming soon on GitHub and Hugging Face.
Why Long Agent Runs Need a 1M Context
Short context windows force agents to forget, and forgetting breaks long tasks. For example, an agent that refactors a large codebase needs the full module map, the test suite, and the error logs in view at the same time. However, a 200,000-token window often forces the agent to drop older files just when it needs them most. As a result, teams see repeated questions, lost decisions, and half-finished refactors. The LongCat 2.5 context window solves this specific problem because it holds one million tokens and allows up to 128,000 tokens of output in a single run. In addition, cached input costs almost nothing, so keeping a large codebase warm across turns stays cheap. On the other hand, a huge window does not fix weak reasoning, and long contexts can still distract a model with irrelevant detail. Therefore, treat the 1M window as room to work, not as a guarantee of quality, and test it on a real repository before you trust it with production code.
LongCat 2.5 Benchmarks in Plain Terms
The published LongCat 2.5 benchmarks cover more than 25 tests, and the jump over LongCat 2.0 stands out clearly. For instance, Terminal-Bench 4.0 rose from 3.0 to 38.5, DeepSWE v1.1 rose from 9.7 to 64.6, and AutomationBench rose from 15.8 to 51.8. Similarly, Terminal-Bench 2.1 reached 88.4, which sits close to Claude Opus 5 at 89.1 and GPT-5.6-Sol at 88.8 in Meituan’s own comparison table. In addition, AutomationBench at 51.8 edges Claude Opus 5 at 50.3, which matters because that benchmark measures end-to-end coding tasks with multi-file changes. However, the same table shows LongCat 2.5 trailing on Terminal-Bench 4.0, where Claude Opus 5 scores 53.9, so the model does not lead everywhere. Because Meituan ran these tests with thinking enabled and selected the comparison models itself, independent testers still need to confirm the numbers.
| Benchmark | LongCat 2.5 | LongCat 2.0 | Claude Opus 5 |
|---|---|---|---|
| Terminal-Bench 2.1 | 88.4 | 70.8 | 89.1 |
| Terminal-Bench 4.0 | 38.5 | 3.0 | 53.9 |
| DeepSWE v1.1 | 64.6 | 9.7 | 68.8 |
| AutomationBench | 51.8 | 15.8 | 50.3 |
These figures come from Meituan’s launch materials, so read them as vendor claims until independent benchmarks confirm them. For context on how speed changes agent economics, see Mercury 3 diffusion speed for business agents.
LongCat 2.5 Pricing and the Cost of One Task
LongCat 2.5 pricing starts at $0.30 per million uncached input tokens, $0.006 per million cached input tokens, and $1.20 per million output tokens. Meituan labels all three rates as a limited-time discount, and it publishes no list price and no end date. As a result, the rates could rise without warning, so budget your pilot at today’s prices and keep an eye on the pricing page. For example, a task that uses 500,000 input tokens and 100,000 output tokens costs about $0.27 at launch rates, which undercuts most frontier models by a wide margin. In addition, heavy cache reuse drops the input bill close to zero, because cached tokens cost only $0.006 per million. On the other hand, long agent runs burn output tokens fast, and output at $1.20 per million still dominates the bill on reasoning-heavy work. Therefore, measure your real token mix during a pilot week instead of trusting a headline rate.
LongCat 2.5 Claude Code Setup in Four Steps
The LongCat 2.5 Claude Code setup takes only a few minutes, because the API speaks both OpenAI and Anthropic request formats. Firstly, create an account on the LongCat API platform and generate an API key, then copy it somewhere safe right away because the platform shows it only once. Secondly, point Claude Code at the Anthropic-compatible endpoint by setting the base URL to the LongCat API address in your settings file. Thirdly, set the model name to LongCat-2.5 for the main model and for subagents, so every call routes to the new model. Finally, set the maximum context variable to 1,000,000, because Claude Code does not recognize this model name and otherwise assumes a 200,000-token window and compacts your session early. In addition, scope these settings to one project or one launch script if you still use Claude for other work, since global settings would redirect every session to LongCat. Similarly, the LongCat 2.5 API works with Codex, OpenCode, Cline, and other harnesses through the same base URL change, so you can test it inside the tool your team already uses.
Where Business Teams Should Use It First
Business teams get the most value when they aim this model at long, well-defined agent work. For example, repository-wide refactors, test suite repairs, and documentation updates across a large codebase all fit the 1M context and the low input price. Similarly, browser and GUI automation tasks benefit from native image input, because the agent can read screenshots instead of guessing at page structure. However, keep customer data out of the API until Meituan publishes a clear data policy, since early coverage flags this gap. As a result, start with internal code and public data, and add sensitive workloads only after a policy review.
LongCat 2.5 vs DeepSeek V4.1 Flash
Readers often ask how this release compares with DeepSeek V4.1 Flash, because both models price input near $0.30 per million tokens at peak. However, the two models serve different strengths. DeepSeek wins most coding rows at the same price in Meituan’s own comparison table, so pure code generation still favors DeepSeek on paper. On the other hand, LongCat 2.5 adds native vision and video input plus a 1M context, which DeepSeek does not match in this comparison. As a result, vision-heavy agent work favors LongCat, while text-only coding at scale may still favor DeepSeek. For a broader view of budget coding models, see Flint coding model guide. That sentence explains how to judge a cheap model on real tasks instead of headline scores.
Honest Limits to Know Before You Switch
Every new model carries limits, and this one is no exception. Firstly, the weights are not open yet, so you depend on Meituan’s API availability and pricing for every call. Secondly, the discounted rates carry no published end date, so today’s bargain could end with little notice. Thirdly, the benchmark table skips several current frontier models, which means the comparison flatters the new release in places. In addition, early hands-on testers report mixed experiences, from fast token throughput to a confusing web interface, so the product polish still needs work. Meanwhile, Meituan’s data retention policy remains unclear in public coverage, which blocks regulated workloads for now. Therefore, treat this release as a strong pilot candidate rather than a proven production default, and keep a fallback model configured in your harness.
A One Week Test Plan for Your Team
A short, structured pilot beats a month of casual testing. Firstly, pick one real task you already understand, such as fixing a known bug or refactoring one module. Secondly, run the same task on your current model and on LongCat 2.5, then compare correctness, test results, and total cost side by side. Thirdly, test one vision task, for example asking the agent to fix a UI bug from a screenshot, because vision input is the feature that sets this release apart. Finally, review your actual bill at the end of the week, including cache hit rates and output token share, before you commit any budget.
Frequently Asked Questions
What does LongCat 2.5 pricing include?
Launch pricing covers API access at $0.30 per million uncached input tokens, $0.006 per million cached input tokens, and $1.20 per million output tokens. Meituan calls these limited-time discounted rates, so confirm the current page before you budget a large rollout.
When did Meituan release this model?
Meituan made the model generally available on November 2, 2026, five weeks after a preview build landed on September 25, 2026. The preview build carried the name LongCat-2.5-Preview, while the production model uses the name LongCat-2.5.
How large is the context window?
The context window holds one million tokens, and a single run can produce up to 128,000 output tokens. Because Claude Code does not recognize the model name by default, set the maximum context variable to 1,000,000 or the harness will compact your session at 200,000 tokens.
Can I download the model weights?
Not yet. Meituan marks the GitHub and Hugging Face releases as coming soon, so the model works through the API and chat service only for now. Teams that need self-hosting should monitor the official repository pages for the weights release.
Which tools work with the API?
The API speaks OpenAI and Anthropic request formats, so Claude Code, Codex, OpenCode, Cline, and similar harnesses connect by changing the base URL, the API key, and the model name. Independent coverage of the launch confirms this compatibility; see Eesel explainer on the new multimodal coding model and November 3 AI news roundup on the release. Those links add hands-on detail.
Is it good for business automation?
It suits long agent workflows such as repo refactors, test repairs, and browser automation, especially where vision input helps. However, keep sensitive customer data out until Meituan publishes a clear data policy, and start with internal workloads during your pilot.
How does it compare with frontier models?
Meituan’s table places it close to Claude Opus 5 and GPT-5.6-Sol on several agent benchmarks and ahead on AutomationBench, but it trails on Terminal-Bench 4.0. Because the vendor selected the comparisons, treat the table as a starting point and verify with your own pilot tasks.
Will the launch price last?
Meituan gives no end date for the discount and no list price, so nobody can promise the current rates will hold. As a result, lock in pilot learning now while rates stay low, and build your budget with room for a price rise.
Conclusion: Should You Try It This Week?
LongCat 2.5 earns a pilot this week for one simple reason: it pairs a 1M context with native vision at launch prices that undercut frontier models. For example, teams with large codebases, screenshot-driven UI work, or long browser automation runs can test real workloads for a few dollars. However, the open weights, the data policy, and the discount end date all remain unresolved, so a pilot makes more sense than a full migration today. In addition, your own task results matter more than any benchmark table, so run the one-week test plan and let your numbers decide.
