CheapestInference | Blog

MiMo-V2.6 Pro & Flash: specs, benchmarks, pricing & API options

Tue, 22 Sep 2026 00:00:00 GMT

Update — September 23, 2026: MiMo V2.6 Flash is now served in the Core Pool as mimo-v2.6-flash, replacing MiMo v2.5 in place — same pool, same price, subscriptions uninterrupted; the old id mimo-v2.5 keeps working until October 23, 2026. Model page: MiMo V2.6 Flash API. MiMo-V2.6-Pro remains under evaluation (live status).

Xiaomi’s MiMo team shipped two models on September 21, 2026, and each one matters for a different reason:

MiMo-V2.6-Pro is the new #1 open-weights model on the Artificial Analysis Intelligence Index: 46, ahead of GLM-5.3 and Qwen3.8 Max (45) and Kimi K3 (44), at a blended $0.18 per 1M tokens.
MiMo-V2.6-Flash is the direct successor to MiMo v2.5: the same size class (309B total / 15B active) and the same list price, with agent-benchmark scores that land within a few points of Pro.

Both ship MIT-licensed weights, a 1M-token context window and omnimodal input (text, image, audio, video). A naming note for searchers: this is MiMo-V2.6, September 2026. It is not the older MiMo-V2-Flash from late 2025, which had a 256K context and is a different model.

MiMo-V2.6 specs: Pro vs Flash

	MiMo-V2.6-Pro	MiMo-V2.6-Flash
Architecture	1.02T total / 42B active MoE	309B total / 15B active MoE, hybrid sliding-window + global attention
Decoding	Reasoning model	Reasoning model, 5-layer multi-token prediction (7 tokens per pass)
Input	Text, image, audio, video	Text, image, audio, video
Context window	1M tokens, up to 128K output	1M tokens, up to 128K output
Open weights	XiaomiMiMo/MiMo-V2.6-Pro-RL, MIT, FP8	XiaomiMiMo/MiMo-V2.6-Flash-RL, MIT, BF16 + FP8
List price (API)	$0.435 in / $0.87 out per 1M, cached input $0.0036	$0.14 in / $0.28 out per 1M, cached input $0.0028
Measured speed	124.5 output tok/s, 2.34s to first token (AA)	Not yet measured independently

The “-RL” suffix in the repository names confuses people. These are full checkpoints from the final reinforcement-learning run, not adapters. Pro and Flash are also separate training runs with their own benchmark tables, not one model cut down to two sizes.

The vendor benchmarks, charted

These are Xiaomi’s own reported numbers from its vendor harness, not independently reproduced. The baseline is last generation’s largest model, MiMo-V2.5-Pro:

MiMo-V2.5-Pro (previous generation)MiMo-V2.6-Flash (15B active)MiMo-V2.6-Pro (42B active)

Benchmark (Xiaomi, vendor-run)	MiMo-V2.5-Pro	MiMo-V2.6-Flash	MiMo-V2.6-Pro
Terminal-Bench 2.1	65.2	87.6	89.9
DeepSWE v1.1	19.0	67.9	71.9
CyberGym	40.0	95.1	94.0
AutomationBench	16.0	52.3	53.1
MiMo Code Bench	40.4	61.2	63.2
JobBench	—	61.2	62.0
MiMo Visual Coding	—	71.5	72.3

The gap between the two new models is small. Flash is within 4.0 points of Pro on every benchmark, and it beats Pro on CyberGym. The generational jump is large: on DeepSWE, Flash scores 67.9 where last generation’s Pro scored 19.0. Xiaomi credits scaled RL for this: about 750,000 trajectories across more than 7,000 environments, and it published the runs live while they trained. That jump is the headline, and it is also the reason to wait for independent reproductions before trusting every point.

Where Pro lands on the Intelligence Index

The independent signal comes from Artificial Analysis, using Intelligence Index v4.3.2. Every score below was checked today on that edition. AA rescored the whole field in this edition, so these numbers are not comparable with scores quoted from earlier editions.

MiMo-V2.6-ProServed in a CheapestInference poolClosed frontier reference

Model	AA Intelligence Index v4.3.2	AA blended $/1M	AA output tok/s
GPT-6 Astra / Claude Fable 5.1	53	—	—
Claude Opus 5	51	—	56.4
MiMo-V2.6-Pro	46	$0.18	124.5
GLM-5.3 (max)	45	$0.90	61.0
Qwen3.8 Max	45	$1.18	39.2
Kimi K3 (max)	44	$2.31	40.6
DeepSeek V4.1 Flash	39	$0.18	225.6

Blended = AA’s 7:2:1 cache-hit/input/output mix. The full field and its history are in our monthly LLM Pareto Frontier report.

The honest read. Pro does not beat the closed frontier: GPT-6 Astra and Claude Fable 5.1 lead at 53, 7 points ahead. Its lead over the next open-weights models is a single point, which is within the noise of any index. The notable part is the rest of the row. Against the three open-weights models it edges out:

it is 5–13× cheaper on AA’s blended price;
it is about 2–3× faster on measured output speed.

It costs the same blended $0.18 as DeepSeek V4.1 Flash while scoring 7 points higher. That combination puts Pro on AA’s intelligence-vs-cost Pareto frontier at $0.13 per Index task.

MiMo-V2.6-Flash: a new generation at the old price

Flash has no AA score yet. Here is why it may be the more important release for high-volume workloads:

The cost profile is unchanged. Flash keeps the exact list price of MiMo v2.5 ($0.14 in / $0.28 out, cached input $0.0028) and the same 15B-active footprint. Agent loops, sub-agents and long-context summarization get a generation’s worth of capability at the same per-token cost.
It lands close to Pro. On Xiaomi’s own table, Flash sits within 4.0 points of the 1T Pro everywhere. At the size class, this is the part to check once independent numbers land.
1M context stays usable. The hybrid sliding-window + global attention keeps long inputs affordable to serve, and the 7-token multi-token-prediction head is built for fast decoding.

The weights: MIT, both of them

Pro and Flash both ship under plain MIT on Hugging Face. Pro is in FP8; Flash is in BF16 and FP8. Alongside them, Xiaomi published:

a technical report;
more than 7,000 RL environments;
its end-to-end RL framework;
a 9B distilled model.

The full task datasets have not been released yet. For anyone evaluating models to serve rather than just call, the top of the open-weights index now carries the most permissive license there is.

Where they stand in our review

MiMo-V2.6-Flash is served. Since September 23, 2026 it is the Core Pool’s MiMo model, as mimo-v2.6-flash, next to DeepSeek V4.1 Flash, unlimited on flat monthly time blocks. It replaced MiMo v2.5 in place: same pool, same price, nothing to change on existing keys, and requests with the old id mimo-v2.5 are served by V2.6 Flash until October 23, 2026. Image input works on the same endpoint; reasoning is off by default and switched on per request. MiMo-V2.6-Pro is under evaluation — its live status is on the models-under-review page, and any addition lands in the changelog the day it ships.

Common questions

What is MiMo-V2.6? Xiaomi’s September 2026 model generation, in two open-weights models. MiMo-V2.6-Pro is a 1.02T-total / 42B-active MoE. MiMo-V2.6-Flash is a 309B-total / 15B-active MoE. Both have a 1M-token context window, omnimodal input (text, image, audio, video) and MIT-licensed weights. Xiaomi also offers a Pro-UltraSpeed variant on its own API, advertised at up to 20× Pro’s output speed.

What is the difference between MiMo-V2.6-Pro and MiMo-V2.6-Flash? Size and price. Pro is about 3× larger in active parameters and costs about 3× more per token ($0.435 / $0.87 vs $0.14 / $0.28 per 1M). On Xiaomi’s vendor benchmarks, Flash sits within 4.0 points of Pro on every task and beats it on CyberGym (95.1 vs 94.0).

Is MiMo-V2.6-Pro the best open-weights model? On the Artificial Analysis Intelligence Index v4.3.2 it is #1 among open-weights models, at 46. That is one point ahead of GLM-5.3 and Qwen3.8 Max (45) and two ahead of Kimi K3 (44). It is also the cheapest and fastest of that group: $0.18/1M blended and 124.5 tok/s. GPT-6 Astra and Claude Fable 5.1 lead the overall index at 53.

How much does the MiMo-V2.6 API cost? Xiaomi lists MiMo-V2.6-Pro at $0.435 input / $0.87 output per 1M tokens, with cached input at $0.0036. MiMo-V2.6-Flash is $0.14 / $0.28, with cached input at $0.0028, which is the same as MiMo v2.5.

Does MiMo-V2.6 have open weights? Yes. Both are on Hugging Face under the MIT license: XiaomiMiMo/MiMo-V2.6-Pro-RL and XiaomiMiMo/MiMo-V2.6-Flash-RL. The “-RL” suffix marks the final RL checkpoint; these are full models, not adapters.

Is MiMo-V2.6-Flash the same as MiMo-V2-Flash? No. MiMo-V2-Flash is Xiaomi’s late-2025 model with a 256K context. MiMo-V2.6-Flash is the September 2026 successor to MiMo v2.5, with a 1M context and the RL-scaled post-training described above.

Is there an unlimited MiMo-V2.6 API subscription? Yes, for Flash. Since September 23, 2026, MiMo V2.6 Flash is served unlimited in the Core Pool as mimo-v2.6-flash: flat monthly fee, no token caps during your reserved hours, OpenAI- and Anthropic-compatible, image input included. It replaced MiMo v2.5 in place, and the old id mimo-v2.5 keeps working until October 23, 2026. MiMo-V2.6-Pro is under evaluation (live status) and is not served today.

CheapestInference serves Kimi K3 and Qwen3.8 Max (Flagship Pool), GLM 5.3 and MiniMax M3 (Frontier Pool) and DeepSeek V4.1 Flash and MiMo V2.6 Flash (Core Pool) through one OpenAI- and Anthropic-compatible API on unlimited time-block subscriptions. See the pools or get started.

Asking a model "who are you?" proves nothing. Here is what the evidence says.

Fri, 18 Sep 2026 00:00:00 GMT

Every week someone sends a provider the same two screenshots: the request asked for model A, the reply says “I am model B”. The conclusion feels obvious, and it is usually wrong. A subscriber sent us this pair this week, verbatim:

// request
{ "model": "deepseek-v4.1-flash",
  "messages": [{ "role": "user",
    "content": "Who are you? Who made you? What's your model name, give me a precise model name" }] }

// response
{ "model": "deepseek-v4.1-flash",
  "choices": [{ "message": { "role": "assistant",
    "content": "I'm DeepSeek, an AI assistant created by the Chinese company DeepSeek (深度求索).\n\nMy precise model name is **DeepSeek-V3**." } }] }

Same subscriber, other runs: the model called itself an Anthropic model. Same key, same endpoint, same served model every time. The model was not lying and the platform was not switching anything. Language models simply do not know what they are, and the research on this is now large enough to put numbers on it.

What has been measured

Study / report	Date	What was tested	Result
TechCrunch: “Why DeepSeek’s new AI model thinks it’s ChatGPT”	Dec 2024	DeepSeek V3, asked what it is	Claimed to be ChatGPT (GPT-4) in 5 of 8 generations; gave OpenAI API instructions when asked about DeepSeek’s API
”I’m Spartacus, No, I’m Spartacus” (Shandong Univ., Drexel, UMass Lowell)	Nov 2024	27 LLMs, systematic identity probing	25.93 % exhibit identity confusion; output-distribution analysis attributes it to hallucination, not copied weights
Same paper, documented real-world cases	2024	Production models	Gemini-Pro says it is Baidu’s Wenxin when asked in Chinese; GPT-4 over the API says it is GPT-3; ByteDance Seed says it is GPT
”Know Thyself? On the Incapability and Implications of AI Self-Recognition” (Univ. of Chicago)	Oct 2025	10 frontier models (GPT-4.1, GPT-5, Claude Sonnet 4, Gemini 2.5 Flash, Kimi K2, DeepSeek V3, GLM-4.5, Qwen3-235B, Grok 4), 20,000 predictions	Exact self-identification accuracy 10.3 – 10.9 % against a 10 % random baseline. GPT and Claude receive 97.7 % of all attributions while producing 40 % of the text. GLM-4.5 identified itself as Claude in half of its runs

The Chicago study is the cleanest one: each model was shown text and asked which model wrote it, including its own text. Only four of the ten ever named themselves. The models that were most often named as authors were the ones with the most public visibility, not the ones that actually wrote the sample.

Why a model cannot answer this question

Identity lives in the system prompt, not in the weights. When a vendor’s own chat app says “I am X, made by Y”, that sentence comes from instructions the vendor injects in front of every conversation. Over a raw API, with no system prompt, the model falls back on whatever its training data says about “AI assistants”, and that corpus is dominated by a few famous names.

Training corpora contain other models’ output. The DeepSeek V3 case was traced to exactly this: public datasets full of GPT-4 generated text. Mike Cook, research fellow at King’s College London, described the effect to TechCrunch as “taking a photocopy of a photocopy”. Synthetic data and distillation are standard practice across the industry, so this is not a property of one vendor; the Chicago paper found the same bias in every family it tested.

Version numbers are the least reliable part. A model trained before its own release cannot know its final product name. The Chicago authors report GPT-5 dismissing “gpt-5” as a fake model name because, from the model’s point of view, it had not been released yet. A DeepSeek model calling itself “V3” is the same failure: it names the latest version it read about.

The model field is written by the server. The name in the JSON response is metadata attached by the API, not something the model produced. It tells you what the endpoint claims to have served. It cannot be cross-checked by asking the model, because the model never sees it.

Signals that are more reliable than the model’s own answer

None of these is proof on its own, and each takes some work. All of them beat a “who are you?” prompt, because they measure behaviour the model cannot talk its way around:

