LongCat-2.5-Preview vs GPT-5.6 Sol: What a 1M-Token Window Costs on Each Side

The most useful thing you can say about LongCat-2.5-Preview against GPT-5.6 Sol is not which one is smarter. It is that both advertise a context window of roughly a million tokens, and only one of them charges the same rate for the whole window. Sol's price doubles past 272,000 input tokens. LongCat-2.5-Preview's published rate card, as far as Meituan writes it down, does not tier at all. That single structural difference decides most real long-document workloads before a benchmark is consulted — and it is the kind of thing a spec-sheet comparison will never show you, because both models put "1M" in the same font size.

Here is what is actually on the record for each, organised by the questions worth asking.

Is the million-token window the same product on both sides?

No, and the difference is not the window — it is what happens as you fill it. Our catalogue carries Sol at a 1,050,000-token context window with 128,000 tokens of maximum output, at $4.00 per million input tokens and $20.00 per million output tokens for requests up to 272,000 tokens, with cached input at $0.40 per million and cache writes at $5.00 per million. Above that threshold the rates step up to $8.00 and $30.00 per million. So a 500,000-token document pass on Sol is billed at the long-context rate for the whole request, not a blended one.

LongCat-2.5-Preview lists 1,000,000 tokens of context and 131,072 tokens of maximum output. Its rate card, published on Meituan's own platform and flagged there as a limited-time discount, is $0.30 per million uncached input tokens, $0.006 per million cached input tokens and $1.20 per million output tokens. Meituan publishes no second tier. That is not the same as saying none exists — it is saying the vendor has not described one, and a price that is not described is not a price you can budget against.

Put a number on it. A 500,000-token read that writes 20,000 tokens back costs roughly $4.60 on Sol at the long-context tier and roughly 17 cents on LongCat-2.5-Preview at its published promotional rate. Both figures are arithmetic on published cards, not measurements. The ratio is large enough that it changes what is economically reasonable to attempt: at Sol's long-context rates, feeding a codebase into a model is a decision; at LongCat's, it is closer to a default.

Which one has evidence behind the number?

Sol, by a wide margin, and this is the part that keeps the comparison from being purely a price argument. Sol is a July 2026 release with a full independent profile on our catalogue: a Coding Index of 77.4, third of the models Artificial Analysis tracks; an Intelligence Index of 47 at thirteenth; GPQA Diamond 94.1%; Humanity's Last Exam 49.5%; SciCode 57.1%; Terminal-Bench v2.1 at 88.0; τ²-Bench at 85.1. All of those are sourced to Artificial Analysis, not to OpenAI.

Its most relevant number for this comparison is Long-Context Recall: 84. That is the highest of the frontier models we carry, and it is a measurement of whether the model still uses information deep inside a long input — the question a large context window is supposed to answer. It is also taken at Sol's own context length, on Sol's own terms.

LongCat-2.5-Preview has no equivalent. Meituan's changelog entry for 25 September 2026 claims image understanding, coding capability and compatibility with "Claude Code and other mainstream dev environments", naming Hermes, OpenClaw, OpenCode and Kilo Code. It publishes no benchmark table, no model card and no technical report. Roughly 1.6 trillion total parameters with about 48 billion active per token is reported from Meituan's site metadata and Chinese trade coverage rather than from documentation. There is no LongCat-2.5-Preview repository on HuggingFace, none in Meituan's GitHub organisation, and the catalogue metadata OpenCode ships records open weights as false.

Does the input side match, or only the output side?

This is where Sol's profile is broader and LongCat's is contested. Sol accepts text, images and files as input on our catalogue, and returns text. LongCat-2.5-Preview's changelog presents image understanding as its headline addition — "parse image content for cross-modal question answering, content summarisation and complex visual reasoning" — but the example response in Meituan's own "Retrieve Model" documentation still shows input_modalities as ["text"] with a text->text modality string. That sample may simply be stale. It is nonetheless the vendor's published contract, and the honest reading is that image input is claimed rather than confirmed until you test it.

One practical consequence: a reasoning trace from LongCat-2.5-Preview arrives in an interleaved reasoning_content field rather than as a sampled parameter. Harnesses that parse chat completions without expecting that field will drop the model's thinking silently — no error, just a worse answer. Whatever you decide about the model itself, check that first.

Which one is a route you can actually keep?

Sol is one of ours. We serve it at OpenAI's list price with zero markup, so a vendor price change reaches your bill the same day rather than at the next renewal, and automatic failover moves a degraded request to a healthy provider without your application knowing. LongCat-2.5-Preview is not one of our routes — we do not serve it, and nothing in this piece should be read as claiming we do.

That asymmetry is where the routing layer earns its place in this specific comparison rather than as a general aside. Sol's tiered pricing means the same task can cost twice as much purely because of input length, and the threshold sits at 272,000 tokens — a number your application knows before it sends the request. Splitting a workload by request size across providers is exactly what a routing DSL is for, and model fusion goes further: two models can be composed on one request so that a long-context pass and a high-quality synthesis step do not have to be the same model at the same rate. Neither of those is a reason to pick a model with no published benchmark. Both are reasons not to hard-wire one.

Bottom line

If your workload is short, Sol is the straightforward choice: it is third on the coding index, it has independent numbers across the board, and its input side is documented. If your workload is long, the arithmetic inverts sharply — Sol's long-context tier is roughly 26 times the cost of LongCat-2.5-Preview's promotional rate for the same 500,000-token read, and Sol is the one whose recall score, 84, actually answers whether the long window works. You are buying a measured long window at a frontier price against an unmeasured long window at a discount price that the vendor has already labelled temporary.

The failure mode to avoid is treating those as comparable options. They are not the same product sold at different prices; they are a documented capability and a promise. The correct way to close the gap is to run LongCat-2.5-Preview on your own long-context tasks while it is free through OpenCode or cheap through Meituan — and to keep Sol behind a router so that the day the promotional rate disappears, or the long-context tier crosses your budget, the switch is a configuration line rather than a migration.