models

11 posts with the tag “models”

GLM-5.3: specs, benchmarks, pricing & API options — and our review status

Aug 14, 2026

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 is officially under review for our pools, as of today. 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	Promised ~2 weeks after launch, pending Z.ai’s safety evaluation — no weights, no license, no model card today
License	Unpublished. GLM 5.2 shipped MIT; that precedent does not automatically set 5.3’s terms
List price (API)	Not yet published — GLM 5.2 lists $1.40 in / $4.40 out per 1M as reference
Availability today	First-party API access from Z.ai only — no open weights, no third-party serving yet; works with Claude Code, OpenCode, 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	1M via Z.ai’s `[1m]` variant; standard API unpublished	198K as served here
Reasoning	Effort `low` / `high` / `max`, thinking always on	Standard GLM 5.2 semantics
Open weights	Promised ~2 weeks post-launch	Published (MIT)
List price (per 1M)	Not yet published	$1.40 in / $4.40 out
Status here	Under review — Frontier candidate	Live in the Frontier Pool

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) runs in parallel: ⏳ in progress.
Fit — a post-training upgrade of a model already serving Frontier Pool workloads: as clean as fit gets.
Licensing — ⏳ waiting on Z.ai’s open-weights release and license text, on the ~two-week clock Z.ai itself set.

Track it live on the models-under-review page — states move Reviewing → Confirmed → Capacity secured → live in the changelog. If you want your workload to count in the decision: support@cheapestinference.com.

Common questions

Is there an unlimited GLM-5.3 API? Not yet, from anyone. GLM-5.3 is API-only and first-party today. It is under review for our flat-rate unlimited pools as a Frontier Pool candidate; meanwhile, GLM 5.2 — same base model — is served unlimited on time-block subscriptions today.

Does GLM-5.3 have open weights? Not yet. Z.ai has committed to releasing open weights roughly two weeks after the August 14 launch, once its internal safety evaluation of the model’s cyber capabilities is complete. No license text or model card has been published; GLM 5.2’s MIT license doesn’t automatically carry over.

How much does the GLM-5.3 API cost? Per-token list pricing hasn’t been published — the closest reference is GLM 5.2’s list rate ($1.40 in / $4.40 out per 1M) until Z.ai posts 5.3 rates.

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.

What is the context window of GLM-5.3? Z.ai advertises 1M tokens via the glm-5.3[1m] variant with context compaction. The standard-API context spec hasn’t been published yet.

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

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

Aug 4, 2026

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 $149/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 $149/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 $149/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