Tokenizer behaviour. Every model family counts tokens differently, and the tokenizers of open-weights models are public. The usage.prompt_tokens reported for a fixed input is a fingerprint of the tokenizer that actually processed it.
Knowledge and capability boundaries. Training cutoffs, supported languages, context length behaviour and native modalities (vision, audio) differ between models in ways that a system prompt cannot fake.
Behaviour with structured features. How a model handles tool calls, JSON mode, reasoning fields, stop sequences or unusual parameters is specific to the model and to the software serving it.
Response metadata patterns. ID formats, error message wording, header sets and latency profiles tend to be stable per serving stack and change when the stack changes.
Consistency across many samples. A single answer at default temperature is noise. The studies above used hundreds or thousands of samples per model; a verification worth trusting does the same and looks at the distribution.
Independent, reproducible attestations. Published test harnesses with recorded runs let a third party repeat the measurement. That is how the September 2026 CrofAI investigation established that a reseller was silently routing sixteen model ids to four cheaper models: tool signatures, response ID formats, token counting and canary strings, recorded in public CI runs, and not one “who are you?” prompt.

What to take from this

If a model tells you it is ChatGPT, Claude, or an older version of itself, you have learned something about its training data and nothing about what is being served to you. Treat self-identification the way the research does: as a hallucination category with a measured rate of roughly one model in four, and at chance level when the question gets specific.

When it matters, measure behaviour instead. The signals above are the ones the published investigations relied on, and the ones we would point anyone to, including for our own endpoints.

DeepSeek V4.1 Flash: what changed, and how to use it over the API

Thu, 10 Sep 2026 00:00:00 GMT

On September 10, 2026 DeepSeek released DeepSeek V4.1 Flash — not a retrain this time, a new generation: 552B parameters (mixture-of-experts, 8B active per token in prefill and 16B in decode), a new “causal encoder–decoder” architecture, vision trained in from the start of pre-training, a 1M-token context, and MIT weights on Hugging Face at deepseek-ai/DeepSeek-V4.1-Flash (the tech report PDF ships in the same repo).

It replaced the previous build in our Core Pool the same day. There is exactly one thing to migrate: the model id. The new id is deepseek-v4.1-flash; the old deepseek-v4-flash keeps working as an alias until October 10, 2026, after which it returns an invalid-model error. Same key, same endpoints, same subscription, same reserved hours — unlimited, flat-rate access starts from $22/mo ($18.70/mo billed annually), live pricing on /pools.

# before                              # from 2026-09-10
"model": "deepseek-v4-flash"          "model": "deepseek-v4.1-flash"

What DeepSeek measured

The headline claim in DeepSeek’s own release material is that V4.1 Flash beats its own larger V4-Pro on performance, cost, speed and total time to finish a task. It is confident enough in that to act on it: from September 14, 2026 DeepSeek will route its own deepseek-v4-pro traffic to V4.1 Flash, billed at Flash rates, until a V4.1-Pro exists.

Here are the three agent benchmarks from the instruct table on the model card, next to V4-Pro and Claude Opus 5.0. All of these are vendor-run — DeepSeek’s own harness at maximum reasoning effort (reasoning_effort=100), with no independent verification yet:

DeepSeek V4.1-FlashDeepSeek V4-ProClaude Opus 5.0

Same numbers as a table, plus the base-model scores DeepSeek publishes alongside them:

Instruct (vendor harness, max reasoning effort)	V4.1-Flash	V4-Pro	Claude Opus 5.0
Terminal-Bench 2.1	90.6	87.9	89.1
DeepSWE v1.1 (resolved)	74.2	62.7	74.0
AutomationBench (pass@1)	54.8	43.2	50.3

Base model	V4.1-Flash-Base	V4-Flash-Base	V4-Pro-Base
MMLU-Pro	74.1	68.3	73.5
HumanEval	79.4	69.5	76.8
GSM8K	93.0	90.8	92.6

Two honest readings, and both are worth holding at once. The generous one: on DeepSeek’s own harness, a model with 8–16B active parameters edges past Claude Opus 5.0 on all three agent benchmarks, and past its own Pro-tier sibling on every row of both tables — which is exactly why DeepSeek is willing to point Pro traffic at it. The sceptical one: every number above was produced by the vendor, at maximum reasoning effort, on its own scaffolding. Vendor tables set expectations; they don’t settle them. Where independent evaluation lands is the next section.

Where it lands on the independent board

Update — September 22, 2026: Artificial Analysis has now scored V4.1 Flash: 39 on its Intelligence Index v4.3.2 — five points above the V4 Flash build it replaced (34 on the same scale), at a lower price. Our Pareto Frontier, Price Tracker and Which-LLM reports now plot it. The paragraph below is the original launch-day note.

Artificial Analysis has not published an Intelligence Index score for V4.1 Flash yet. So we are not moving anything on the strength of a vendor table: our Pareto Frontier, Price Tracker and Which-LLM reports keep the previous build’s plotted point until an independent score exists. For reference, the build this one replaces scored 50 on that index when it launched (52 after AA’s later v4.1.1 recalibration). We’ll update the reports when AA publishes.

The architecture, the vision, and the price

	DeepSeek V4.1 Flash
Parameters	552B mixture-of-experts — 8B active per token in prefill, 16B in decode
Architecture	New causal encoder–decoder: a 20-layer causal encoder followed by a 20-layer decoder
Vision	Native — a from-scratch vision encoder plus projector, trained alongside text from the start of pre-training, not bolted on afterwards
Context window	1M tokens
KV cache	~890 bytes per token — DeepSeek reports roughly ¼ of the previous generation’s HBM footprint and ⅛ of its SSD footprint
Weights	MIT — `deepseek-ai/DeepSeek-V4.1-Flash`, tech report in the repo
Model id here	`deepseek-v4.1-flash` (old `deepseek-v4-flash` accepted until 2026-10-10)
Pool	Core Pool, alongside MiMo V2.6 Flash

The cache line is the one with second-order consequences. A quarter of the KV footprint per token is what makes a 1M-token context economically serious rather than a spec-sheet number — and it is the mechanism behind DeepSeek’s list price coming down on a newer, larger model, which is not the usual direction:

DeepSeek list price, per 1M tokens	V4 Flash (before)	V4.1 Flash (now)
Off-peak input	$0.22	$0.15
Off-peak output	$0.66	$0.60
Peak input	$0.44	$0.30
Peak output	$1.32	$1.20
Cache hit (off-peak / peak)	—	$0.003 / $0.006

Peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday to Friday; everything else is off-peak. DeepSeek has retired the deepseek-v4-flash id on its own API, where it now routes to V4.1.

On a flat-rate subscription none of that column matters at all — a Core Pool block costs the same whether your agent burns one million tokens or one billion — but it matters as a signal: the cheap tier keeps getting better without getting more expensive. We track that trend month by month in the LLM Price Tracker.

How to use it

curl:

curl https://api.cheapestinference.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "deepseek-v4.1-flash", "messages": [{"role": "user", "content": "Hello"}]}'

OpenAI SDK (Python):

from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheapestinference.com/v1",
    api_key="sk-...",  # your subscriber key
)

response = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Fix the failing test in this repo..."}],
)
print(response.choices[0].message.content)

Anthropic SDK (Python) — the same key against the /anthropic endpoint:

from anthropic import Anthropic

client = Anthropic(
    base_url="https://api.cheapestinference.com/anthropic",
    api_key="sk-...",  # your subscriber key
)

message = client.messages.create(
    model="deepseek-v4.1-flash",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explain this stack trace..."}],
)
print(message.content[0].text)

No account yet? Register, subscribe to the Core Pool, and mint a key at cheapestinference.com/keys.

Run it in Claude Code

Claude Code speaks the Anthropic Messages API, so it drops in with two environment variables (plus the small-model one):

export ANTHROPIC_BASE_URL="https://api.cheapestinference.com/anthropic"
export ANTHROPIC_AUTH_TOKEN="sk-..."   # your subscriber key
export ANTHROPIC_MODEL="deepseek-v4.1-flash"
export ANTHROPIC_SMALL_FAST_MODEL="deepseek-v4.1-flash"

Start claude as usual — every request runs on V4.1 Flash with no per-token meter. Per-project pinning, thinking blocks and the rest of the setup are in the Claude Code + DeepSeek guide. The same key works in Cline, Roo Code, Continue and anything that accepts a custom OpenAI base URL.

Sending an image

Vision is native, and it uses the standard content formats on both endpoints — image_url parts on /v1/chat/completions, image blocks on /anthropic/v1/messages, in user messages, inside the same 8 MB per-request budget as everything else:

response = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What does this dashboard screenshot show?"},
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}},
        ],
    }],
)

Common questions

Does DeepSeek V4.1 Flash have open weights? Yes — MIT, on Hugging Face at deepseek-ai/DeepSeek-V4.1-Flash, with the tech report PDF in the same repo. MIT means unrestricted commercial use, including self-hosting.

Does it replace V4-Pro? For DeepSeek’s own traffic, effectively yes for now: from September 14, 2026 requests to deepseek-v4-pro will be routed to V4.1 Flash and billed at Flash rates, until a V4.1-Pro ships. On its own tables V4.1 Flash outscores V4-Pro on every row we quote above.

What is its Artificial Analysis Intelligence Index score? There isn’t one yet — AA has not published a score for V4.1 Flash. Our living reports keep the previous build’s point on the chart until it does; we’ll update them when it lands.

Do I have to change anything to keep working? One line: the model id becomes deepseek-v4.1-flash. deepseek-v4-flash still resolves here until October 10, 2026, then returns an invalid-model error. Keys, endpoints, subscriptions and reserved blocks are untouched.

Can it read images? Yes, natively — vision was in the pre-training, not added afterwards. Send image_url parts (OpenAI format) or image blocks (Anthropic format) in user messages, within the 8 MB per-request limit.

Is it better than Claude Opus? On DeepSeek’s own three agent benchmarks above it is ahead of Claude Opus 5.0 — 90.6 vs 89.1, 74.2 vs 74.0, 54.8 vs 50.3. Those are vendor-run numbers at maximum reasoning effort with no independent verification, and two of the three margins are inside a point; treat them as a claim worth testing on your own workload, not a settled ranking.

Full details: DeepSeek V4.1 Flash API docs · Plans & Limits · what a flat monthly DeepSeek subscription changes.

Check live Core Pool availability →

GLM-5.3-Flash: specs, benchmarks, pricing & API options

Mon, 31 Aug 2026 00:00:00 GMT

GLM-5.3-Flash is Z.ai’s (Zhipu AI) efficiency-tier release next to GLM-5.3, and the headline is simple: Artificial Analysis measures it at 57 on its Intelligence Index at a blended price of $0.10 per 1M tokens — $0.09 per Index task, on AA’s intelligence-vs-cost Pareto frontier, ranked #4 of 111 open-weights models it tracks. For scale: the entire index currently tops out at 63.

Unlike its big sibling — a post-training pass on the existing 743B GLM base — Flash is a new model: 320B total / 18B active MoE with hybrid sparse + linear attention, trained on a 30T-token multimodal corpus, and natively multimodal (image, video and file input) where GLM-5.3 is text-only. The weights are on Hugging Face under MIT (zai-org/GLM-5.3-Flash) — plain MIT, where the flagship’s custom license carries a security-review clause for large Model-as-a-Service operators.

GLM-5.3-Flash specs


Architecture	320B total / 18B active MoE, hybrid sparse + linear attention
Multimodal	Native — image, video, text and file input; text output
Context window	1M tokens; up to 128K output
Reasoning	Reasoning model — thinking always on, cannot be disabled on the direct API
Open weights	Yes — zai-org/GLM-5.3-Flash, MIT license (BF16 + FP8)
List price (API)	$0.15 in / $0.50 out per 1M, cached input $0.03 — 50% launch promo ($0.075 / $0.25) until September 9, 2026
Measured speed	48.6 output tok/s, 1.51s to first token (Artificial Analysis)

The vendor benchmarks, charted

Z.ai’s own reported numbers (vendor harness — not independently reproduced), with the retired GLM 5.2 and the full GLM-5.3 on either side:

GLM 5.2 (743B, retired)GLM-5.3-Flash (18B active)GLM-5.3 (743B)

Benchmark (Z.ai, vendor-run)	GLM 5.2	GLM-5.3-Flash	GLM-5.3
Terminal-Bench 2.1	81.0	84.3	88.2
DeepSWE v1.1	46.2	63.4	66.9
AutomationBench v1.0.6	26.2	48.8	48.2

Two things stand out. An 18B-active model beats the 743B GLM 5.2 on all three — a model that was frontier-class until weeks ago. And on AutomationBench it edges out the full GLM-5.3 itself. Z.ai also reports Flash within half a point of Claude Opus 4.8 on its internal Code Bench v1.0 (29.0 vs 29.5, max effort) — vendor-run, so hold it loosely until independent reproductions land.

Where it lands on the Intelligence Index

The independent signal, from Artificial Analysis (current index edition — every score below re-verified today):

GLM-5.3-FlashServed in a CheapestInference poolReference frontier models

Honest framing, as always: Flash does not beat the closed frontier — Claude Opus 5 leads the index at 63 — and it is three points behind the best open-weights scores (Kimi K3 and GLM-5.3, tied at 60). What is remarkable is the column AA puts next to those scores:

Model	AA Intelligence Index	AA blended $/1M tokens
GLM-5.3 (max)	60	$0.90
Qwen3.8 Max	58	—
GLM-5.3-Flash	57	$0.10

Blended = AA’s 7:2:1 cache-hit/input/output mix; scores from the current index edition. Full field and history in our monthly LLM Pareto Frontier report.

95% of GLM-5.3’s measured intelligence at a ninth of its blended price is why AA places Flash on the Pareto frontier: among everything it tracks at this intelligence level, nothing is cheaper per task. The trade-off it does not hide: speed. Flash generates ~48.6 tok/s against GLM-5.3’s ~66.6, so interactive latency is where the smaller model feels smaller.

