English 
Deutsch 
Español 
Italiano 
Français 
There is a very specific kind of decision fatigue that hits you at about 11pm, three coffees in, staring at OpenCode’s model picker.
You have a Z.ai key. You have a MiniMax key. Both models claim a million tokens of context. Both are open-weight. Both cost roughly nothing compared to the frontier closed models. Both have a benchmark chart where they are winning. And you just want to know which one to set as your default so you can get back to work.
This article is the answer to that question — the long version, because the short version (“GLM-5.3-Flash, probably”) hides about six caveats that will bite you if you skip them.
I have pulled the architecture details, the vendor benchmarks, the neutral evaluations, the real per-token pricing including the tiered long-context trap, OpenCode’s own published usage telemetry, and the actual configuration files for both. Then I did the cost math for a normal working month instead of a press-release scenario.
Here is what came out.
TL;DR — The 30-Second Verdict
Run GLM-5.3-Flash as your default OpenCode model. It is smarter on nearly every agentic and coding benchmark that matters, it costs roughly half as much per token, it is genuinely MIT-licensed, and it is where the OpenCode community has actually gone.
Keep MiniMax M3 as your speed lane. It generates roughly three times faster and answers roughly twice as quickly on first token. For high-turn, low-difficulty loops — file renames, test scaffolding, doc generation, lint-and-fix passes, big mechanical refactors — that speed difference is felt more than the intelligence gap.
The honest one-liner: GLM-5.3-Flash thinks better, MiniMax M3 types faster. Agentic coding is mostly a thinking problem, so GLM wins the default slot. But if you are not running both, you are leaving throughput on the table, and OpenCode makes running both trivially easy.
Quick Comparison Table
| GLM-5.3-Flash | MiniMax M3 | |
|---|---|---|
| Maker | Z.ai (Zhipu AI) | MiniMax |
| Released | 26 August 2026 | 1 June 2026 |
| Total parameters | 320B | ~428B |
| Active per token | 18B | ~23B |
| Architecture | Hybrid KDA linear attention + NoPE sparse MLA, MoE (8 of 288 experts + 1 shared) | GQA backbone + MiniMax Sparse Attention (MSA), sparse MoE |
| Context window | 1M (1,048,576) | 1M (512K guaranteed floor) |
| Max output | 131,072 tokens | up to 262,144 tokens |
| Multimodal input | Text, image, video, file | Text, image, video |
| Licence | MIT | MiniMax Community License |
| API input price | $0.15 / 1M ($0.03 cached) | $0.30 / 1M ($0.06 cached) |
| API output price | $0.50 / 1M | $1.20 / 1M |
| Long-context surcharge | None published | 2× above 512K input |
| Output speed | ~48.6 tok/sec | ~147.9 tok/sec |
| Time to first token | ~1.51s | ~0.99s |
| Terminal-Bench 2.1 | 84.3 | 66.0 |
| Artificial Analysis Intelligence | 57 | 45 |
| OpenCode token share | 10.3% | 1.12% |
| Thinking mode | Always on (cannot disable) | Configurable |
| Subscription entry price | $18/mo (GLM Coding Plan Lite) | $20/mo (MiniMax Plus) |
Pricing is official list pricing from each vendor. Routed gateways such as OpenRouter frequently show lower effective prices because they load-balance across third-party hosts — more on that below, because it matters.
Why This Comparison Is The One That Matters Right Now
Twelve months ago, the open-weight coding conversation was about whether these models were usable at all. That question is settled. The conversation in the second half of 2026 is narrower and more interesting: which open-weight model do you point your agent harness at, and what does it cost you to be wrong?
OpenCode sharpened that question. It is not a chat window — it is a terminal-native agent that plans, reads files, edits them, runs commands, reads the output, and iterates. That workload punishes models in ways a chat benchmark never surfaces. A model that writes beautiful isolated functions can still be useless in OpenCode if it loses the thread after twenty tool calls, or hallucinates a file path, or burns 90,000 tokens deciding what to do.
GLM-5.3-Flash and MiniMax M3 are the two open-weight models most credibly in that conversation right now. They arrived within three months of each other, they target the same job, they are priced within the same order of magnitude, and they made almost opposite engineering bets.
That last part is the interesting bit.
What GLM-5.3-Flash Actually Is
GLM-5.3-Flash had one of the better launches of the year, and it was not an accident.
Before Z.ai put its name on anything, the model appeared on OpenRouter under the codename “Ox Alpha.” No lab attribution, near-free access, no marketing. It quietly climbed to the top of the OpenRouter and OpenCode usage charts and stayed there for about a week while the community argued about who had built it. On 26 August 2026, Z.ai confirmed it was theirs and open-sourced the weights under MIT.
Launching a model into the wild and letting it earn credibility before claiming it is a genuinely good move, and it worked — the model had real usage data behind it before anyone had seen a benchmark chart.
The architecture, in plain language
GLM-5.3-Flash is a 320-billion-parameter mixture-of-experts model that only activates about 18 billion parameters per token. It routes each token through 8 of 288 routed experts plus one shared expert — roughly 2.8% of the expert weights fire on any given forward pass. That is where the “Flash” economics come from: frontier-scale knowledge, small-model inference cost.
The attention design is the genuinely novel part. Instead of one uniform attention mechanism, it interleaves two:
- 34 KDA linear-attention layers. These run in linear time relative to sequence length instead of quadratic. They handle local dependencies cheaply and keep throughput from collapsing as your context grows.
- 11 NoPE sparse MLA layers. DeepSeek-style multi-head latent attention with no positional embeddings, fronted by a “lightning indexer” that selects the top 2,048 most relevant tokens out of the full context. This is what preserves long-range retrieval quality.
There is also an IndexPool compression step that aggregates indexer key vectors to cut memory overhead at extreme context lengths, and a multi-token prediction head for speculative decoding — the vLLM implementation defaults to 5 speculative tokens per decode step, worth 2–3× throughput at small batch sizes.
Net effect versus the full GLM-5.3: roughly 3× lower attention compute and a KV cache more than 4× smaller. That is why a 1M-token context is actually usable rather than theoretically available.
Why it matters for coding agents
Three things, specifically.
It is natively multimodal, and that is not a gimmick here. Earlier GLM coding models had a blind spot for anything they could not read as text. If your agent breaks a layout, a text-only model has no way to know. GLM-5.3-Flash accepts images, video and files natively, which means screenshot-driven debugging, design-to-code, and “does this actually look right” verification loops are on the table.
Thinking is mandatory. You cannot turn it off. You can set reasoning_effort to low, high, or max (the documented default is max), but the model always reasons before it acts. For agentic work this is the right default — the failure mode of cheap coding models is confident action without planning, and Z.ai has removed that option.
The generational jump is real, and it came from post-training. GLM-5.3 reuses the same base model as GLM-5.2. Every gain came from scaling post-training — reportedly tenfold more long-horizon task environments, with training tasks that simulated complete software lifecycles from bug identification through testing and deployment, some sized to “the workload of a senior engineer over several days.” The DeepSWE v1.1 score went from 46.2 to 63.4. Terminal-Bench 3.0 went from 4.6 to 28.3. Those are not tuning-noise deltas.
What MiniMax M3 Actually Is
MiniMax M3 landed on 1 June 2026 and made a different bet: rather than optimising for peak reasoning, optimise for the economics of sustained agent loops.
It is a ~428B-parameter sparse MoE with roughly 23B active parameters per token, built on a grouped-query-attention backbone with MiniMax’s own MSA (MiniMax Sparse Attention) on top.
The MSA bet
Traditional attention is quadratic: double the context, quadruple the compute. That is the reason most “1M context” models are 1M context on paper and 150K context in practice — you technically can fill the window, but you will not want to pay for it.
MSA replaces full attention with KV-block selection. It pre-filters the context down to relevant blocks and attends only to those, using uncompressed key-values so retrieval quality survives the filtering. MiniMax reports the result as roughly 1/20th the per-token compute of the previous generation at 1M context, with 9.7× faster prefill and 15.6× faster decoding versus M2.
This is a legitimately smart piece of engineering, and it shows up in the numbers you feel: ~148 tokens/sec output and sub-second time to first token. Next to GLM-5.3-Flash’s ~49 tok/sec and ~1.5s TTFT, M3 feels like a different class of tool. In a long agent loop with dozens of turns, that compounds into minutes of wall-clock difference per task.
MiniMax also markets M3 as capable of “8+ hour autonomous coding sessions.” Treat that as a claim, not a spec — it has not been independently validated.
Where M3 is genuinely strong
The multimodal and desktop-agent side of M3 is underrated. OSWorld-Verified at 70.06% is a serious score for desktop/GUI agent tasks. MCP Atlas at 74.2% says its tool-invocation behaviour is solid. GPQA Diamond at 92.9% is frontier-adjacent on hard reasoning. And SWE-bench Verified at 80.5% is a strong headline number.
If your workload is “drive a browser, read a video, operate a UI, call twelve MCP tools in sequence,” M3 is not a compromise. It is arguably the better tool.
The Benchmarks — And What They Are Hiding
Here is where I need to be careful, because both vendors publish their own numbers and the two models are largely evaluated on different benchmark sets. That is not accidental. Labs pick the evaluations they win.
Where they overlap directly
| Benchmark | GLM-5.3-Flash | MiniMax M3 | What it measures |
|---|---|---|---|
| Terminal-Bench 2.1 | 84.3 | 66.0 | Shell/terminal agent tasks |
| Artificial Analysis Intelligence Index | 57 | 45 | Aggregate intelligence |
| Reasoning index (llm-stats) | 50.3 (#13) | 41.8 (#39) | Multi-step reasoning |
| Coding index (llm-stats) | 37.8 (#22) | 34.4 (#30) | Code generation |
| Agents index (llm-stats) | 39.1 (#9) | 27.8 (#38) | Agentic task completion |
| Tool Use index (llm-stats) | 34.2 (#4) | 22.8 (#42) | Function/tool calling |
| Vision index (llm-stats) | 32.0 (#21) | 25.6 (#37) | Multimodal understanding |
Terminal-Bench 2.1 is the one to weight most heavily for OpenCode, because it is the closest public proxy for what OpenCode actually does: an agent in a terminal, running commands, reading output, iterating. An 18-point gap there is not a rounding error.
The Tool Use ranking is the other one I would not skip. GLM-5.3-Flash at #4 overall versus M3 at #42 is the single most decision-relevant line in this entire article. An agent harness is a tool-calling machine. A model that is #42 at tool use will produce more malformed calls, more retries, more wasted turns — and every wasted turn costs you tokens and wall-clock time, which quietly erases M3’s speed advantage.
Where GLM-5.3-Flash stands on its own
- Terminal-Bench 2.1: 84.3 — against Claude Opus 4.8 at 85.0. Within a point of a frontier closed model, at roughly 1/30th the price.
- DeepSWE v1.1: 63.4 — up from GLM-5.2’s 46.2.
- AutomationBench v1.0.6: 48.8 — versus Opus 4.8 at 41.0. This is its largest lead over a frontier model.
- Z.ai Code Bench v1.0: 29.0 — Opus 4.8 scores 29.5.
- GDPval-AA v2: 1773 — top score among compared models on knowledge-work capability.
- Toolathlon: 78.4 · OfficeQA Pro: 62.4 · CharXiv-R: 89.4% · MMVU: 80.5 · Chartography: 78.0
Where MiniMax M3 stands on its own
- SWE-bench Verified: 80.5%
- SWE-bench Pro: 59.0% — harder repos, run with Claude Code scaffolding
- MCP Atlas: 74.2% · OSWorld-Verified: 70.06% · GPQA Diamond: 92.9%
- KernelBench Hard: 28.8% · SWE-fficiency: 34.8%
The caveat you should actually apply
Both labs’ launch numbers are self-reported. MiniMax’s benchmark suite in particular had not appeared on neutral evaluation boards at the time of its release, and Z.ai’s own analysts noted that automatic redirects from older model versions on Z.ai’s platform make clean A/B comparisons genuinely difficult.
Where the neutral aggregators — Artificial Analysis and llm-stats — have run their own evaluations, GLM-5.3-Flash wins every category. That is the evidence I weight highest, because neither vendor chose those benchmarks.
The Signal Nobody Talks About: OpenCode’s Own Usage Data
This is the part I found most persuasive, and it is the part most comparison articles skip entirely.
OpenCode publishes usage telemetry for the models running inside it. Not vendor claims. Not benchmark suites. Actual developers, doing actual work, choosing what to keep using.
| Metric | GLM-5.3-Flash | MiniMax M3 |
|---|---|---|
| Unique users | 566K | 436K |
| Share of tokens processed | 10.3% | 1.12% |
| Tokens over two months | 46T (+100%) | 5T (−51%) |
| Week-one returning users | pending | 66% (32K user-weeks) |
Read those two token-share numbers again. Roughly comparable user counts — GLM-5.3-Flash has about 30% more people who have tried it — but more than nine times the token throughput.
That gap is not about who tried what. It is about who stuck with what for real work. People open a session with M3, and people live in sessions with GLM-5.3-Flash.
The trend line says the same thing louder: GLM-5.3-Flash doubled its token volume over two months while M3 lost half of its own.
Two fair caveats. First, GLM-5.3-Flash is three months newer, and new models get a novelty bump; its curve will flatten. Second, M3’s 66% week-one retention is a healthy number — the people who chose it are not abandoning it, there are just fewer of them and they use it more lightly. And M3’s decline is partly cannibalisation from its own successors and the wider Chinese open-weight release cadence, not pure rejection.
But if you are asking “what are experienced OpenCode users actually running all day,” the data answers it without ambiguity.
Setting Up MiniMax M3 in OpenCode
Credit where it is due: MiniMax has the easier setup, because OpenCode ships a built-in MiniMax provider. No config file, no JSON, no base URL.
bash
# 1. Install OpenCode (skip if you already have it)
curl -fsSL https://opencode.ai/install | bash
# or: npm i -g opencode-ai
# 2. Authenticate
opencode auth login
# Select: "MiniMax Token Plan (minimax.io)"
# Paste your Subscription Key (starts sk-cp-...)
# 3. Go
opencodeThen /models inside the session and pick MiniMax-M3.
The key-type trap
This one catches almost everyone. MiniMax Token Plan (subscription) keys and pay-as-you-go API keys are not interchangeable. They route differently and bill differently. If you authenticate with a PAYG key against the Token Plan provider you will get authentication or balance errors that look like an outage and are actually a mismatch.
Subscription keys start with sk-cp- and require an assigned seat or credits. Get yours from the Token Plan page in the MiniMax user center, not the general API key page.
If you need a manual provider block
If your OpenCode build predates the built-in provider, or you want to point at a PAYG key explicitly:
json
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"minimax": {
"npm": "@ai-sdk/openai-compatible",
"name": "MiniMax",
"options": {
"baseURL": "https://api.minimax.io/v1",
"apiKey": "{env:MINIMAX_API_KEY}"
},
"models": {
"MiniMax-M3": {
"name": "MiniMax M3",
"limit": {
"context": 1000000,
"output": 262144
}
}
}
}
}
}Note the explicit limit.context. That is not decoration — see the next section.
The MiniMax Context-Window Trap (Read This Before You Commit)
If you route MiniMax M3 through an Anthropic-compatible harness — Claude Code, or an OpenCode setup using @ai-sdk/anthropic against https://api.minimax.io/anthropic — there is a documented, still-open bug you need to know about.
The /anthropic endpoint reports a 200K context window instead of M3’s actual 1M.
The compatibility layer appears to inherit Claude Sonnet’s metadata rather than reporting M3’s real specification. Coding agents trust that metadata and size their context budget accordingly — which means auto-compaction fires at around 167K tokens even though the model can comfortably hold five times that.
This is a properly annoying failure mode, because it is invisible. Your agent does not error. It just quietly starts forgetting things far earlier than it should, and you spend an afternoon wondering why a model with a million-token window keeps losing the plot two files into a refactor. The issue was filed on the day of M3’s release and remains open.
Working around it
In OpenCode: use the built-in MiniMax provider (OpenAI-compatible route) rather than the Anthropic route, and set limit.context explicitly if you define a manual provider block.
In Claude Code, override the compaction window directly:
json
{
"env": {
"ANTHROPIC_BASE_URL": "https://api.minimax.io/anthropic",
"ANTHROPIC_AUTH_TOKEN": "<YOUR_MINIMAX_SUBSCRIPTION_KEY>",
"CLAUDE_CODE_AUTO_COMPACT_WINDOW": "1000000",
"ANTHROPIC_MODEL": "MiniMax-M3[1m]",
"ANTHROPIC_DEFAULT_SONNET_MODEL": "MiniMax-M3[1m]",
"ANTHROPIC_DEFAULT_OPUS_MODEL": "MiniMax-M3[1m]",
"ANTHROPIC_DEFAULT_HAIKU_MODEL": "MiniMax-M3[1m]"
}
}Two details that matter: the [1m] suffix on the model ID requests the full-context variant, and shell environment variables override settings.json in MiniMax’s documented behaviour. If you have a stale ANTHROPIC_BASE_URL exported in your .zshrc, it wins silently and you will chase your tail.
Also — do not set provider credentials as global exports. ANTHROPIC_BASE_URL is a global variable; exporting it permanently will silently redirect every Anthropic-speaking tool on your machine to MiniMax. Scope it per-project or per-invocation.
Setting Up GLM-5.3-Flash in OpenCode
OpenCode also ships a built-in Z.AI provider, so this is nearly as easy — with one fork in the road.
bash
# 1. Get a key from Z.ai — either a standard API key or a GLM Coding Plan key
# 2. Authenticate
opencode auth login
# Select "Z.AI" for a standard API key
# Select "Z.AI Coding Plan" for a Coding Plan subscription key
# 3. Start OpenCode, then pick your model
opencode
/models # select GLM-5.3-FlashMatch the provider to the key type. Standard API keys and Coding Plan keys use different routes and different billing. Picking the wrong one produces auth or balance errors that look like a broken account.
The Coding Plan endpoints
If you are wiring things manually or configuring another tool, Z.ai’s developer pack exposes three:
| Protocol | Base URL |
|---|---|
| Anthropic Messages | https://api.z.ai/api/anthropic |
| OpenAI Chat Completions | https://api.z.ai/api/coding/paas/v4 |
| OpenAI Responses | https://api.z.ai/api/v1 |
One restriction worth flagging: the GLM Coding Plan is contractually limited to officially supported tools — Claude Code, OpenCode, Cline, Roo Code, Kilo Code, Cursor, Goose, Crush, OpenClaw and a handful of others. If you are planning to point a Coding Plan key at your own homegrown harness, read the terms first. Use the standard API for that.
Manual provider block
json
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"zai": {
"npm": "@ai-sdk/openai-compatible",
"name": "Z.AI",
"options": {
"baseURL": "https://api.z.ai/api/coding/paas/v4",
"apiKey": "{env:ZAI_API_KEY}"
},
"models": {
"glm-5.3-flash": {
"name": "GLM-5.3-Flash",
"limit": {
"context": 1048576,
"output": 131072
},
"options": {
"reasoning_effort": "high",
"temperature": 1,
"top_p": 0.95
}
}
}
}
},
"model": "zai/glm-5.3-flash"
}Recommended sampling settings
Z.ai’s documented recommendations for GLM-5.3-Flash, which I would not deviate from without a reason:
temperature: 1top_p: 0.95reasoning_effort: max(documented default)thinking.clear_thinking: falsestream: trueandtool_stream: truefor streaming requests
reasoning_effort is your main quality-versus-latency dial. low for latency-sensitive work, high for substantial coding, max for the hardest problems. Given GLM-5.3-Flash is already the slower of the two models at ~49 tok/sec, high is a sensible everyday setting and max is what you reach for when a task has genuinely defeated high.
The Setup I Would Actually Recommend: Run Both
This is the part where the “versus” framing breaks down, because OpenCode does not force you to pick one. Its config supports per-agent models, which means you can put the smart model on the hard job and the fast model on the grunt work.
json
{
"$schema": "https://opencode.ai/config.json",
"model": "zai/glm-5.3-flash",
"small_model": "minimax/MiniMax-M3",
"agent": {
"build": {
"model": "zai/glm-5.3-flash",
"options": { "reasoning_effort": "high" }
},
"plan": {
"model": "zai/glm-5.3-flash",
"options": { "reasoning_effort": "max" }
},
"grunt": {
"description": "Mechanical, high-volume edits: renames, test scaffolding, docstrings, lint fixes",
"model": "minimax/MiniMax-M3"
}
}
}The logic:
- Planning gets
reasoning_effort: maxon GLM-5.3-Flash. Planning is where a bad decision costs you the most downstream tokens. Buy the best thinking you can afford at this step. - Building gets
high. Good balance of quality and latency for the bulk of the work. - Mechanical work goes to M3. Renaming a symbol across 40 files does not need a #4-ranked tool-use model. It needs throughput, and M3 is three times faster.
small_modelhandles OpenCode’s internal housekeeping — title generation, summarisation, small utility calls. Point it at the fast, cheap one.
You are not choosing a winner. You are building a two-speed gearbox.
The Cost Math, With Real Numbers
Benchmarks are abstract. Invoices are not. Let me model a realistic agentic task and run it through both price sheets.
The scenario
One medium-sized feature, done agentically in OpenCode: roughly 60 tool-calling turns, averaging 45K input tokens per turn as context accumulates, and 2K output tokens per turn.
- Total input: 2.7M tokens
- Total output: 120K tokens
- Assumed prompt cache hit rate: 80% (2.16M cached, 540K fresh)
GLM-5.3-Flash
| Component | Tokens | Rate | Cost |
|---|---|---|---|
| Fresh input | 540K | $0.15/M | $0.081 |
| Cached input | 2.16M | $0.03/M | $0.065 |
| Output | 120K | $0.50/M | $0.060 |
| Total | ≈ $0.21 |
MiniMax M3 (standard tier, ≤512K input)
| Component | Tokens | Rate | Cost |
|---|---|---|---|
| Fresh input | 540K | $0.30/M | $0.162 |
| Cached input | 2.16M | $0.06/M | $0.130 |
| Output | 120K | $1.20/M | $0.144 |
| Total | ≈ $0.44 |
GLM-5.3-Flash is roughly 2.1× cheaper for identical work. That tracks with the independent estimate of ~2.2× cheaper on a blended 3:1 input/output basis.
Scaling to a month
Four such tasks a day, twenty working days — 80 agentic runs:
- GLM-5.3-Flash: ≈ $16.50/month
- MiniMax M3: ≈ $35/month
The long-context surcharge nobody mentions
Here is the trap. MiniMax M3’s pricing is tiered by input length, and once any single request exceeds 512K input tokens, the rate doubles:
| Tier | Input | Output | Cache read |
|---|---|---|---|
| ≤512K input | $0.30/M | $1.20/M | $0.06/M |
| >512K input | $0.60/M | $2.40/M | $0.12/M |
| Priority tier | 1.5× standard | 1.5× standard | 1.5× standard |
So the headline “1M context” comes with a footnote: the second half of that window costs double. If your workflow genuinely involves loading enormous repositories into context, M3 goes from 2× more expensive than GLM-5.3-Flash to roughly 4× more expensive exactly when you need the context most.
Z.ai publishes no equivalent surcharge for GLM-5.3-Flash. Its million tokens are priced flat.
Subscriptions versus pay-as-you-go
| GLM Coding Plan | MiniMax Token Plan | |
|---|---|---|
| Entry | Lite $18/mo (~80 prompts/5h, ~400/week, 100 MCP calls/mo) | Plus $20/mo (~3–4 agents) |
| Mid | Pro $72/mo (~400 prompts/5h, ~2,000/week, 1,000 MCP calls) | Max $50/mo (~4–5 agents, 3 video gens/day) |
| Top | Max $160/mo (~1,600 prompts/5h, ~8,000/week, 4,000 MCP calls) | Ultra $120/mo (~6–7 agents, 5 video gens/day) |
| Annual discount | ~30% off | Not published |
| Models included | GLM-5.3, GLM-5.3-Flash, GLM-5.2, GLM-5-Turbo | MiniMax model family |
Two details that change the maths.
GLM-5.3-Flash gets 3× quota inside the Coding Plan compared to GLM-5.3, and off-peak usage consumes 50% of standard points. Choosing Flash over the full GLM-5.3 effectively triples your subscription’s value, and shifting heavy runs outside the 14:00–18:00 UTC+8 peak window stretches it further.
MiniMax quota does not roll over. Unused allowance expires at the end of each billing cycle, and MiniMax itself recommends pay-as-you-go for production deployments rather than the Token Plan.
At my modelled usage (~$16–35/month of tokens), pay-as-you-go and the entry subscriptions are roughly break-even. Past about 6–8 hours of daily agentic work, the subscriptions win decisively — the GLM Coding Plan Lite at $18 covering ~400 weekly prompts is genuinely hard to beat.
A note on gateway pricing
You will see very different numbers depending on where you look. OpenRouter lists GLM-5.3-Flash around $0.05/M input and $0.17/M output; OpenCode’s own model data shows $0.07/M and $0.25/M. Both are below Z.ai’s official $0.15/$0.50.
That is not a contradiction. Routed gateways load-balance across 20+ third-party hosts — Baseten, DeepInfra, Novita, Cloudflare and others — and those hosts compete on price. You can absolutely get GLM-5.3-Flash cheaper than list through a gateway. You trade away consistency: throughput on OpenRouter ranges from 8 to 111 tokens/sec depending on which provider you land on, which for a long agent loop is the difference between a two-minute task and a fifteen-minute one.
For agent work, I would rather pay list price to the first party and get predictable latency. Use gateways for batch and experimentation.
Licensing and Self-Hosting: The Part European Businesses Should Read Twice
If you are running a company inside the EU, the licence is not a footnote. It is a procurement question.
GLM-5.3-Flash: MIT
Weights are on Hugging Face at zai-org/GLM-5.3-Flash under the MIT licence. That is about as permissive as software licensing gets: use it commercially, modify it, redistribute it, embed it in a product, no revenue thresholds, no acceptable-use appendix, no field-of-use restrictions. Keep the copyright notice and you are done.
For a German or EU business, MIT plus self-hostable weights means you can put the whole thing inside your own infrastructure and make data residency a non-issue — no cross-border transfer assessment, no processor agreement with a Chinese vendor, no dependency on someone else’s uptime.
MiniMax M3: MiniMax Community License
M3’s weights are also open on Hugging Face, but under the MiniMax Community License — a custom licence, not a standard permissive one. The community reception was broadly positive (it is more permissive than the licence M2.7 shipped under), and multiple sources describe commercial use as unrestricted in practice.
But “described as unrestricted” and “audited by your counsel” are different things. If MiniMax M3 is going into a commercial product, read the licence text directly before you ship. A custom licence introduces review overhead that MIT simply does not.
The self-hosting reality check
Both models are open-weight. Neither is running on your laptop.
GLM-5.3-Flash:
- FP8 checkpoint: 331 GB across 62 shards (~306 GiB of weights before KV cache)
- BF16 variant: 640 GB across 120 shards
- FP8 at TP=4 on a single GB200: ~386 GB VRAM
- BF16 at TP=8: ~772 GB VRAM
- Requires Hopper-generation or newer — H100/H200/B200/B300/GB200/GB300, or AMD MI300X/MI325X/MI355X
- Stack: vLLM 0.29.0+, FlashInfer 0.6.17+; also SGLang, TokenSpeed, KTransformers, Transformers, Unsloth
MiniMax M3:
- Roughly 214 GB at 4-bit quantisation — smaller, but still firmly server-class
Z.ai’s own hosted infrastructure reports ~48.7 output tokens/sec with a 1.52s TTFT, and at TP=4 on GB200 a 14.92M-token KV pool supporting 113.81× max concurrency at 128K context. That is the shape of hardware required to serve this properly.
Practical translation: self-hosting either model means renting or buying multiple data-centre GPUs. For most teams — including most of my clients — the right answer is the API, with the open weights functioning as insurance. If the vendor raises prices, degrades the model, or disappears, you have an exit. That optionality has real value even if you never exercise it.
Where Each Model Actually Breaks
No hype section. Here are the honest weaknesses.
GLM-5.3-Flash weaknesses
It is slow. ~48.6 tokens/sec output and ~1.51s to first token. Against M3’s ~148 tok/sec and ~0.99s, you feel every long generation. In a 40-turn agent loop that adds up to real minutes of thumb-twiddling.
You cannot turn thinking off. Mandatory reasoning is correct for hard agentic work and wasteful for trivial calls. Every “add a docstring to this function” request pays a reasoning tax. This is precisely why you want M3 or a smaller model wired in for grunt work.
Reasoning tokens are billed tokens. With reasoning_effort: max as the documented default, real-world cost per task runs above naïve estimates from input/output counts alone. Set it to high unless the task earns max.
It is new. Released 26 August 2026. Long-tail integration bugs across the harness ecosystem have not all surfaced yet, and community knowledge is still thin. If you hit an obscure failure mode, you may be the first to report it.
Do not confuse it with GLM-5.3. They are different models with different capabilities — notably, the non-Flash GLM-5.3 is text-only. Sending images to the wrong model ID is a common early mistake.
MiniMax M3 weaknesses
The tool-use ranking is the real problem. #42 on llm-stats’ tool-use index, against GLM-5.3-Flash at #4. For an agent harness that is the load-bearing capability. Expect more malformed tool calls, more retries, more turns burned recovering — which eats the speed advantage you paid for.
The context-reporting bug is unresolved. Open since release. Workable around, but it is a papercut you carry.
Independent verification is thin. MiniMax’s launch benchmarks had not appeared on neutral boards, and where neutral aggregators have measured, M3 lands mid-table rather than near the top. The gap between vendor framing and third-party measurement is wider here than it is for Z.ai.
Long-context pricing doubles above 512K. The headline feature has a surcharge attached to it.
Custom licence. Extra legal review before commercial deployment.
Declining usage. A 51% drop in OpenCode token volume over two months is a signal about ecosystem momentum, whatever the cause. Fewer users means fewer people hitting and fixing the same bugs you will hit.
The Decision Framework: Five Scenarios
1. “I want one model, set it, forget it.”
GLM-5.3-Flash. Better on every neutral benchmark, half the price, MIT-licensed, and where the community has landed. Set reasoning_effort: high, add the GLM Coding Plan Lite at $18/month if you code daily, and move on with your life.
2. “I run huge, mechanical refactors across enormous codebases.”
MiniMax M3 for the mechanical passes, GLM-5.3-Flash for the plan. MSA makes M3 genuinely economical at long context, and 3× the generation speed is felt most on high-volume, low-difficulty edits. Just watch the 512K pricing cliff, and let GLM plan the refactor before M3 executes it.
3. “My work is visual — UI, design-to-code, screenshot debugging.”
GLM-5.3-Flash first, M3 as a strong second. GLM’s native multimodality is designed for exactly this and it outranks M3 on the vision index (32.0 vs 25.6). But M3’s OSWorld-Verified score of 70.06% makes it the better choice specifically for desktop and GUI agent work — driving actual applications rather than reading screenshots.
4. “I need to self-host for data residency or compliance.”
GLM-5.3-Flash, unambiguously. MIT versus a custom community licence is not a close call when your legal team is involved, and MIT self-hosting takes the entire cross-border data transfer question off the table. Budget for Hopper-class hardware or a European GPU host.
5. “I’m running a small team on a tight budget.”
GLM Coding Plan Lite at $18/month, defaulting to GLM-5.3-Flash. The 3× quota multiplier for Flash inside the plan makes it the highest value-per-euro option available right now. Schedule heavy batch runs outside the 14:00–18:00 UTC+8 peak window for the 50% points discount. Add MiniMax later if throughput becomes the bottleneck.
What I Would Watch Over The Next Quarter
Independent Terminal-Bench and SWE-bench Pro runs for GLM-5.3-Flash. The vendor numbers are excellent. Neutral aggregators broadly corroborate them. But the specific claim of “within a point of Claude Opus 4.8 on Terminal-Bench 2.1” deserves third-party replication before anyone builds a business case on it.
Whether the MiniMax /anthropic context bug gets fixed. It is small, it is documented, and it has been open since June. How quickly it closes tells you something about maintenance velocity.
GLM-5.3-Flash’s retention curve in OpenCode. The token-share number is spectacular but young. The interesting datapoint is whether it holds at 10%+ once the novelty fades. If it does, this is not a moment — it is a new default.
Release cadence from the Chinese open-weight labs. Qwen3.8-Flash-Next launched more or less alongside GLM-5.3-Flash. Kimi K3 already beats GLM-5.3 on DeepSWE (67.5 vs 66.9) and Toolathlon (76.5 vs 73.0). The gap between “current best open-weight coding model” and “second best” is now measured in weeks. Build your config so swapping the model string is a one-line change, because you will be making that change again.
Whether Z.ai publishes flat standalone API pricing for the full GLM-5.3. As of writing, the per-token row for GLM-5.3 was still missing from the official pricing page while GLM-5.3-Flash was fully priced. That is a strange asymmetry and worth watching.
Frequently Asked Questions
Is GLM-5.3-Flash better than MiniMax M3 for coding? On the evidence available, yes. GLM-5.3-Flash leads on Terminal-Bench 2.1 (84.3 vs 66.0), on Artificial Analysis’ Intelligence Index (57 vs 45), and on every llm-stats capability index including coding, agents and tool use. It is also roughly half the price per token. MiniMax M3 is faster — about 3× output speed — but agentic coding rewards reasoning quality more than raw generation speed.
Which is cheaper, GLM-5.3-Flash or MiniMax M3? GLM-5.3-Flash, by roughly 2×. Official pricing is $0.15/M input and $0.50/M output for GLM-5.3-Flash, versus $0.30/M and $1.20/M for MiniMax M3. The gap widens to about 4× for requests above 512K input tokens, where MiniMax doubles its rates and Z.ai publishes no surcharge.
Can I run GLM-5.3-Flash locally? Only on server-class hardware. The FP8 checkpoint is 331 GB and needs roughly 386 GB of VRAM at TP=4, on Hopper-generation GPUs or newer. It is not a consumer-hardware model. The MIT licence makes self-hosting legally straightforward; the hardware makes it expensive.
Does OpenCode support both models natively? Yes. OpenCode ships built-in providers for both Z.AI and MiniMax. Run opencode auth login, select the provider matching your key type, then /models to pick your model. No opencode.json editing required for a standard setup.
Why does MiniMax M3 show only 200K context in Claude Code? A known, still-open bug in MiniMax’s Anthropic-compatible endpoint: it reports Claude Sonnet’s metadata rather than M3’s real specification, triggering auto-compaction at around 167K tokens. Set CLAUDE_CODE_AUTO_COMPACT_WINDOW to 1000000 in your settings, or use the OpenAI-compatible route instead.
What’s the difference between GLM-5.3 and GLM-5.3-Flash? Different models. GLM-5.3 launched 14 August 2026 and is text-only, sharing its base model with GLM-5.2. GLM-5.3-Flash launched 26 August, is natively multimodal, uses a 320B/18B hybrid-attention MoE architecture, is MIT-licensed with open weights, and costs roughly a tenth as much. Inside the GLM Coding Plan, Flash also gets 3× the quota.
Is MiniMax M3 truly open source? The weights are openly downloadable from Hugging Face, but under the custom MiniMax Community License rather than a standard permissive licence like MIT or Apache 2.0. Commercial use is widely described as unrestricted, but read the licence text before shipping a commercial product on it.
Should I use the subscription plans or pay-as-you-go? Below roughly $20–30/month of token spend, they are close to break-even. Above 6–8 hours of daily agentic coding, subscriptions win clearly — the GLM Coding Plan Lite at $18/month covering around 400 weekly prompts is the strongest entry-level value available. Note that MiniMax quota does not roll over, and MiniMax itself recommends pay-as-you-go for production workloads.
The Bottom Line
If you take one thing from this: GLM-5.3-Flash is the better default for OpenCode in late 2026, and the case is not close on the dimensions that decide agentic coding outcomes — reasoning quality, tool-use reliability, and cost per completed task.
MiniMax M3 is not a bad model. It is a differently-optimised one, and its MSA architecture is a genuinely elegant answer to the long-context economics problem. There are real workloads — high-volume mechanical edits, desktop and GUI agent tasks, anything where 3× generation speed dominates — where it is the correct tool.
But agentic coding is fundamentally a decision-making problem, not a typing-speed problem. The model that plans better, calls tools more reliably, and recovers from failure more gracefully will finish more tasks per euro, even when it generates tokens three times slower.
The pragmatic play is the two-speed gearbox: GLM-5.3-Flash on planning and building, MiniMax M3 on the grunt work, small_model pointed at the fast one. OpenCode makes that a fifteen-line config change, and it gets you the intelligence where it matters and the throughput where it does not.
And write that config so the model IDs are easy to swap. In this market, today’s obvious answer has a shelf life measured in weeks.
Have you run either of these as your OpenCode daily driver? I’m particularly interested in whether GLM-5.3-Flash’s Terminal-Bench numbers hold up in real repositories, and whether anyone has found a cleaner workaround for MiniMax’s context-reporting bug. Get in touch — corrections and counter-evidence welcome, and this article gets updated when the picture changes.
Last updated: 30 August 2026.