Aug 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 $17.99/mo ($15.29/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.2 and MiniMax M3 (Frontier Pool) and DeepSeek V4 Flash and MiMo v2.5 (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

Jul 27, 2026 - Last update: Jul 28, 2026

Kimi K3 is live on CheapestInference: Moonshot’s flagship — scoring 60 on the Artificial Analysis Intelligence Index — the top open-weights score — served through an OpenAI- and Anthropic-compatible API with unlimited usage at a flat monthly price, from $149/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 $149/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 $149/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

Jul 22, 2026 - Last update: Jul 28, 2026

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 $149/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 $149/mo), GLM 5.2 and MiniMax M3 (Frontier Pool, from $50.15/mo billed annually) and DeepSeek V4 Flash and MiMo v2.5 (Core Pool, from $15.29/mo) 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

Jul 9, 2026 - Last update: Aug 15, 2026

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.2, DeepSeek V4 Flash, MiMo v2.5, 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.2 and MiniMax M3 (1M context); the Core Pool covers DeepSeek V4 Flash and MiMo v2.5 — 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

Jul 8, 2026

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

Jul 6, 2026 - Last update: Aug 1, 2026

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 (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 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 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.5 included. A Core Pool subscription covers every model in the pool — Xiaomi’s MiMo v2.5 shares the same 1M-context class.
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-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-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 Flash (the 0731 build) during your reserved daily 8-hour blocks, plus MiMo v2.5 in the same Core Pool.

How much does a DeepSeek subscription cost? From $17.99/month per 8-hour daily block ($15.29/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 serves the current V4 Flash build under the stable model id deepseek-v4-flash; when DeepSeek retrained it (V4-Flash-0731, July 2026), subscribers got the new build with no migration.

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 Flash and MiMo v2.5 (Core Pool, from $15.29/mo billed annually) and GLM 5.2 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

Jul 6, 2026 - Last update: Aug 14, 2026

Update — August 14, 2026: Z.ai just released GLM-5.3 — the same base model as GLM 5.2 with extended post-training (open weights promised ~2 weeks out). It’s officially under review for our pools — 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.2, Kimi K2.7, and MiniMax M3 (Frontier Pool, from $50.15/mo billed annually) and DeepSeek V4 Flash and MiMo v2.5 (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

Jul 6, 2026

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.

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 is served in the Core Pool alongside DeepSeek V4 Flash, 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.5",
    "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.5. Full details on the MiMo v2.5 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.

Building a multi-model architecture: route requests to the right LLM

Mar 19, 2026

Using one model for everything is the simplest architecture. It’s also the most wasteful. A 685B-parameter reasoning model answering “what’s the weather?” is like hiring a PhD to sort mail.

This guide covers how to use a small, fast model to classify incoming requests and route them to the right specialist. The result: lower latency, lower cost, and often better quality — because each model handles what it’s actually good at.

The problem with single-model architectures

Most applications start with one model:

User request --> Large Model --> Response

This works, but every request — simple or complex — pays the same latency and cost penalty. When 60% of your traffic is simple classification, FAQ, or extraction, you’re burning expensive compute on tasks a small model handles equally well.

Llama 3.1 8B

~200 t/s

DeepSeek V3.2

~60 t/s

DeepSeek R1

~30 t/s

The gap between Llama 8B and R1 is nearly 7x in throughput. Routing simple requests to the small model saves that difference on every request.

The multi-model architecture

User request --> Router (GLM 5.2) --> classify intent
                                          |
                  +-----------+-----------+-----------+
                  |           |           |           |
           simple/general  reasoning    code        agent
                  |           |           |           |
               GLM 5.2    MiniMax M3  MiniMax M3  MiniMax M3
                  |           |           |           |
                  +-----+-----+-----+-----+
                        |
                     Response

Two stages:

Classify — The router model reads the user’s message and outputs a category. A fast model returns this in a fraction of a second.
Route — Based on the category, forward the request to the appropriate specialist model.

The router adds minimal overhead (~200ms) but saves significant compute by keeping simple requests away from expensive models.

Step 1: Classify with a fast model

A fast, lightweight model makes a good router. With low TTFT and a short, single-word output, the classification step costs almost nothing and completes before the user notices. (On CheapestInference, DeepSeek V4 Flash or MiMo v2.5 in the Core pool are natural router models; the example below uses GLM 5.2 so everything runs on one Frontier subscription.)

The classification prompt is simple — you want a single-word category, not a conversation:

from openai import OpenAI

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

def classify_request(user_message: str) -> str:
    """Classify a user message into a routing category."""
    response = client.chat.completions.create(
        model="glm-5.2",
        messages=[
            {
                "role": "system",
                "content": (
                    "Classify the user's message into exactly one category. "
                    "Respond with only the category name, nothing else.\n\n"
                    "Categories:\n"
                    "- simple: greetings, FAQ, simple factual questions\n"
                    "- general: complex questions, analysis, writing, summarization\n"
                    "- reasoning: math, logic, multi-step problems, science\n"
                    "- code: code generation, debugging, refactoring, technical implementation\n"
                    "- agent: tasks requiring tool use, web search, or multi-step execution"
                )
            },
            {"role": "user", "content": user_message}
        ],
        max_tokens=10,
        temperature=0
    )
    category = response.choices[0].message.content.strip().lower()
    # Default to general if classification is unclear
    valid = {"simple", "general", "reasoning", "code", "agent"}
    return category if category in valid else "general"

The key details: max_tokens=10 because we only need one word. temperature=0 for deterministic routing. The system prompt is explicit about format — no preamble, just the category.

Step 2: Route to the specialist

Each category maps to a model optimized for that task:

# Model routing table
ROUTE_TABLE = {
    "simple":    "glm-5.2",
    "general":   "glm-5.2",
    "reasoning": "MiniMax-M3",
    "code":      "MiniMax-M3",
    "agent":     "minimax-m3",
}

def route_request(user_message: str, conversation_history: list) -> str:
    """Classify and route a request to the appropriate model."""
    category = classify_request(user_message)
    model = ROUTE_TABLE[category]

    response = client.chat.completions.create(
        model=model,
        messages=conversation_history + [
            {"role": "user", "content": user_message}
        ],
        stream=True
    )

    # Stream the response back
    full_response = ""
    for chunk in response:
        if chunk.choices[0].delta.content:
            content = chunk.choices[0].delta.content
            full_response += content
            print(content, end="", flush=True)

    return full_response

Notice that simple requests route back to GLM 5.2 — the same model that did the classification. For simple queries, the router overhead is effectively zero because the specialist is the same model and can reuse the warm connection.

Step 3: Handle edge cases

The basic router works for most traffic, but production systems need a few refinements:

def route_request_production(
    user_message: str,
    conversation_history: list,
    force_model: str = None
) -> tuple[str, str]:
    """Production router with overrides and fallback."""

    # Allow explicit model override (for power users or testing)
    if force_model:
        model = force_model
        category = "override"
    else:
        category = classify_request(user_message)
        model = ROUTE_TABLE[category]

    try:
        response = client.chat.completions.create(
            model=model,
            messages=conversation_history + [
                {"role": "user", "content": user_message}
            ]
        )
        return response.choices[0].message.content, category

    except Exception:
        # Fallback to GLM 5.2 if the specialist is unavailable
        fallback = "glm-5.2"
        response = client.chat.completions.create(
            model=fallback,
            messages=conversation_history + [
                {"role": "user", "content": user_message}
            ]
        )
        return response.choices[0].message.content, f"{category}->fallback"

Three patterns worth noting:

Force model — Let callers bypass routing when they know what they need.
Fallback — If a specialist model is down, fall back to GLM 5.2. It handles everything reasonably well.
Return the category — Log which route each request takes. You’ll need this data to tune the system.

Cost and latency comparison

Consider a workload of 1,000 requests with this distribution: 600 simple, 300 general, 70 reasoning, 30 code. Average 500 input tokens, 200 output tokens per request.

Single-model approach (everything on V3.2)

Avg latency

~4.5s

All 1000 reqs

V3.2 only

Every request waits for V3.2’s ~1.2s TTFT plus generation time at ~60 t/s. Simple questions get the same treatment as complex analysis.

Multi-model approach (routed)

Simple (600)

~1.2s (8B)

General (300)

~4.7s (V3.2)

Reasoning (70)

~9.0s (R1)

Code (30)

~3.5s (Coder)

The weighted average latency drops to approximately 2.7s — a 40% reduction. The 600 simple requests finish in ~1.2s instead of ~4.5s. That’s a 3.7x improvement for the majority of your traffic.

The 70 reasoning requests are slower individually (~9s vs ~4.5s) because R1 generates chain-of-thought tokens. But the quality on those specific requests is significantly better — R1 scores 50.2% on HLE versus V3.2’s 39.3%.

You get faster averages and better quality on the hard tail.

Real example: a support chatbot

A customer support chatbot receives three types of requests:

FAQ (60%) — “What are your business hours?” / “How do I reset my password?”
Complex support (30%) — “I was charged twice for order #12345, can you investigate?”
Technical issues (10%) — “Your API returns 500 when I send multipart form data with UTF-8 filenames”

Without routing

All requests go to DeepSeek V3.2. FAQs get correct answers but with unnecessary latency. Technical issues get decent answers but miss edge cases that a code-specialized model would catch.

With routing

SUPPORT_ROUTES = {
    "simple":    "glm-5.2",       # FAQ, greetings
    "general":   "glm-5.2",       # Complex support
    "reasoning": "glm-5.2",       # Investigations
    "code":      "glm-5.2",       # Technical issues
    "agent":     "minimax-m3",     # Multi-step resolution
}

FAQs resolve quickly via GLM 5.2. Complex support issues get GLM 5.2’s full analytical capability. Technical problems also route to GLM 5.2, which understands the code context well. If a support issue requires looking up order data via API, it routes to MiniMax M3 for tool-assisted resolution.

The classification step adds ~200ms. For the 60% of requests that drop from ~4.5s to ~1.2s, that’s an invisible cost.

When NOT to use multi-model routing

Routing adds complexity. Skip it when:

All your requests are the same type. If you’re building a code editor, just use a single coding model like GLM 5.2. No routing needed.
You have fewer than 100 requests/day. The cost savings don’t justify the engineering overhead at low volume.
Latency doesn’t matter. For batch processing or async workloads, a single capable model is simpler.
Your classification accuracy is low. If the router misclassifies frequently, you get worse results than a single good model. Test the classifier on real traffic before deploying.

The sweet spot is high-volume applications with diverse request types — chatbots, API gateways, developer tools, and customer-facing products where response time directly affects user experience.

Implementation checklist

Log your traffic. Before building a router, understand your request distribution. What percentage is simple? Complex? Code?
Start with two tiers. A fast, lighter model for simple requests, and a stronger model like MiniMax M3 for everything that needs deep reasoning, code, or long context. Add specialists only when you have data showing they help.
Measure classification accuracy. Sample 100 requests, manually label them, compare against the router’s output. Target >90% accuracy.
Add fallback. Every specialist route should fall back to GLM 5.2 if the specialist is unavailable.
Monitor per-route metrics. Track latency, cost, and quality per category. This tells you where to optimize next.

The routing pattern works with any OpenAI-compatible API. The code examples in this guide use the model ids we actually serve — GLM 5.2 and MiniMax M3 from our Frontier pool (DeepSeek V4 Flash and MiMo v2.5 in the Core pool make great router models too); the throughput and latency comparisons cite ecosystem reference models like Llama and DeepSeek V3.2/R1 for context. If you’re building a platform that needs LLM access for your users, see how per-key plans work.

Sources: Artificial Analysis Leaderboard · DeepSeek V3.2 · HLE Leaderboard