The weights: MIT, and why that matters

Z.ai shipped GLM-5.3’s weights under a custom license with a security-review clause for Model-as-a-Service operators above US$10B revenue. Flash ships under plain MIT — no clauses, BF16 and FP8 checkpoints on Hugging Face. For anyone evaluating models to serve rather than just call, that difference is not cosmetic: MIT is as serving-friendly as licenses get, and it makes Flash the most permissively-licensed near-frontier model of the moment.

Where it stands in our review

We serve the full GLM-5.3 unlimited in the Frontier Pool (from $71/mo, flat) since August 30. A near-frontier, MIT-licensed, 1M-context multimodal model is squarely the profile our pools exist for, and Flash is under active evaluation — the live pipeline status is always on the models-under-review page, and additions land in the changelog the day they ship.

Common questions

What is GLM-5.3-Flash? Z.ai’s efficiency-tier model beside GLM-5.3: a new 320B-total / 18B-active MoE with native multimodal input (image, video, file), a 1M-token context window and MIT-licensed open weights. Artificial Analysis scores it 57 on its Intelligence Index at $0.10 per 1M tokens blended.

How much does the GLM-5.3-Flash API cost? Z.ai lists $0.15 input / $0.50 output per 1M tokens (cached input $0.03), with a 50% launch discount until September 9, 2026. Artificial Analysis measures $0.09 per Intelligence-Index task and a $0.10/1M blended rate.

Does GLM-5.3-Flash have open weights? Yes — zai-org/GLM-5.3-Flash on Hugging Face under the MIT license, in BF16 and FP8. More permissive than the full GLM-5.3, whose custom license adds a security-review clause for large Model-as-a-Service operators.

How good is GLM-5.3-Flash at coding? On Z.ai’s vendor benchmarks it scores 84.3 on Terminal-Bench 2.1 and 63.4 on DeepSWE v1.1 — above the retired 743B GLM 5.2 on both — and 48.8 on AutomationBench, marginally above the full GLM-5.3. Independently, its 57 on the AA index is three points behind the best open-weights models. Its measured output speed is ~48.6 tok/s.

Is there an unlimited GLM-5.3-Flash API subscription? Not from us today — Flash is under evaluation (live status). The full GLM-5.3 is served unlimited in the Frontier Pool from $71/mo: flat monthly fee, no token caps during your reserved hours.

Claude Code alternatives in 2026: switch tools, or switch the model behind it

Sat, 15 Aug 2026 00:00:00 GMT

Searches for a “Claude Code alternative” usually start with one of two pains: the subscription limits (the five-hour usage windows belong to the Claude plan, not to the tool) or the bill (agentic coding burns tokens like nothing else you run). Before comparing tools, it helps to split the question in two, because they have different answers:

The harness — the terminal agent itself: the REPL, the tool-calling loop, permissions, MCP support. Claude Code is one harness; there are now several good ones.
The model — what actually writes the code, and what you’re actually paying for.

You can swap either one independently. Here’s the honest map of both.

The real alternatives (swapping the harness)

Tool	By	Models it drives	Worth knowing
Codex CLI	OpenAI	GPT family	Ships with ChatGPT plans; open-source harness
Gemini CLI	Google	Gemini family	Generous free tier; the harness many forks build on
OpenCode	SST	Any (bring your own API)	Open-source, provider-agnostic, closest to Claude Code in feel
Qwen Code	Alibaba	Qwen family + any OpenAI-compatible API	Gemini CLI fork tuned for Qwen
Aider	open-source	Any (bring your own API)	The veteran; git-native, great diffs
Cline / Roo Code	open-source	Any (bring your own API)	VS Code sidebar instead of a terminal

All of these are good software. If your pain is the harness itself — you want an IDE sidebar, or a different permission model — pick from the table and you’re done. But notice what the table also says: half of these tools don’t come with a model at all. You bring an API key, and the model behind it is where the cost and the quality actually live.

The option most people miss: keep Claude Code, swap the model

Claude Code talks to any endpoint that implements the Anthropic Messages API — that’s two environment variables:

export ANTHROPIC_BASE_URL="https://api.cheapestinference.com/anthropic"
export ANTHROPIC_AUTH_TOKEN="sk-..."
export ANTHROPIC_MODEL="kimi-k3"   # or glm-5.3, deepseek-v4.1-flash, ...

Your muscle memory, your .claude/ config, your MCP servers, your slash commands — everything stays. What changes is the engine and the meter: on a CheapestInference pool, usage during your reserved time blocks is a flat monthly fee, with no per-token billing and no five-hour windows.

Model-by-model setup guides:

Kimi K3 in Claude Code — Moonshot’s flagship, 256K context
GLM 5.3 in Claude Code — frontier coding & agentic work
DeepSeek in Claude Code — fast, 1M context, lowest price

How the per-token prices of these models compare to the closed frontier is tracked monthly in the LLM API pricing comparison.

If your only pain is “usage limit reached”

If you’re otherwise happy on a Claude subscription and just want overnight runs to survive the window resets, you don’t need to switch anything: claude-auto-retry waits out the limit and resumes the session for you. Free, one npm install.

FAQ

Is there a free Claude Code alternative?

The harnesses are mostly free and open-source (OpenCode, Aider, Cline, Qwen Code, Codex CLI’s source). What’s never free at scale is the model behind them — a serious agentic session runs millions of tokens, so the real comparison is per-token bills vs. subscriptions vs. flat-rate blocks.

Can Claude Code use models other than Claude?

Yes. Claude Code works with any Anthropic-compatible endpoint via ANTHROPIC_BASE_URL — no plugin, no proxy. That’s the “keep the harness, swap the model” path above.

What’s the cheapest way to run a coding agent all day?

A flat-rate block: agentic coding is exactly the workload where per-token billing hurts most, because the agent — not you — decides how many tokens to spend. A pool subscription makes the heavy week cost the same as the light one. For per-token numbers across the market, see the live pricing comparison.

GLM-5.3: specs, benchmarks, pricing & API options — now served unlimited

Fri, 14 Aug 2026 00:00:00 GMT

Update, August 30, 2026: the review is over — GLM-5.3 is live in our Frontier Pool as glm-5.3. Z.ai published the open weights on August 28 (zai-org/GLM-5.3, under the custom GLM-5.3 License — commercial use allowed; a security-review clause applies only to Model-as-a-Service operators above US$10B revenue), the licensing gate we describe below lifted, and the pool’s GLM slot was upgraded in place: every Frontier subscriber gets GLM-5.3 at the same flat price, and glm-5.2 requests keep working until September 30, 2026. Setup on the model page. The analysis below is as written on launch day.

GLM-5.3 (API id glm-5.3) is Z.ai’s (Zhipu AI) new coding and agentic model, released today, August 14, 2026, under the tagline “Built to Code. Ready for Cyber Defense.” The architecture story is unusual and worth being precise about: GLM-5.3 keeps the same 743B-parameter base model as GLM 5.2 — every reported gain comes from scaled-up post-training alone. On Z.ai’s own benchmark suite that post-training buys a lot: it calls GLM-5.3 the strongest open-weights coding model it has measured, and reports a cyber-security capability that grew faster than the company anticipated.

And the question this blog exists to answer: GLM-5.3 was officially under review for our pools as of launch day — and went live on August 30 (see the update above). We already serve GLM 5.2 in the Frontier Pool, so 5.3 enters the pipeline as the natural upgrade candidate for that slot. What gates the decision is not quality signals — it’s that the model is API-only today: open weights are promised roughly two weeks out, after Z.ai completes its own safety evaluation. Live status is always on our models-under-review page.

GLM-5.3 specs


Base model	Same 743B base as GLM 5.2 — not a new pretrain; gains from extended post-training
Context window	Z.ai advertises a 1M-token variant (`glm-5.3[1m]`, with context compaction); the standard-API spec is not yet published
Reasoning	Effort levels `low` / `high` / `max` — default `max`; thinking cannot be disabled on the direct API
Open weights	Published August 28, 2026 — zai-org/GLM-5.3 (fp8, 141 shards); at launch they were promised ~2 weeks out
License	GLM-5.3 License (custom): commercial use with attribution; Model-as-a-Service operators above US$10B revenue over 12 months must pass Z.ai’s security review. Not MIT — GLM 5.2’s terms did not carry over
List price (API)	$1.40 in / $4.40 out per 1M, cached input $0.26 — unchanged from GLM 5.2
Availability	First-party API access from Z.ai; open weights since August 28; served unlimited on CheapestInference’s Frontier Pool since August 30 — works with Claude Code, OpenCode, Cline and Codex via compatible endpoints

GLM-5.3 benchmarks: what post-training bought

All numbers below are Z.ai’s own reported results — vendor-run, not yet independently reproduced, and the Artificial Analysis index hasn’t rated GLM-5.3 yet. With that caveat on the table, the GLM 5.2 → GLM-5.3 deltas are the story, because the base model is identical:

Benchmark	GLM 5.2	GLM-5.3	Δ
Terminal-Bench 2.1	81.0	88.2	+9%
Terminal-Bench 3.0	4.6	28.3	+515%
DeepSWE v1.1	46.2	66.9	+45%
SWE-Marathon v1.1	19.4	42.5	+119%
FrontierSWE	67.5	78.1	+16%
NL2Repo	48.9	58.0	+19%
Toolathlon Verified	59.9	73.0	+22%
AutomationBench v1.0.6	26.2	48.2	+84%
CyberGym	77.2	84.5	+9%

Two readings. The charitable one: the biggest jumps land on the newest, hardest agentic benchmarks (Terminal-Bench 3.0, SWE-Marathon) — exactly where post-training on agent trajectories should show up, and exactly the workloads coding agents run all day. The skeptical one: several of these benchmarks are new or Z.ai-adjacent, and until independent runs land, “strongest open-weights coding model” is a claim, not a fact. Both readings can wait two weeks — the open-weights release is when independent verification becomes possible.

The cyber-defense angle — and why the weights are two weeks out

The unusual part of this launch is that Z.ai leads with cyber security as a first-class capability, not a footnote. It reports GLM-5.3 at 84.5 on CyberGym — above its figures for Claude Mythos 5 (83.8) and GPT-5.6 Sol (83.6) — and says the model found thousands of real vulnerabilities across open-source projects during training. Z.ai’s framing is defensive: vulnerability detection at scale.

That capability is also the stated reason the weights aren’t out yet. Rather than shipping weights on day one — as it did with GLM 5.2 — Z.ai is running a staged release: API first, then open weights roughly two weeks after launch, once its own safety evaluation and hardening work is complete. Whatever you think of the trade-off, it’s a more deliberate open-weights process than the ecosystem norm, and it puts a concrete clock on the one thing our review is waiting for.

GLM-5.3 vs GLM 5.2 — the model we serve today

	GLM-5.3	GLM 5.2
Base	743B (same base)	743B
What’s new	Scaled post-training: agentic coding, tool use, cyber	—
Context	Z.ai advertises a 1M-token variant (`glm-5.3[1m]`, with context compaction); the standard-API spec is not yet published	1M per the model card
Reasoning	Effort `low` / `high` / `max`, thinking always on	Standard GLM 5.2 semantics
Open weights	Published August 28 (GLM-5.3 License)	Published (MIT)
List price (per 1M)	$1.40 in / $4.40 out	$1.40 in / $4.40 out
Status here	Live in the Frontier Pool since August 30	Retired August 30 — migration

Because the base is unchanged, this isn’t a “new model vs old model” decision so much as a post-training upgrade — the same shape as DeepSeek’s V4-Flash-0731 build, which we upgraded in place in the Core Pool within days of release. If GLM-5.3’s weights land with a usable license and it passes our quality evaluation on real coding and agent workloads, the natural outcome is the same: the Frontier Pool’s GLM slot upgrades, and every existing subscription simply gets the better model.

So the honest status board:

Quality — vendor numbers are strong; our own evaluation on real agent workloads (both OpenAI and Anthropic endpoints, tool calling included): ✅ passed.
Fit — a post-training upgrade of a model already serving Frontier Pool workloads: as clean as fit gets.
Licensing — ✅ open weights published August 28 under the GLM-5.3 License.

Outcome (August 30): live. The upgrade is recorded in the changelog; the models-under-review page is where the next candidate will show up.

Common questions

Is there an unlimited GLM-5.3 API? Yes — since August 30, 2026 CheapestInference serves GLM-5.3 in the Frontier Pool on flat-rate time-block subscriptions from $71/mo: no token caps during your reserved hours, model id glm-5.3, OpenAI- and Anthropic-compatible.

Does GLM-5.3 have open weights? Yes, since August 28, 2026 — zai-org/GLM-5.3 on Hugging Face, under Z.ai’s custom GLM-5.3 License: commercial use is allowed with attribution, and only Model-as-a-Service operators above US$10B aggregate revenue over 12 months must pass Z.ai’s security review first. GLM 5.2 was MIT; the terms did not carry over.

How much does the GLM-5.3 API cost? Per token, Z.ai lists $1.40 in / $4.40 out per 1M (cached input $0.26) — the same as GLM 5.2. On CheapestInference it is a flat monthly fee: from $71/mo for a daily 8-hour block, unlimited tokens.

What is the difference between GLM-5.3 and GLM 5.2? Same 743B base model — GLM-5.3 is extended post-training on top of it, targeting agentic coding, tool use, and cyber-security workloads. Z.ai reports large gains on agentic benchmarks (SWE-Marathon 19.4 → 42.5, Terminal-Bench 3.0 4.6 → 28.3); all numbers are vendor-run so far.

Qwen3.8 Max: specs, benchmarks, pricing & API options — now live in the Flagship Pool

Tue, 04 Aug 2026 00:00:00 GMT

Qwen3.8 Max (also written “Qwen 3.8 Max”; API id qwen3.8-max) is Alibaba’s flagship model, announced July 19: a 2.4-trillion-parameter system with a 1M-token context window, scoring 58 on the independent Artificial Analysis Intelligence Index (v4.1.1) — top-five territory, two points behind Kimi K3 (60), the current open-weights ceiling. As we chart below, that score at Qwen’s list price lands it on the price-vs-intelligence Pareto frontier — and knocks Claude Sonnet 5 off it.

Update, August 14, 2026: the review is over — Qwen3.8 Max is live in our Flagship Pool. Alibaba shipped the open-weight variant on August 13, the licensing gate we describe below lifted, and every Flagship subscriber can now call it with model id qwen3.8-max — unlimited, flat-rate, from $199/mo, next to Kimi K3. Setup, specs and examples: Qwen3.8 Max API — pricing, access & subscription.

curl https://api.cheapestinference.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "qwen3.8-max", "messages": [{"role": "user", "content": "Hello"}]}'

The analysis below is the review that got it there, kept as published (August 4) with the status lines updated.

Qwen3.8 Max specs and benchmarks


Architecture	~2.4T total parameters (MoE details unpublished)
Context window	1M tokens
Open weights	Released August 13, 2026 — Qwen3.8-2.4T-A95B, the open variant of the Max
Vision	Yes — image input
List price (API)	$2 input / $6 output per 1M tokens (cached input from $0.25)

The benchmark picture: 58 on the Artificial Analysis index (v4.1.1) puts Qwen3.8 Max above every previous Qwen release and within two points of Kimi K3 (60). Independent benchmarking is ongoing; active-parameter counts and MoE configuration haven’t been published, so per-token compute cost can’t be derived yet.

Qwen3.8 Max vs Kimi K3

The head-to-head everyone is asking for — the two highest-scoring models in the open(-ing) ecosystem, and on paper they’re complements rather than rivals:

	Qwen3.8 Max	Kimi K3
AA Intelligence Index	58	60
Parameters	~2.4T (MoE, config unpublished)	~2.8T MoE
Context window	1M tokens	1M tokens
List price (in / out per 1M)	$2.00 / $6.00	$3.00 / $15.00
Open weights	Published August 13, 2026 (2.4T-A95B)	Published July 27, 2026
Status here	Live in the Flagship Pool since August 14	Live in the Flagship Pool

K3 holds the intelligence crown and the agentic-coding pedigree; Qwen3.8 Max answers with 2.5× cheaper output at two index points’ distance, plus standard sampling controls. One pool serving both covers the two profiles that matter — peak agentic reasoning and tunable long-context breadth — which is exactly what the Flagship Pool now does.

Qwen3.8 Max on the price-vs-intelligence Pareto frontier

A model is on the frontier when nothing tracked is both smarter and cheaper. At index 58 for a $6.00/1M list output price, Qwen3.8 Max steps onto the frontier — five points above Claude Sonnet 5 at 40% lower list price — and pushes Sonnet 5 off it:

Served in a CheapestInference poolUnder reviewReference frontier modelsPareto frontier

Four of the five models on that frontier — V4-Flash-0731, GLM 5.2, Qwen3.8 Max and Kimi K3 — are served here on flat rate. The monthly-updated, full-field version of this chart (with cost-per-task data and edition history) lives in our LLM Pareto Frontier report.

What gated the decision — and how it resolved

When this review was published (August 4), Qwen3.8 Max had no open weights and no open license. Qwen’s open releases (3.5, 3.6) shipped under Apache 2.0; its Max tier had historically stayed closed — a tension the community debated openly since the preview shipped. Our review status was explicit that licensing, not quality, was the gate.

On August 13 Alibaba resolved it: Qwen3.8-2.4T-A95B — the open-weight variant of the Max — shipped on Hugging Face and ModelScope, followed on August 14 by the dense Qwen3.8-27B under Apache 2.0. The final scorecard:

Quality — reviewed on real agent workloads through both our OpenAI and Anthropic endpoints, including tool calling: ✅ passed.
Fit — a second flagship-class model with a different profile (hybrid reasoning, standard sampling, 1M context, vision) next to Kimi K3: ✅ strong.
Licensing — ✅ open weights published August 13.

Result: live in the Flagship Pool on August 14 — the pipeline’s fastest gate-to-launch turnaround so far. The models-under-review board and the changelog reflect it.

Common questions

Is there an unlimited Qwen3.8 Max API? Yes — live since August 14, 2026: the CheapestInference Flagship Pool serves Qwen3.8 Max with no token caps during your reserved hours, from $199/month for a daily 8-hour block, on the same subscription as Kimi K3. Model id qwen3.8-max; setup on the model page. Seats are very limited.

Does Qwen3.8 Max have open weights? Yes, as of August 13, 2026: Alibaba published Qwen3.8-2.4T-A95B, the open-weight variant of the Max, on Hugging Face and ModelScope — and the dense Qwen3.8-27B followed on August 14 under Apache 2.0.

How much does the Qwen3.8 Max API cost? Per token, list price is $2.00 per 1M input tokens and $6.00 per 1M output, with cached input from $0.25 — a 100M-token month lands around $200–600 depending on cache-hit rate and output mix. The credit-based subscription plans we analyzed in Qwen coding plans, explained cap usage per 5-hour and 7-day windows. For heavy use, our flat-rate unlimited route starts at $199/month.

What is the context window of Qwen3.8 Max? 1M tokens, per Alibaba’s published spec for the model.

DeepSeek V4-Flash-0731: what changed, and how to use it over the API

Sat, 01 Aug 2026 00:00:00 GMT

Update — September 10, 2026: DeepSeek V4.1 Flash replaced this build in the Core Pool on 2026-09-10, served as deepseek-v4.1-flash — a new generation (552B MoE, causal encoder–decoder, native vision, MIT weights), not another retrain. The old id deepseek-v4-flash keeps working until October 10, 2026, then returns an invalid-model error; migration is one line. Full analysis: DeepSeek V4.1 Flash: what changed, and how to use it over the API. The post below is kept as published on August 1, 2026.

On July 31, DeepSeek shipped V4-Flash-0731 — not a bigger model, a retrained one. Same 284B-total / 13B-active architecture, same 1M-token context, same price bracket — but re-post-trained for agent work, and the reported jump is unusual: DeepSeek says the new Flash now beats its own larger V4-Pro-Preview on every one of the nine agent benchmarks it publishes.

If you use the Core Pool, there is nothing to migrate: the model id is still deepseek-v4-flash, and requests already serve the new build. Unlimited, flat-rate access starts from $22/mo ($18.70/mo billed annually) — live pricing on /pools.

The retrain, measured

Same architecture, new post-training. This is DeepSeek’s own reported before/after (vendor harness — no independent verification of these specific numbers yet):

V4-Flash-0731V4-Flash preview (the previous build, April 2026)

Full vendor-stated table for the 0731 build, next to the April preview it replaces:

Benchmark	Flash-0731	Flash preview (Apr)
Terminal-Bench 2.1	82.7	61.8
Cybergym	76.7	38.7
Toolathlon-Verified	70.3	49.7
DSBench-FullStack†	68.7	37.0
DSBench-Hard†	59.6	25.8
DeepSWE	54.4	7.3
NL2Repo	54.2	39.4
Agents’ Last Exam	25.2	15.8
AutomationBench Public	25.1	10.8

† DeepSeek-internal test sets; the rest are public benchmarks.

The DeepSWE number is the striking one: the retrain multiplied the preview’s score by seven without touching the architecture. And like the April preview, the 0731 checkpoint is a genuine open-weights release: the weights are published under MIT at deepseek-ai/DeepSeek-V4-Flash-0731 (304B parameters on the repo — the 284B base plus a draft module).

Where that lands among frontier models

The independent signal comes from Artificial Analysis, which measures Flash-0731 at 50 on its Intelligence Index — ten points above the previous Flash. Honest framing: it does not beat Claude Opus 5 (61) or GPT-5.6 Sol (59) — nothing near this price does. What it does is land within seven points of Kimi K3 (57, the highest open-weights score on the index) from the budget model of the field — with a reference per-token price of $0.28 per 1M output tokens, roughly 90× below Claude Opus 5’s $25:

Served in a CheapestInference poolReference frontier models

Same data as a table, with list output prices alongside for scale — each model at its best published configuration (max effort where the index reports one); the median across all models Artificial Analysis tracks is 17:

Model	AA Intelligence Index	List output $/1M	On CheapestInference
Claude Opus 5	61	$25.00	—
Claude Fable 5*	60	$50.00	—
GPT-5.6 Sol	59	$30.00	—
Kimi K3	57	$15.00	Flagship Pool
Claude Opus 4.8	56	$25.00	—
GLM 5.2	51	$4.40	Frontier Pool
DeepSeek V4-Flash-0731	50	$0.28	Core Pool
MiniMax M3	44	$1.20	Frontier Pool

* Yes, one point below Claude Opus 5, even though Anthropic positions Fable 5 above Opus in capability. The index scores what AA actually evaluates: Fable 5 is measured in its “Adaptive Reasoning, Max Effort, Opus 4.8 Fallback” serving configuration — the variant with Anthropic’s additional dual-use safeguards — while Opus 5 runs at plain max effort. Independent index, published configurations, taken as-is.

Four of the eight models on that chart are served here on flat-rate subscriptions — and the 0731 retrain just moved the cheapest pool of the three into frontier territory.

V4-Flash-0731 vs Claude Opus 4.8, GPT-5.6 Luna, and Gemini 3.6 Flash

Is DeepSeek V4-Flash-0731 better than Claude Opus? On raw capability, no — and we won’t pretend otherwise. The strongest competitor in DeepSeek’s own release table is Claude Opus 4.8, and Opus wins every one of the nine shared benchmarks. What the table actually shows is how little it wins by, against a model priced roughly 90× higher per output token at list:

Benchmark (DeepSeek’s release table, vendor-run)	V4-Flash-0731	Claude Opus 4.8
Terminal-Bench 2.1	82.7	85.0
Cybergym	76.7	83.1
Toolathlon-Verified	70.3	76.2
DSBench-FullStack†	68.7	71.6
DSBench-Hard†	59.6	71.7
DeepSWE	54.4	58.0
NL2Repo	54.2	69.7
Agents’ Last Exam	25.2	25.7
AutomationBench Public	25.1	27.2
Reference output price, per 1M tokens	$0.28	$25.00

On Agents’ Last Exam the gap is half a point — effective parity. On Terminal-Bench 2.1 it is 2.3 points. NL2Repo and the (internal) DSBench-Hard are where the distance stays wide.

Against its actual price peers, the independent picture flips. Per Artificial Analysis: Flash-0731 sits one point behind GPT-5.6 Luna (50 vs 51 at max effort) with a cost per task roughly 60% lower — even after OpenAI’s price cut — ties Gemini 3.6 Flash (50), and lands on AA’s Pareto frontier for Intelligence vs Cost per Task: at this intelligence level, nothing tracked is cheaper per task.

Here is that frontier drawn out — intelligence against list output price. A model is on the frontier when nothing tracked is both smarter and cheaper; everything below-right of the line pays more for less. The 0731 retrain moved Flash onto it, and pushed MiniMax M3 off:

Served in a CheapestInference poolReference frontier modelsPareto frontier

Three of the five models on that frontier — Flash-0731, GLM 5.2 and Kimi K3 — are served here on flat rate. This chart is a snapshot of the frontier’s cheap end; the monthly-updated, full-field version (with cost-per-task data and edition history) lives in our LLM Pareto Frontier report.

And on a flat-rate subscription the per-token column stops mattering altogether: a Core Pool block is the same price whether your agent burns one million tokens or one billion.

Call it

curl:

curl https://api.cheapestinference.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "deepseek-v4-flash", "messages": [{"role": "user", "content": "Hello"}]}'

OpenAI SDK (Python):

from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheapestinference.com/v1",
    api_key="sk-...",  # your subscriber key
)

response = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[{"role": "user", "content": "Fix the failing test in this repo..."}],
)
print(response.choices[0].message.content)

No account yet? Register, subscribe to the Core Pool, and mint a key at cheapestinference.com/keys.

Run it in Claude Code

The API also speaks the Anthropic Messages format, so a retrained agent model drops straight into the most popular coding agent:

export ANTHROPIC_BASE_URL="https://api.cheapestinference.com/anthropic"
export ANTHROPIC_AUTH_TOKEN="sk-..."   # your subscriber key
export ANTHROPIC_MODEL="deepseek-v4-flash"
export ANTHROPIC_SMALL_FAST_MODEL="deepseek-v4-flash"

Start claude as usual — every request runs on Flash-0731 with no per-token meter. The same key works in Cline, Roo Code, Continue, and anything that accepts a custom OpenAI base URL (setup guides).

Why this release matters for flat-rate users

Agent workloads are exactly where per-token bills explode: an agent re-sends its growing context on every tool call, and iteration count — not task value — drives the invoice. A model that is suddenly much better at agent work makes that math worse per-token and better flat-rate: more capable loops, same fixed monthly price. We ran the full per-token vs. flat break-even math in Unlimited DeepSeek: what a flat monthly subscription changes — every row of that table just got more favorable, because the same subscription now serves a stronger model.

The trade-offs, as always: usage is unlimited in tokens during your reserved 8-hour blocks, each subscription runs one request at a time (fair use), and outside your blocks the key doesn’t serve. Full details: DeepSeek V4 Flash API docs · Plans & Limits.

Check live Core Pool availability →

CheapestInference serves Kimi K3 (Flagship Pool), GLM 5.3 and MiniMax M3 (Frontier Pool) and DeepSeek V4.1 Flash and MiMo V2.6 Flash (Core Pool) through one OpenAI- and Anthropic-compatible API on unlimited time-block subscriptions. See the pools or get started.

How to use the Kimi K3 API: key, snippets, and unlimited access

Mon, 27 Jul 2026 00:00:00 GMT

Kimi K3 is live on CheapestInference: Moonshot’s flagship — scoring 44 on the Artificial Analysis Intelligence Index (v4.3.2), 9 points off the top score (53) and above Claude Opus 4.8, Sonnet 5 and GPT-5.5 — served through an OpenAI- and Anthropic-compatible API with unlimited usage at a flat monthly price, from $199/mo (live availability — seats are very limited). This is the practical guide: get access, call it, wire it into your coding agent.

1. Get access

Three realistic routes to K3 over an API today:

Per-token, from Moonshot — $3.00 per 1M input tokens ($0.30 cached) and $15.00 per 1M output. Ideal for evaluation and light use; expensive fast for agent workloads.
Kimi memberships — Moonshot’s own plans bundle K3 access with request quotas per 5-hour and weekly windows (new signups have been intermittently paused since launch).
Unlimited time-block subscription (this guide) — reserve one or more daily 8-hour blocks on the Flagship Pool and use K3 with no token caps during your hours. From $199/mo per block; all three blocks = 24/7.

For the subscription route: create an account, subscribe to the Flagship Pool, and mint an API key at cheapestinference.com/keys. Model id: kimi-k3.

2. Call Kimi K3

curl:

curl https://api.cheapestinference.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "kimi-k3", "messages": [{"role": "user", "content": "Hello"}]}'

OpenAI SDK (Python):

from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheapestinference.com/v1",
    api_key="sk-...",  # your subscriber key
)

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Refactor this function..."}],
)
print(response.choices[0].message.content)

K3 is a reasoning model, but reasoning is off by default — you get fast, direct answers. Turn it on per request with "thinking": {"type": "enabled"} or reasoning_effort (low / high / max — K3’s deepest tier). With reasoning on, give it a generous max_tokens so long answers don’t truncate mid-thought, and stream (stream: true) for responsive UIs.

3. Run it in Claude Code

The API also speaks the Anthropic Messages format, so Claude Code works out of the box:

export ANTHROPIC_BASE_URL="https://api.cheapestinference.com/anthropic"
export ANTHROPIC_AUTH_TOKEN="sk-..."   # your subscriber key
export ANTHROPIC_MODEL="kimi-k3"
export ANTHROPIC_SMALL_FAST_MODEL="kimi-k3"

Start claude as usual — every request now runs on K3 with no per-token meter. The same key works in Cline, Roo Code, Continue, and any client that accepts a custom OpenAI base URL (setup guides).

What it costs, honestly

At list price, a coding agent that burns 100M tokens a month on K3 costs roughly $200–400 per-token, depending on your cache-hit and output mix — and heavy agentic users go far beyond that. A Flagship block at $199/mo covers your working day; all three blocks cover 24/7. The trade-offs: during your reserved hours usage is truly unlimited, each subscription runs one request at a time (fair use), and outside your blocks the key doesn’t serve. Full pricing detail: Plans & Limits · Kimi K3 API docs.

Seats on the Flagship Pool are very limited — when a block sells out it’s gone until someone leaves. Check live availability →

Kimi K3: specs, benchmarks, and our day-one plan to serve it

Wed, 22 Jul 2026 00:00:00 GMT

Kimi K3 is Moonshot AI’s new flagship, announced on July 16 after a leaked promotion page on Moonshot’s own platform tipped the release a day early. The headline is simple: on the independent Artificial Analysis Intelligence Index it scores 57 — above Claude Opus 4.8 (56), making it the first open-weight model to outscore a Claude Opus-class model on that index.

And to answer the question this blog exists to answer: yes, we will serve it. We have already secured the capacity to run a model of this size. K3 goes live on CheapestInference the moment two things are true: the weights are actually published, and the license terms permit commercial serving. Nothing else is in the way.

Update — July 2026: Kimi K3 is now live. The weights shipped on schedule (July 27), and K3 is served in the new Flagship Pool with unlimited usage at a flat monthly price — very limited seats. How to use the Kimi K3 API → · Subscribe →

July 28: with Claude Opus 5 (61) and GPT-5.6 Sol (59) landing the same month, K3’s 57 puts the open-vs-closed gap at 4 index points — per Artificial Analysis, the narrowest since the GLM-5 release in February. Only two labs score higher. Our Pareto Frontier report now charts K3 — straight onto the frontier.

What Moonshot announced


Architecture	Mixture-of-Experts, ~2.8T total parameters
Context window	1M tokens
Input	Text, image, and video
Variants at launch	K3 Max (chat and agent tasks) · K3 Swarm Max (large-scale parallel processing)
Available today	Moonshot’s API, Kimi Code, and the Kimi app
Open weights	Published July 27, 2026 — Hugging Face, Kimi K3 License
List price (API)	$3 input / $15 output per 1M tokens

Coverage from the launch day: TechCrunch on the Opus gap closing, Fortune on Chinese AI entering Fable-level territory, and Simon Willison’s notes for a practitioner’s first look.

When is the Kimi K3 release date?

K3 was announced on July 16, 2026, usable from day one through Moonshot’s own API, Kimi Code, and the Kimi app. The open weights were published on July 27, 2026, on schedule, on Hugging Face under Moonshot’s own Kimi K3 License — and K3 went live on CheapestInference’s Flagship Pool the same week.

The numbers so far

Artificial Analysis Intelligence Index: 57. For scale: Claude Opus 4.8 scores 56, and the best open-weight model until now — GLM 5.2 — scores 51: the open ceiling jumped six points in one release. Only three closed models score higher — Claude Opus 5 (61), Claude Fable 5 (60) and GPT-5.6 Sol (59). Where every model sits on price-vs-intelligence is our Pareto Frontier report, whose refreshed 2026-07 edition now charts K3 — straight onto the Pareto frontier.
#1 on Frontend Code Arena with 1,679 points — ahead of Claude Fable 5 (1,631), GPT-5.6 Sol (1,618), and GLM 5.2 (1,587).
The Kimi track record. Moonshot’s K2.6 still holds the best open SWE-bench Verified score (80.2), and the K2 line has been the default open choice for tool-heavy agent work — see the tier-fair matchups in our Which-LLM guide.

The honest caveats, same as in our living reports: the index is one composite and task-specific rankings differ, and these are launch-week numbers, mostly on Moonshot’s own serving stack. The weights question resolved on schedule: K3 is downloadable from Hugging Face under Moonshot’s own Kimi K3 License (not the K2 line’s Modified MIT — read the text before self-hosting), and K3 now has its row in State of Open Weights.

What it changed

When K3 was announced, every model above GLM 5.2’s intelligence score was closed, and the open-vs-closed gap had sat at 5+ index points all year. With the weights shipped, the open ceiling is 57 — and after Claude Opus 5 (61) and GPT-5.6 Sol (59) landed in the same month, the gap to the very top stands at 4 index points, the narrowest since the GLM-5 release in February (Artificial Analysis). K3’s $3/$15 list price still undercuts every closed model in its class, and it walked straight onto the Pareto frontier.

Kimi K3 API pricing

Moonshot’s list price for the K3 API is $3 input / $15 output per 1M tokens — undercutting every closed model in its class, but 3–4× the K2 line’s price: the first open flagship priced like a closed mid-tier model (Price Tracker). On CheapestInference that call is made: K3 debuted in its own Flagship Pool, flat-rate from $199/mo, unlimited usage during your reserved hours and very limited seats — the pools page is always the live source for lineup, prices and availability.

Unlimited Kimi K3 API access

Live now. The capacity we secured before launch is serving K3 today in the Flagship Pool — we didn’t start the clock the day the weights dropped.
The usual: one OpenAI- and Anthropic-compatible API, flat-rate time-block subscriptions, no token caps during your reserved hours — so it drops into Claude Code, Cline, or any compatible client; it’s in GET /v1/models now.

If you want to be running K3 this week, create an account — seats in the Flagship Pool are very limited, no waitlist.

CheapestInference serves Kimi K3 (Flagship Pool, from $199/mo), GLM 5.3 and MiniMax M3 (Frontier Pool, from $60.35/mo billed annually) and DeepSeek V4.1 Flash and MiMo V2.6 Flash (Core Pool, from $18.70/mo) through one OpenAI- and Anthropic-compatible API on unlimited time-block subscriptions. See the pools or get started.

Combined keys: stack your subscriptions into one credential

Thu, 09 Jul 2026 00:00:00 GMT

On an Unlimited subscription, the thing you’re actually shaping isn’t tokens — it’s capacity over time. Each subscription gives you a daily coverage window (the 8-hour blocks you reserve) and, within it, some number of requests you can run in parallel. Your real capacity is those two dimensions multiplied: parallel slots × hours.

Most people grow along both axes. You buy a second block to cover more of the day, or a second subscription to run more requests at once during your busy hours. The awkward part used to be the bookkeeping: every subscription minted its own key, so a serious setup meant three or four keys, each live at different times, each with its own capacity — and you juggling which one to paste where.

Combined keys remove the juggling. A combined key (it looks like sk-ci-meta-…) folds two or more of your subscriptions into a single credential, and it behaves like the union of everything underneath it.

Two rules, and that’s it

Coverage adds up. A combined key is live whenever any of its subscriptions has an open window. Reserve the Europe block on one subscription and the Americas block on another, combine them, and the one key covers both stretches of the day.

Overlap stacks parallel capacity. Where two subscriptions cover the same hour, their parallel slots add together. That’s the lever for concurrency: if you need to run more requests side by side during your peak hours, buy a second subscription over those hours and combine it in.

A concrete example. Say you hold one full-day (24h) subscription and add a second subscription on just the Europe block. The combined key gives you:

Double the parallel capacity during the Europe hours — the two subscriptions overlap there, so their slots stack.
Baseline capacity the rest of the day — only the 24h subscription is covering those hours.

Coverage is 24/7 (from the full-day subscription); parallel capacity is shaped to peak exactly when you work.

Allowances stay separate

Combining is about capacity, not billing. Each subscription keeps its own monthly allowance and its own renewal date — nothing is pooled or co-mingled. The practical upside is resilience: if one subscription lapses or you let it cancel, it simply drops out of the union. The combined key keeps working with whatever subscriptions remain — no dead key, no scramble to re-issue credentials.

It works across pools

Requests route by the model you ask for. So a combined key can span subscriptions on different pools — a Core Pool subscription and a Frontier Pool subscription under one key — and each request lands wherever its model lives. Ask for deepseek-v4.1-flash and it’s served from your Core subscription; ask for glm-5.3 and it’s served from your Frontier one. GET /v1/models on a combined key lists every model you can reach across all of them.

One credential per subscription

Combining a subscription into a key removes that subscription’s standalone key — each subscription has exactly one credential at a time. That’s deliberate: it means there’s never ambiguity about what capacity a given key carries. A key’s coverage and parallel capacity are always the exact sum of the subscriptions it holds, nothing more, nothing hidden. The dashboard walks you through it when you combine.

Creating one

In the Keys page, choose Create API Key and multi-select the subscriptions you want to combine. Before you commit, a preview shows the resulting daily coverage and peak parallel capacity, so you can see the shape you’re buying into. Prefer the API? The Management API does the same thing programmatically.

Full walkthrough in the combined keys guide. If you’re still deciding which blocks to reserve, the live menu and per-block prices are on the pools page.

CheapestInference serves frontier models — Kimi K3, Qwen3.8 Max (Flagship Pool), GLM 5.3, MiniMax M3 (Frontier Pool) and DeepSeek V4.1 Flash, MiMo V2.6 Flash (Core Pool) — through one OpenAI- and Anthropic-compatible API on unlimited time-block subscriptions. See the pools or get started.

Qwen coding plans in 2026: what you actually get

Thu, 09 Jul 2026 00:00:00 GMT

Qwen3-Coder — Alibaba’s open-weights coder family — is one of the most capable coding models you can run over an API, and one of the most searched-for. If you want to run it as your daily coding model, you have a few realistic routes. As with Kimi and GLM, they differ less in headline price than in cost shape: what happens to your bill and your workflow when a heavy week hits.

Update — August 14, 2026: Alibaba’s flagship Qwen3.8 Max is now live in our Flagship Pool on unlimited time-block subscriptions — the review chronicle and specs are in Qwen3.8 Max: specs, benchmarks, pricing & API options, setup on the model page.

Evaluating Qwen coding plans? There’s now a flat-rate unlimited route for Qwen itself. We serve Qwen3.8 Max in the Flagship Pool — and if what you’re after is a fixed monthly bill for a capable open-weights coder at a lower price point, the same cost-shape question applies to GLM 5.3, DeepSeek V4.1 Flash, MiMo V2.6 Flash, and MiniMax M3. Compare the flat-rate pools →

Route 1: the official Qwen Coding Plan

Alibaba Cloud sells a subscription Coding Plan on Model Studio aimed specifically at coding-tool usage of Qwen (plus a few third-party models). It’s first-party access, integrated with Qwen Code and compatible with Claude Code, Cline, and Cursor, and the Qwen coder models — qwen3-coder-plus, qwen3-coder-next, and the newer qwen3.x-plus line — arrive there first.

The trade-off is that the plan is quota-based: each tier grants a request allowance that resets on a schedule — with per-few-hours, weekly, and monthly request caps — and burning through it mid-refactor means waiting for the reset or moving up a tier. The tier lineup itself has already shifted once in 2026 (the entry-level Lite tier stopped accepting new orders), so any number printed here would go stale — check Alibaba’s Coding Plan page for the current tiers and quotas.

Good fit: you want first-party access to the newest Qwen coder models and your volume fits inside a tier’s request quota.

Route 2: per-token APIs

Qwen3-Coder is available per-token from Alibaba’s Model Studio / DashScope API and from several aggregators. No tiers, no resets — you pay for exactly the tokens you burn, which is ideal while you’re evaluating the model or your usage is light. New Model Studio accounts also get a time-limited free-token trial (region-restricted, expiring after a fixed window), useful for a first look — see Alibaba’s pricing page for the current allowance.

The catch is structural, not Qwen-specific: coding agents re-send their whole context on every tool call, so token volume compounds with every iteration. A capable coder will happily churn through long agent sessions — great for output, open-ended for the invoice. Per-token Qwen is cheap per request and unpredictable per month.

Good fit: a few million tokens a month, spiky schedules, or benchmarking before committing.

Route 3: unlimited time blocks on comparable open-weights models

The third shape is the one we sell, so apply the usual discount for self-interest. Since August 14, 2026 this route includes Qwen3.8 Max itself (Flagship Pool), alongside a lineup of comparable open-weights coders at lower price points. You reserve one or more daily 8-hour time blocks and get unlimited usage during them: no token allowances, no request quotas, no resets — a monthly number that’s fixed the day you subscribe. Capacity is shaped by per-key concurrency instead of token or request budgets, so an agent that loops all afternoon changes nothing on the bill.

Two things matter if you’re weighing this against a Qwen plan:

Qwen itself, plus comparable models, one fee. A Flagship Pool block covers Qwen3.8 Max (and Kimi K3); a Frontier Pool block covers GLM 5.3 and MiniMax M3 (1M context); the Core Pool covers DeepSeek V4.1 Flash and MiMo V2.6 Flash — switchable per request.
It runs in the same tools. The API speaks both the Anthropic and OpenAI formats, so it drops into Claude Code, Cline, Roo Code, or Qwen Code — no wrapper, just a base-URL change.

Current block pricing is on the pools page.

Good fit: you want a fixed monthly bill for Qwen3.8 Max or a comparable open-weights coder, with predictable working hours.

The three routes at a glance

Route	Cost shape	Limits	Models	Best for
Official Qwen Coding Plan	Fixed monthly subscription	Request quotas that reset (per-few-hours / weekly / monthly)	First-party Qwen coder models (plus some third-party)	First-party Qwen, volume inside quota
Per-token API	Pay per token used	None — spend scales with usage	Any Qwen model on Model Studio / aggregators	Light, spiky, or exploratory use
Flat-rate time blocks (us)	Fixed monthly, per block	Concurrency-shaped; no token or request caps	Qwen3.8 Max (Flagship) plus Kimi K3, GLM, DeepSeek, MiMo, MiniMax	Predictable hours, fixed bill

When to use what

Official Qwen Coding Plan — first-party access, day-one Qwen coder updates, your volume fits the request quota. Per-token — light, spiky, or exploratory usage; pay only for what you burn. Flat-rate time blocks — heavy daily coding in predictable hours where you want a constant bill, on Qwen3.8 Max itself or a comparable open-weights model.

All three answer the same underlying question. It isn’t “which Qwen tier is cheapest” — it’s which cost shape matches how you work.

Kimi coding plans in 2026: K2.7, K2.6, and what you actually get

Wed, 08 Jul 2026 00:00:00 GMT

Kimi K2.7 — Moonshot AI’s open-weights flagship — is currently one of the most capable coding models you can run over an API, and its predecessor K2.6 remains a strong, cheaper-to-serve option per-token from Moonshot and the aggregators. If you want Kimi as your daily coding model, you have three realistic routes. As with GLM, they differ less in headline price than in cost shape: what happens to your bill and your workflow when a heavy week hits.

Route 1: the official Kimi coding plan

Moonshot sells subscription plans aimed specifically at coding-tool usage of Kimi. It’s first-party access, tightly integrated with their own tooling, and the models arrive there first. The trade-off is that the plans are quota-based: each tier grants a usage allowance that resets on a schedule, and burning through it mid-refactor means waiting for the reset or moving up a tier. Tiers and allowances change often enough that any number printed here would go stale — check Moonshot’s pricing page for the current shape.

Good fit: you want first-party access and your coding volume fits comfortably inside a tier’s allowance.

Route 2: per-token APIs

Kimi K2.7 and K2.6 are available per-token from Moonshot’s open platform and from several aggregators. No tiers, no resets — you pay for exactly the tokens you burn, which is ideal while you’re evaluating the model or your usage is light.

The catch is structural, not Kimi-specific: coding agents re-send their whole context on every tool call, so token volume compounds with every iteration. A model as eager to work as K2.7 will happily churn through long agent sessions — great for output, open-ended for the invoice. Per-token Kimi is cheap per request and unpredictable per month.

Good fit: a few million tokens a month, spiky schedules, or benchmarking before committing.

Route 3: unlimited time blocks

The third shape is the one we sell, so apply the usual discount for self-interest — but the mechanics are easy to verify. You reserve one or more daily 8-hour time blocks and get unlimited Kimi K3 usage during them: no token allowances, no resets, a monthly number that’s fixed the day you subscribe. Capacity is shaped by per-key concurrency instead of token budgets, so an agent that loops all afternoon changes nothing on the bill.

Three properties matter for coding specifically:

Kimi K3 — the current Moonshot flagship — under one flat fee. A Flagship Pool block covers Kimi K3 (model id kimi-k3), alongside Qwen3.8 Max, switchable per request — very limited seats. (K2.6 and K2.7 were retired from our pools in July and August 2026; if you need those builds specifically, Route 2 still covers them per-token.)
It runs inside Claude Code natively. The API speaks both the Anthropic and OpenAI formats, so Kimi drops into Claude Code, Cline, Roo Code, or whatever tool you already use — no wrapper, just a base-URL change.
The subscription isn’t Kimi-only. The same Flagship block also covers Qwen3.8 Max (1M context, vision). If Kimi is your main model but not your only one, that’s two flagship coding plans for the price of one.

Current block pricing is on the pools page.

Good fit: Kimi is your daily driver, your working hours are roughly predictable, and you want the bill to be a constant instead of a variable.

When to use what

Official Moonshot plan — first-party access, day-one model updates, your volume fits the quota. Per-token — light, spiky, or exploratory usage; pay only for what you burn. Time-block unlimited — heavy daily coding or agent work in predictable hours; fixed cost, Kimi K3 plus Qwen3.8 Max under one fee.

All three routes serve the same open-weights model family. The question isn’t “which Kimi is better” — it’s which cost shape matches how you work.

DeepSeek subscription: what unlimited flat-monthly access changes

Mon, 06 Jul 2026 00:00:00 GMT

DeepSeek has a well-earned reputation as the budget option among frontier-quality models. Per-token rates for DeepSeek V4 Flash run around $0.14 per million input tokens and $0.28 per million output — an order of magnitude below closed-source flagships.

So why would anyone pay a flat monthly fee for it?

Update — September 10, 2026: the Core Pool’s DeepSeek slot is now DeepSeek V4.1 Flash (deepseek-v4.1-flash) — a new generation: 552B MoE with 8–16B active, a causal encoder–decoder architecture, native image input, 1M context and MIT weights, at a lower list price than the build it replaces. The old id deepseek-v4-flash keeps working until October 10, 2026. Every number below holds or improves. What changed in V4.1 Flash →

Update (Aug 2026): DeepSeek retrained V4 Flash — the 0731 build posts large agent-benchmark gains at the same price, which strengthens every number below. What changed in V4-Flash-0731 →

Because per-token pricing has a property that doesn’t care how low the rate is: cost scales with tokens, and agent tokens scale with iterations, not value. Cheap per token is not the same as cheap per month.

The math nobody runs until the invoice arrives

A coding agent re-sends its growing context on every tool call. A typical task burns 300–500K tokens; an active developer runs dozens of tasks a day. Being conservative:

	Tokens/day	Tokens/month	Per-token cost (V4 Flash rates)
Light use	2M	60M	~$11/mo
Daily driver	15M	450M	~$80/mo
Heavy agent loops	50M	1.5B	~$270/mo

The rate is tiny. The bill is not — and it’s unpredictable, because next month’s iteration count is unknowable in advance.

A time-block subscription inverts this: you reserve a daily 8-hour window and usage inside it is unlimited. The number on your invoice is decided when you subscribe, not by how many times your agent loops. DeepSeek V4.1 Flash is served in the Core Pool — current pricing is on the pools page.

At “daily driver” volume, the flat block is cheaper than even DeepSeek’s per-token rates — and the gap only widens from there.

What you get with the subscription

DeepSeek V4.1 Flash with a 1M-token context window — whole codebases, long documents, extended agent runs in a single request.
No token caps during your blocks. The plan is unlimited in tokens; capacity is shaped by per-key concurrency instead, so one busy key never affects another.
MiMo V2.6 Flash included. A Core Pool subscription covers every model in the pool — Xiaomi’s MiMo V2.6 Flash is served alongside DeepSeek V4.1 Flash on the same key.
Drop-in API. OpenAI-compatible (/v1/chat/completions) and Anthropic-compatible (/anthropic/v1/messages) — point your SDK, Cline, or Claude Code at it with model id deepseek-v4.1-flash.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.cheapestinference.com/v1",
    api_key="sk-...",  # subscriber key
)
r = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Review this repo for race conditions: ..."}],
)

Common questions

Is there a DeepSeek subscription? Not from DeepSeek itself — their first-party API is pay-per-token (with peak/off-peak and cache discounts, but no flat plan). CheapestInference sells a flat-monthly DeepSeek subscription: unlimited DeepSeek V4.1 Flash during your reserved daily 8-hour blocks, plus MiMo V2.6 Flash in the same Core Pool.

How much does a DeepSeek subscription cost? From $22/month per 8-hour daily block ($18.70/mo billed annually), up to full 24/7 coverage — live pricing on /pools. No token caps during your hours.

Does the subscription include the latest DeepSeek model? Yes — the pool always serves DeepSeek’s current Flash generation, and subscribers get it without changing plans. Retrains land with nothing to do at all (V4-Flash-0731, July 2026); a generation change costs one line — since September 10, 2026 the id is deepseek-v4.1-flash, with the old deepseek-v4-flash accepted until October 10, 2026.

When per-token DeepSeek is still the right call

Honesty clause: if your usage is light or spiky — a few million tokens a month, unpredictable hours — per-token is cheaper and you should use it. The flat block wins when usage is heavy and concentrated in predictable hours: agent development, batch processing, a working day of assisted coding. That’s the break-even logic in one sentence; the full break-even analysis is here.

CheapestInference serves DeepSeek V4.1 Flash and MiMo V2.6 Flash (Core Pool, from $18.70/mo billed annually) and GLM 5.3 and MiniMax M3 (Frontier Pool) through one OpenAI- and Anthropic-compatible API on unlimited time-block subscriptions. See the pools or get started.

GLM 5.2 coding plans in 2026: what you actually get

Mon, 06 Jul 2026 00:00:00 GMT

Update — August 30, 2026: GLM-5.3 — the same base model as GLM 5.2 with extended post-training, open-weighted by Z.ai on August 28 — is now served unlimited in our Frontier Pool as glm-5.3, replacing GLM 5.2 in place. The full analysis is in GLM-5.3: specs, benchmarks, pricing & API options.

GLM 5.2 — Zhipu AI’s (Z.ai) frontier coding and reasoning model — has become one of the most searched-for open-weights models for coding work. If you’re trying to run it as your daily coding model, you have three realistic routes, and they differ less in price than in cost shape: what happens to your bill and your workflow when usage spikes.

Route 1: the official Z.ai coding plan

Z.ai sells subscription tiers aimed at coding-tool usage of GLM. You get first-party access and tight integration with their own tooling. The trade-off is that the plans are quota-based: each tier grants an amount of usage that resets on a schedule, and hitting the ceiling mid-task means waiting or upgrading. For usage details and current tiers, check Z.ai’s pricing page — quotas and tiers change often enough that any number printed here would go stale.

Good fit: you want first-party access and your usage fits comfortably inside a tier’s quota.

Route 2: per-token APIs

GLM 5.2 is available per-token from several inference providers and aggregators. No quotas, no tiers — you pay for exactly what you use, which is ideal for light or unpredictable usage.

The catch is the same one that applies to every agent workload: coding agents re-send their whole context on every tool call, so token volume scales with iterations. Per-token GLM is cheap per request and open-ended per month — the bill is a dependent variable of how hard your agent worked.

Good fit: a few million tokens a month, spiky schedules, or evaluation before committing to anything.

Route 3: unlimited time blocks

The third shape is the one we sell, so discount accordingly — but the mechanics are simple to verify. You reserve one or more daily 8-hour time blocks and get unlimited GLM 5.2 usage during them: no token caps, no quota resets, a fixed monthly number decided at subscription time. Capacity is shaped by per-key concurrency rather than token budgets, so a runaway agent loop changes nothing on the invoice.

Two properties matter for coding specifically:

It works as a drop-in coding plan. The API is Anthropic- and OpenAI-compatible, so GLM 5.2 runs inside Claude Code, Cline, Roo Code, or any tool you already use — model id glm-5.2.
The subscription isn’t GLM-only. A Frontier Pool block covers Kimi K2.7 and MiniMax M3 (1M context) too, switchable per request. If GLM is your main model but not your only one, that’s three coding plans for the price of one.

Current block pricing is on the pools page.

Good fit: GLM is your daily-driver coding model, your hours are roughly predictable, and you want the bill to be a constant.

When to use what

Official Z.ai plan — first-party access, quota fits your volume, you use their tooling. Per-token — light, spiky, or exploratory usage; pay only for what you burn. Time-block unlimited — heavy daily coding or agent work in predictable hours; fixed cost, no quota anxiety, multiple frontier models under one fee.

All three serve the same open-weights model. The question isn’t “which GLM is better” — it’s which cost shape matches how you work.

CheapestInference serves GLM 5.3 and MiniMax M3 (Frontier Pool, from $60.35/mo billed annually) and DeepSeek V4.1 Flash and MiMo V2.6 Flash (Core Pool) through one OpenAI- and Anthropic-compatible API on unlimited time-block subscriptions. See the pools or get started.

Xiaomi's MiMo v2.5: the 1M-context model almost nobody is serving

Mon, 06 Jul 2026 00:00:00 GMT

First, a disambiguation for the search engines: this is about MiMo, Xiaomi’s open-weights large language model — not MIMO antenna technology. If you came here for multipath radio, wrong blog.

Update — September 23, 2026: MiMo v2.5 has been upgraded in place to MiMo V2.6 Flash in the Core Pool — same size class and list price, with a generational jump on agent benchmarks and image input. The new model id is mimo-v2.6-flash; requests with mimo-v2.5 keep working until October 23, 2026. Model page: MiMo V2.6 Flash API; the full analysis, alongside MiMo-V2.6-Pro, is in MiMo-V2.6 Pro & Flash: specs, benchmarks, pricing & API options. The post below is kept as written for MiMo v2.5.

MiMo v2.5 is the model Xiaomi’s LLM lab ships as its fast, efficient workhorse: small enough to be quick and cheap to run, with a ~1M-token context window that puts it in a class usually reserved for much more expensive models. It’s open weights, and — unlike most of the open-weights catalog — very few providers serve it over an API at all.

What it’s actually good at

MiMo v2.5 is not a frontier reasoning model, and pretending otherwise helps nobody. Where it earns its keep:

Long-context work on a budget. Feed it an entire codebase, a contract stack, or weeks of chat logs in one request. Most tasks over long inputs are retrieval-and-synthesis, not deep reasoning — exactly the regime where a fast model with 1M context beats a smarter model with 128K.
High-volume agent plumbing. Sub-agents, summarizers, extractors, classifiers — the loops that run hundreds of times a day and quietly dominate token bills.
Drafting and iteration speed. It’s fast. For inner-loop coding assistance, latency often matters more than the last few points of benchmark quality.

For frontier-tier reasoning, use a frontier-tier model — that’s what the Frontier Pool is for. MiMo’s job is to make the other 80% of your token volume cost almost nothing.

The fastest way to try it

MiMo v2.5 was served in the Core Pool alongside DeepSeek V4.1 Flash until September 23, 2026, when MiMo V2.6 Flash replaced it in place (the snippet below uses the current id), on unlimited time-block subscriptions — flat monthly fee, no per-token billing. One curl:

curl https://api.cheapestinference.com/v1/chat/completions \
  -H "Authorization: Bearer sk-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mimo-v2.6-flash",
    "messages": [{"role": "user", "content": "Summarize the attached spec..."}]
  }'

It speaks both the OpenAI and Anthropic API shapes, so it also works as a model in Claude Code, Cline, or any OpenAI-compatible client — set model id mimo-v2.6-flash. Full details on the MiMo V2.6 Flash model page.

Why serve it at all?

Because the interesting frontier in 2026 isn’t only “smartest model” — it’s capability per dollar at volume. A subscription covers every model in its pool, so the practical pattern is: route the hard 20% to a frontier model, and everything else to a model like MiMo where unlimited usage costs a flat few dollars a month. Your effective blended cost drops without touching quality where quality matters.

Your AI bill should scale with users, not usage

Sun, 05 Jul 2026 00:00:00 GMT

If you’re building a product with AI features, you’re probably doing two things at once: charging your users a flat monthly price, and paying your inference provider by the token.

That’s a structural mismatch. Your revenue scales with the number of users. Your AI bill scales with what those users do. Those are different curves, and the gap between them is your margin.

This post makes one argument: for a product with users, your inference cost should be a function of headcount, not behavior — because that’s the only model where you can offer an unlimited experience and know your worst-case bill in advance.

Two ways to buy inference

Metered (per-token): you pay for every token in and out. Your cost is a function of user behavior — decided by your users, known only after the fact, and unbounded.

Capacity (per-seat): you pay a flat price for a reserved slot that serves one request at a time with no token caps. Your cost is a function of how much capacity you provision — decided by you, known before the month starts, and bounded.

Everything in this post follows from that one difference: who controls the variable your bill depends on.

	Metered (per-token)	Capacity (per-seat)
Bill is a function of	User behavior	Capacity you provision
Who controls it	Your users	You
Known	After the fact	Before the month starts
Worst case	Unbounded	The subscription price
Heavy user	Costs you more	Costs you the same

The fat-tail problem

Per-user token consumption is not a bell curve. It’s fat-tailed: most users send a few short conversations, and a small minority — power users, users who wire your product into a workflow, users running agents — consume one or two orders of magnitude more than the median.

When your COGS are metered, you price your product for the median and bleed on the tail. That leaves you three options, all bad:

Cap usage. “You’ve used your 50 messages this month.” Your most engaged users hit the wall first — you punish exactly the people who love the product.
Pass the meter through. Credit systems, token balances, per-message pricing. Users ration a feature they’re paying for, and usage anxiety kills adoption.
Eat it. Accept that some fraction of your users are unprofitable and hope the average holds. Your margin is now a bet on user behavior.

Per-seat capacity dissolves the trilemma instead of picking a corner: the heavy user and the light user cost you exactly the same, so you don’t need to cap, meter, or gamble.

The math

With metered pricing, your monthly cost is a sum over things you don’t control:

COGS = Σ (tokens per user × price per token)     ← one term per user, unbounded

With per-seat capacity, it’s a product of things you do control:

COGS = seats × price per seat                     ← known before the month starts

And here’s the part that makes the second equation better than it first looks: seats scale with peak concurrency, not with user count. A thousand users don’t make a thousand simultaneous requests — they make a handful at peak, because usage spreads across the day. You provision for the busiest moment, the same way you provision web servers.

Two consequences:

Your bill is a step function of how many users you serve simultaneously — which grows much more slowly than signups.
Your cost per user falls as you grow, because more users share the same peak capacity. Metered pricing has no equivalent: cost per user stays flat at best, and rises if engagement improves.

Under metered pricing, engagement is a cost. Under per-seat capacity, engagement is free. You’ve aligned your COGS with your business for the first time: more users → more revenue → step up capacity when queues grow. Nothing in that loop depends on how hard each user hits the API.

What bounded COGS buys your product

You can offer unlimited AI to your own users. No credit meters, no message counters, no “upgrade to continue.” This is the single biggest UX difference between AI features people use constantly and AI features people ration. You can only make that promise downstream if someone made it to you upstream.

Pricing becomes arithmetic. Gross margin per user = your price − (seat cost ÷ users per seat). Every input is known in advance. Compare that to forecasting a fat-tailed usage distribution and multiplying by a per-token rate.

A runaway user is a queueing problem, not a financial incident. On metered infrastructure, a user who wires your product into a retry loop shows up on your invoice. On seats, the worst they can do is saturate one slot and wait in line — they cannot add a cent to your bill.

You stop building cost-control infrastructure. Spend alerts, per-user budget tracking, anomaly detection on your own invoice — that’s engineering effort that exists only because your provider’s pricing made user behavior your financial problem.

What the seat model asks of you

Honesty about the trade: capacity pricing is not magic, it’s a different discipline.

One request at a time per key. A seat serves requests serially. Your backend keeps a pool of keys and dispatches to the least busy one — the same pattern as a database connection pool, and about as much code.
You scale in steps, not on a smooth curve. When p95 queue time creeps up, you add a seat. That’s the whole capacity-planning playbook.
Reserved time windows. Seats here are daily 8-hour blocks — reserve the block that matches your traffic hours, or all three for 24/7 coverage.
Fair use applies. Unlimited means no token counting during your reserved hours; it doesn’t mean reselling raw capacity.

If you’ve ever sized a server fleet, none of this is new. The point is precisely that it turns inference into infrastructure you provision instead of a utility that meters you.

When the meter is still right

Per-token pricing is the better buy when usage is genuinely sporadic — a weekly batch job, an internal tool ten people touch once a day. A seat that idles is money spent on capacity you didn’t use. Metered pricing is also right when you need a specific proprietary model, or thousand-way burst parallelism for a few minutes a day.

The crossover is steady, user-driven traffic: the moment real users generate load every day — and especially the moment agents multiply that load by 10–50× — the meter’s “pay only for what you use” becomes “pay for whatever your users decide,” and the flat seat wins.

Running it in practice

Size for peak concurrency. Count simultaneous in-flight AI requests at your busiest hour. That’s your starting seat count — not your user count.
Pool the keys. One API key per seat, least-busy dispatch in your backend. Keys are independent, so one saturated seat never affects the others.
Watch queue time, not spend. Your only scaling signal is latency. When it degrades at peak, add a seat; the bill changes by exactly one known number.
Match blocks to traffic. A product with a single dominant timezone can cover its whole day with one block per seat and pay a fraction of 24/7 coverage.

The API is OpenAI-compatible, so the switch is a base URL and a key.

We serve five open-weight models across two flat-rate pools — GLM 5.3 and MiniMax M3 in the Frontier pool (from $60.35/mo), DeepSeek V4.1 Flash and MiMo V2.6 Flash in the Core pool (from $18.70/mo) — with unlimited time-block subscriptions: no token caps during your reserved hours, one key per seat. Your users’ usage never becomes your problem. Get started or see plans.

Claude usage limit reached? How to auto-resume Claude Code

Fri, 03 Jul 2026 00:00:00 GMT

It’s 11pm. Claude Code is 40 minutes into a refactor, tests are half-green, and then the terminal prints:

5-hour limit reached ∙ resets 3am

The agent stops. The session sits there. If you go to bed, nothing happens at 3am — the limit resets, but nobody is around to type “continue”. You lose the hours between the reset and whenever you come back.

We got tired of this, so we built claude-auto-retry: a small open-source tool that watches your Claude Code session, parses the reset time out of the limit message, waits for it, and resumes the session automatically. You run claude exactly like before. That’s the whole pitch.

The problem: limits don’t care where your task is

Claude subscriptions meter usage in rolling windows. Heavy Claude Code use — long agent runs, big contexts, lots of tool calls — burns through a window fast, and when it’s gone you get a variant of:

5-hour limit reached ∙ resets 3pm
You've hit your limit · resets 3pm
Claude usage limit reached. Resets at 2pm

The limit itself is fine — it’s how a fixed-price subscription stays fixed-price. The annoying part is what happens after: Claude Code doesn’t queue your work and resume at the reset. It just stops, mid-task, holding all the context of whatever it was doing. Resuming costs one word — “continue” — but only if a human is there to type it.

For interactive use that’s a coffee break. For the way people increasingly use Claude Code — overnight runs, long autonomous tasks, claude -p in scripts — it’s a silent halt that wastes every hour between the reset and your return.

Workarounds people try (and why they’re fragile)

Sitting there. Works, wastes an evening.

A cron job that types “continue” at a fixed time. Blind. The reset time moves with your usage, so you either fire too early (message goes nowhere, session still limited) or too late (hours lost anyway). And if Claude exited, you’re injecting keystrokes into a bare shell.

Wrapper scripts around the CLI. Most break something: interactive mode, claude -p piping, or they lose the session when your terminal disconnects.

The failure modes all reduce to the same two hard parts: knowing when the limit actually resets, and injecting “continue” safely into a live session — including after you’ve closed your laptop.

How claude-auto-retry solves it

The tool leans on tmux for session persistence, but hides it completely:

Transparent wrapping. The installer adds a shell function so claude transparently runs inside a tmux session. If you’re already in tmux, it uses your pane. You won’t notice the difference — interactive use, flags, and claude -p "prompt" | jq all work as before.
Background monitoring. A separate process polls the pane every 5 seconds looking for the known limit-message patterns (customizable if Anthropic changes the wording).
Real reset-time parsing. When a limit hits, it parses the actual reset time from the message — timezone-aware and DST-safe — computes the wait, and sleeps until reset plus a small safety margin. No guessed schedules.
Safe injection. Before sending “continue”, it verifies Claude is still the foreground process in the pane. If Claude exited, nothing gets typed into your shell.
Survives disconnects. Because the session lives in tmux, you can close the terminal, drop SSH, or shut the laptop lid. The monitor keeps waiting server-side; reattach whenever and the run has continued without you.

Separately from usage limits, it also catches transient API errors (429, 5xx, 529 overloaded) and retries those with exponential backoff — a different failure with a different fix, handled by the same monitor.

It’s pure Node.js with zero npm dependencies, MIT-licensed, and logs everything it does to ~/.claude-auto-retry/logs/.

Install

npm i -g claude-auto-retry
claude-auto-retry install

The installer adds the shell function to ~/.bashrc or ~/.zshrc and installs tmux if it’s missing (apt, dnf, brew, pacman, apk). Then use Claude Code exactly as always:

claude

When a limit hits, you’ll see the monitor take over. Check on it with:

claude-auto-retry status   # what it's waiting for, and until when
claude-auto-retry logs     # what it has done

Retry counts, the wait margin, and custom detection patterns live in ~/.claude-auto-retry.json if you want to tune them. Needs Node.js ≥ 18; tested on Ubuntu, CentOS, macOS, Arch, and Alpine.

We first shared the tool on r/ClaudeAI — the discussion there is a decent picture of how many people hit this exact wall.

Common questions

How do I resume Claude Code after hitting the usage limit? Wait for the reset time shown in the limit message, then type continue in the same session — Claude Code keeps all its context. To do it automatically, claude-auto-retry parses the reset time from the message, waits, and types continue for you.

Can Claude Code auto-continue after the limit resets? Not on its own — Claude Code stops mid-task and waits for a human. That’s exactly the gap claude-auto-retry fills: one npm i -g claude-auto-retry, and sessions resume at the reset without anyone at the keyboard.

Does Claude Code have a 5-hour limit? The limit belongs to your Claude subscription, not to Claude Code itself: usage is metered in rolling windows shared across everything on the account, and heavy agent runs simply burn the window faster. When it’s exhausted, every surface — Claude Code included — waits for the reset.

Can Claude Code resume overnight, with my laptop closed? Yes, if the session survives your terminal: claude-auto-retry runs Claude Code inside tmux transparently, so you can drop SSH or close the lid and the monitor still types continue at the reset, server-side. Reattach in the morning to a run that kept going.

Can I avoid the usage limit entirely for unattended runs? Not on a metered subscription — but you can route the unattended work to an endpoint without rolling caps. See the next section.

When waiting isn’t an option

claude-auto-retry makes limits painless when the work can wait a few hours. Some workloads can’t — always-on agents, batch jobs, anything that has to keep moving at 4am.

Claude Code speaks the Anthropic Messages API, which means it can point at any compatible endpoint — including ours. CheapestInference serves open-weight models across three pools (Kimi K3 and Qwen3.8 Max in the Flagship pool; GLM 5.3 and MiniMax M3 in the Frontier pool; DeepSeek V4.1 Flash and MiMo V2.6 Flash in the budget Core pool) through an Anthropic-compatible endpoint, with a different limits model: you reserve daily 8-hour time blocks, and during your reserved hours inference is unlimited — there is no usage-limit message to parse, because there is no rolling cap to hit.

export ANTHROPIC_BASE_URL="https://api.cheapestinference.com/anthropic"
export ANTHROPIC_AUTH_TOKEN="your-api-key"
export ANTHROPIC_MODEL="glm-5.3"
claude

Model-by-model setup: Kimi K3, GLM 5.3 or DeepSeek in Claude Code. And if you’re weighing a switch of harness instead, the field is mapped in Claude Code alternatives in 2026.

The two approaches compose. Plenty of people keep their Claude subscription for interactive work and run the long unattended stuff — the runs that would otherwise die at 11pm — on an open-weight model during a reserved block. Open-weight coding models are closer to frontier than most people assume; here’s the current evidence.

Either way: stop typing “continue”.

OpenRouter alternatives in 2026: unified LLM APIs compared

Wed, 15 Apr 2026 00:00:00 GMT

OpenRouter solved a real problem: one API key, hundreds of models, no separate accounts per provider. You point your code at openrouter.ai/api/v1 and pick any model from any provider.

But OpenRouter isn’t the only unified API anymore. And depending on your workload, it might not be the cheapest or fastest option. Here’s how the alternatives compare.

What OpenRouter does well

Credit where it’s due:

Model coverage: 200+ models from dozens of providers. If a model exists, OpenRouter probably has it.
Automatic routing: openrouter/auto picks a model for you based on your prompt. Useful for prototyping.
Fallback: If one provider is down, OpenRouter routes to another. You don’t handle failover yourself.
Single billing: One account, one API key, one invoice. No managing 8 provider accounts.

For developers who want access to everything and don’t want to manage multiple integrations, OpenRouter is a good default.

Where OpenRouter gets expensive

OpenRouter adds a margin on top of each provider’s per-token price. This is how they make money — they’re a reseller. The markup varies by model but is typically 5–20% above the direct provider price.

For low-volume usage, the convenience premium is negligible. For high-volume or agent workloads, it compounds:

Model	Direct price (input)	OpenRouter price	Markup
Claude Sonnet 4.6	$3.00/M	$3.00/M	0%
DeepSeek V3.2	$0.27/M	$0.30/M	+11%
Llama 3.1 70B	$0.13/M	$0.16/M	+23%
Qwen 3.5 397B	$0.40/M	$0.48/M	+20%

The markup is smallest on premium models (where the provider’s price already includes healthy margin) and largest on cheap open-source models (where OpenRouter’s fixed costs are a bigger percentage).

For an agent consuming 10M tokens/day on DeepSeek V3.2, the markup adds $9/month. Not a lot. But on a team of 10 with multiple agents each, it adds up — and the per-token model itself is the real problem for agent workloads.

The alternatives

Together AI

Best for: Fastest open-source model inference.

Together runs their own GPU clusters optimized for open-source models. No reselling — they serve the models directly. This means lower latency and often lower prices than OpenRouter for the same model.

100+ models
Own infrastructure (not reselling)
Competitive pricing on open-source models
Dedicated endpoints for production workloads
Per-token pricing only

Together doesn’t carry proprietary models (no Claude, no GPT). If you need Anthropic or OpenAI alongside open-source, you need a second integration.

Fireworks

Best for: Low-latency inference with custom model support.

Fireworks focuses on speed. Their custom serving infrastructure delivers lower latency than most providers, especially for open-source models. They also support fine-tuned model deployment.

50+ models
Very low latency
Fine-tuned model hosting
Serverless and dedicated options
Per-token pricing only

Like Together, Fireworks doesn’t carry proprietary models natively.

Groq

Best for: Absolute lowest latency.

Groq’s custom LPU hardware delivers the fastest inference in the market for supported models. If your use case is latency-sensitive (real-time chat, voice agents), Groq is hard to beat.

15+ models (smaller catalog)
Sub-second TTFT on most models
Free tier available
Per-token pricing

Limited model selection. No Claude, no GPT. But what they have is fast.

CheapestInference

Best for: Agent workloads and cost certainty.

Full disclosure — this is us. Here’s what we do differently:

Time-block subscriptions: Subscribe to a model pool and reserve one or more daily 8-hour blocks (Asia-Pacific, Europe, or Americas — all three for full 24/7 coverage). The Frontier pool ($57–$61/mo per block, from $60.35/mo billed annually) carries GLM 5.3 and MiniMax M3. The Core pool (from $22/mo per block, from $18.70/mo annually) carries DeepSeek V4.1 Flash and MiMo V2.6 Flash. No per-token billing.
Unlimited during your hours: During your reserved block, usage of every model in your pool is unlimited with no budget cap — fair use is one request at a time per key. Pay by card (Stripe) or USDC on Base.
A focused lineup: six curated open-weight models through one OpenAI- and Anthropic-compatible endpoint.
x402 pay-per-request: No account needed — agents pay with USDC on Base L2 per request.

The trade-off: a small, curated model catalog instead of OpenRouter’s breadth, no proprietary models, and no automatic routing between providers.

Side-by-side comparison

	OpenRouter	Together	Fireworks	Groq	CheapestInf.
Models	200+	100+	50+	15+	6 (curated)
Proprietary models	Yes	No	No	No	No
Pricing model	Per-token	Per-token	Per-token	Per-token	Time-block flat-rate
Unlimited in reserved hours	No	No	No	No	Yes
Auto routing	Yes	No	No	No	No
API format	OpenAI	OpenAI	OpenAI	OpenAI	OpenAI

Every provider on this list is OpenAI-compatible. Switching between them is a base_url change.

Cost comparison for real workloads

Light usage (chatbot, ~3M tokens/month)

OpenRouter

$4.20/mo

Together AI

$3.60/mo

CheapestInference

from $18.70/mo (Core)

At very low volume, per-token is genuinely cheaper — the Core pool ($22/mo month-to-month, unlimited DeepSeek V4.1 Flash and MiMo V2.6 Flash during your block) costs roughly thirteen dollars more at this size. What it buys is a flat bill: past roughly 12M tokens/month the per-token lines cross it, and it stays flat no matter how far the chatbot grows.

Heavy usage (agents, ~300M tokens/month)

OpenRouter

$420/mo

Together AI

$360/mo

CheapestInference

from $60.35/mo

At agent-scale volume, a time-block subscription is dramatically cheaper. The gap grows with usage because per-token scales linearly and a reserved block is unlimited — it doesn’t scale at all.

When to use what

Stay on OpenRouter if: You need access to 200+ models, use auto-routing, and your monthly spend is under $50. The convenience premium is worth it at this scale.

Switch to Together/Fireworks if: You only use open-source models, care about latency, and want to avoid the reseller markup. Together and Fireworks serve models directly.

Switch to CheapestInference if: You run agents during predictable hours, want cost certainty, and the curated open-weight lineup covers your needs — GLM 5.3 and MiniMax M3 in the Frontier pool, or DeepSeek V4.1 Flash and MiMo V2.6 Flash in the budget Core pool. Unlimited inference during a reserved time block beats per-token billing once your usage in those hours is heavy.

Use Groq if: Latency is your primary constraint and your model is in their catalog.

All five are OpenAI-compatible. Try each one with a base_url swap and see which fits.

CheapestInference serves a curated open-weight lineup across two pools — GLM 5.3 and MiniMax M3 (Frontier); DeepSeek V4.1 Flash and MiMo V2.6 Flash (Core) — through one OpenAI- and Anthropic-compatible API. Unlimited time-block subscriptions from $18.70/mo (Core) or $60.35/mo (Frontier), billed annually. See the pools or get started.

Self-hosted vs. API inference: the real cost comparison

Wed, 15 Apr 2026 00:00:00 GMT

“Why pay for an API when I can run the model myself?”

It’s a reasonable question. Open-source models are free. GPUs are available on every cloud. vLLM and Ollama make serving straightforward. The math should be simple: GPU cost per hour × hours = total cost. Done.

Except it’s not. The GPU is the minority of the cost. Here’s the full picture.

The visible costs

GPU hardware

Running DeepSeek V3.2 (671B MoE, ~130B active parameters) requires at least 4× A100 80GB or 2× H100 80GB in FP8. Qwen 3.5 397B has similar requirements.

Setup	Hourly	Monthly (24/7)	Monthly (8h/day)
4× A100 80GB (cloud)	$12.80	$9,216	$2,816
2× H100 80GB (cloud)	$8.40	$6,048	$1,848
1× A100 80GB (Llama 70B)	$3.20	$2,304	$704
1× L40S (Llama 8B)	$1.10	$792	$242

These are cloud GPU rental prices (AWS, GCP, Lambda Labs — varies by provider and availability). If you buy hardware, the upfront cost is $15K–$40K per GPU, amortized over 3–4 years, plus electricity, cooling, and data center costs.

Smaller models are cheaper — but limited

Running Llama 3.1 8B on a single L40S costs $242/month (8h/day). That’s competitive with API pricing. But 8B models can’t handle complex coding, multi-step reasoning, or nuanced analysis — the tasks where AI provides the most value.

The models worth self-hosting (70B+, MoE) require multi-GPU setups where the economics change dramatically.

The invisible costs

GPU rental is just the beginning.

1. Operations and maintenance

Someone has to:

Set up vLLM/TGI with optimal batch sizes, quantization, and memory allocation
Monitor GPU utilization and restart crashed processes
Update model weights when new versions release
Handle OOM errors, NCCL failures, and driver issues
Manage the serving infrastructure (load balancer, health checks, auto-scaling)

If this is a full-time DevOps engineer at $150K/year, that’s $12,500/month in labor. If it’s 20% of a senior engineer’s time, it’s $2,500/month. Either way, it’s more than the GPU.

2. Idle capacity

GPUs cost money whether they’re inferring or not. If your usage pattern is 8 hours of heavy use (work hours) and 16 hours of near-zero traffic, you’re paying for 24 hours and using 8.

Cloud spot instances help but introduce availability risk. Auto-scaling GPU clusters is possible but complex — model loading takes minutes, not seconds.

API pricing is purely usage-based. Zero requests = zero cost.

3. Multi-model overhead

Self-hosting one model is manageable. Self-hosting five models for different tasks — a coding model, a reasoning model, a fast classification model, an embedding model, and a vision model — requires either:

5 separate GPU instances (expensive)
Shared GPU with model swapping (slow — loading a 70B model takes 2–5 minutes)
A serving framework that handles multi-model routing (complex)

An API gives you access to many models through the same endpoint. No model loading, no GPU allocation, no routing logic.

4. Opportunity cost

Every hour your team spends on inference infrastructure is an hour not spent on your actual product. For startups, this is the most expensive cost of all — it doesn’t show up on any invoice.

Total cost of ownership

For a team of 5 developers running AI-assisted coding with a mix of DeepSeek V3.2 and smaller models:

Cost	Self-hosted	API (per-token)	API (time-block sub)
Compute/inference	$2,800	$265	$250
Ops/maintenance	$2,500	$0	$0
Idle waste (~60%)	$1,680	$0	$0
Total monthly	$6,980	$265	$250

Self-hosting costs 26x more for the same workload. The GPU is only 40% of the self-hosted cost — ops and idle waste are the majority.

When self-hosting makes sense

Self-hosting wins in specific scenarios:

Data sovereignty: If your data cannot leave your network — regulated industries, government, healthcare with strict compliance — self-hosting is the only option. No API provider can guarantee the data isolation you need.

Extreme scale: If you’re processing millions of requests per day and your GPUs are consistently at 80%+ utilization, the per-token math eventually favors owned hardware. This threshold is higher than most teams expect — typically $20K+/month in API spend before self-hosting breaks even.

Custom models: If you’ve fine-tuned a model and need to serve it, self-hosting or a dedicated inference provider (Fireworks, Together) is required. Most unified APIs don’t serve custom model weights.

Latency control: If you need guaranteed sub-100ms TTFT and your data center is co-located with your GPUs, self-hosting eliminates network hops.

For everyone else — startups, small teams, companies with variable usage patterns — the API is cheaper, faster to set up, and easier to maintain.

The migration path

Most teams don’t need to choose one forever. A practical approach:

Start with an API: Get your product working, validate demand, understand your usage patterns.
Optimize model selection: Use cheaper models for simple tasks, frontier models for hard tasks. Full guide: Multi-model architecture.
Evaluate self-hosting when: Your monthly API spend exceeds $10K, your GPU utilization would be >70%, and you have DevOps capacity to maintain it.
Hybrid: Self-host your high-volume models, use an API for long-tail models and overflow capacity.

The worst outcome is spending 3 months setting up GPU infrastructure before you’ve validated that anyone wants your product.

CheapestInference serves five open-weight models across two pools — GLM 5.3 and MiniMax M3 (Frontier); DeepSeek V4.1 Flash and MiMo V2.6 Flash (Core) — through a single API. No GPUs to manage, no idle costs, no ops burden. Reserve a daily 8-hour time block for unlimited usage from $18.70/mo (Core) or $60.35/mo (Frontier), billed annually — reserve all three blocks for full 24/7. Get started or see the pools.