GLM 5.2 vs Kimi K3: Which Million-Token Open Model Wins?
Two of 2026's biggest open-weight releases both ship roughly 1-million-token context windows. Here is how they actually differ on price, limits, and verified performance.
GLM 5.2 and Kimi K3 are the two most prominent million-token-context open-weight models to ship in 2026 — GLM 5.2 from Zhipu AI (Z.AI) on June 16, and Kimi K3 from Moonshot AI in July. Both are MIT-style open-weight, both target long-horizon coding and agentic work, and both undercut closed frontier APIs on price.
They are not the same model wearing different branding, though. GLM 5.2 is roughly 744 billion total parameters with an officially documented 128K output cap and more independent benchmark corroboration; Kimi K3 is a much larger 2.8 trillion parameters with more aggressive launch pricing on cached input but a thinner independent verification record so far.
This guide compares the two head-to-head on pricing, context and rate limits, and verified benchmark performance, so you can pick based on your actual workload rather than which one launched more recently.
Layer3 does not resell either model. This comparison is based on each vendor's own published documentation plus independent benchmark sources — see our full GLM 5.2 review and Kimi K3 review for the deeper honest verdict on each.
GLM 5.2 (Zhipu AI / Z.AI) vs. Kimi K3 (Moonshot AI): Side-by-Side
| Dimension | GLM 5.2 (Zhipu AI / Z.AI) | Kimi K3 (Moonshot AI) |
|---|---|---|
| Vendor / origin | Zhipu AI (Z.AI), China | Moonshot AI, China |
| License | MIT, open weights, self-hostable | Open weights; license terms were not finalized at launch — confirm before commercial use |
| Parameters | ~744B total (reports vary 743B–753B), ~40B active per token (MoE) | 2.8T total (Moonshot-reported, likely MoE) |
| Context window | 1,000,000 tokens (Z.AI-documented, via IndexShare sparse attention) | ~1,000,000 tokens (Moonshot-reported) |
| Max output tokens | 128,000 tokens (Z.AI-documented) | Not publicly documented at time of writing |
| API pricing (per million tokens) | $1.40 input / $0.26 cached input / $4.40 output | ~$0.30 cache-hit / $3 cache-miss input / $15 output |
| Rate limits | Not officially documented by tier; real-world reports of severe rate-limiting incidents | Not officially documented by tier |
| Self-host hardware | ~8x H200 GPUs (~$300K), practical at 1B+ tokens/month | Larger cluster needed given 2.8T parameters — no official minimum published |
| Verified benchmark result | #1 on Design Arena Code Categories (independent, blind human-preference), ~10 Elo ahead of Claude Fable 5 | #1 on LMArena Frontend Code Arena at launch (independent, blind human-preference), 1,679 points |
| Vendor-reported benchmarks | SWE-bench Pro 62.1, Terminal-Bench 2.1: 81.0, FrontierSWE 74.4 (vs Opus 4.8's 75.1) | Terminal-Bench 2.1: 88.3 (self-reported, not independently reproduced) |
| Best for | High-volume coding with heavy repeat/cached context; teams that want the more independently-corroborated benchmark record | Teams that want the largest raw parameter count and the cheapest cache-hit input rate; open to a less-verified capability record at launch |
Quick verdict
For most coding-focused teams, GLM 5.2 is the safer starting point: its 128K output cap is officially documented (Kimi K3's is not), its benchmark claims have more independent corroboration (Design Arena, Artificial Analysis, Scale AI, BenchLM all weigh in), and its cached-input pricing at $0.26/million tokens rewards workflows that repeatedly re-send the same large codebase or document.
Kimi K3 wins on raw scale (2.8T parameters vs GLM 5.2's ~744B) and on cache-hit input pricing (~$0.30/million vs GLM 5.2's $1.40 uncached), and its one independent result — a #1 finish on LMArena's Frontend Code Arena — is a genuine signal specifically for front-end code generation.
Neither vendor publishes official per-tier API rate limits, and both hosted APIs carry data-residency caveats for regulated US buyers. Self-hosting removes the rate-limit question for either model but requires serious GPU investment either way — more so for Kimi K3 given its larger parameter count.
Deciding between GLM 5.2 and Kimi K3 for your own coding pipeline? We test both against your actual codebase and recommend based on real results, not a leaderboard.
Book a ConsultationPricing: GLM 5.2 vs Kimi K3
GLM 5.2's official API pricing is $1.40 per million input tokens, $0.26 per million cached input tokens, and $4.40 per million output tokens. Kimi K3's launch pricing is roughly $0.30 per million input tokens on a cache hit, $3 per million on a cache miss, and $15 per million output tokens.
The two models split on where they are cheaper. Kimi K3 is far cheaper on cache-hit input ($0.30 vs GLM 5.2's $1.40 uncached — though GLM 5.2's own cached rate of $0.26 actually undercuts Kimi K3's cache-hit rate slightly). GLM 5.2 is meaningfully cheaper on output tokens ($4.40 vs $15 per million) — a significant difference for any workflow that generates a lot of code rather than just reading it.
For a workload that generates substantial output — most agentic coding use cases — GLM 5.2's output pricing advantage likely outweighs Kimi K3's edge on cache-miss input pricing. Model your own input/output token ratio before assuming either vendor is cheaper in the aggregate.
Context Window and Rate Limits
Both models ship roughly 1-million-token context windows — GLM 5.2's is officially documented by Z.AI at exactly 1,000,000 tokens with a 128,000-token output cap; Kimi K3's ~1M-token figure and output cap are Moonshot-reported without the same level of documented precision.
Neither Z.AI nor Moonshot publishes an official, tier-by-tier rate-limit table for their hosted API. GLM 5.2's hosted API has documented real-world reliability problems, including a GitHub issue describing a multi-day near-outage from rate limiting. Kimi K3's hosted API has no equivalent publicly documented incident at the time of writing, though it is also new enough that less real-world load history exists.
Verified Benchmarks: Design Arena vs LMArena
Each model's strongest evidence comes from a different independent human-preference leaderboard. GLM 5.2 ranks #1 on Design Arena's Code Categories, roughly 10 Elo ahead of Claude Fable 5 — a broad coding-category result. Kimi K3 ranks #1 on LMArena's Frontend Code Arena at launch, scoring 1,679 points — a narrower result specific to front-end code generation.
GLM 5.2 has a wider corroboration base beyond that single result: independent groups including Artificial Analysis, Scale AI, and BenchLM have each published their own reads on its coding performance. Kimi K3's other headline figures — including a self-reported 88.3 on Terminal-Bench 2.1 — are Moonshot's own numbers, not yet independently reproduced.
When GLM 5.2 wins
GLM 5.2 is the better fit in several common scenarios.
- Your workload generates a lot of output tokens (agentic coding, code generation) — GLM 5.2's output pricing is a third of Kimi K3's
- You want a documented, precise output-token cap (128K) rather than an undocumented one
- You want the model with the broader independent benchmark corroboration today
- Your codebase gets re-sent repeatedly across a session — GLM 5.2's $0.26/million cached rate rewards that pattern
When Kimi K3 wins
Kimi K3 is the better fit in a few specific cases.
- You want the largest raw parameter count currently available in an open-weight model (2.8T)
- Your workload is input-heavy with a high cache-hit rate — Kimi K3's $0.30/million cache-hit rate is hard to beat
- Your work is specifically front-end code generation, where Kimi K3 has an independent #1 result
- You are comfortable with a less-verified capability record in exchange for the largest model on the market
Compliance and data-sovereignty considerations
Both GLM 5.2 and Kimi K3 are built by Chinese labs, so the same data-sovereignty review applies to either one for regulated US buyers.
- Neither vendor offers a HIPAA BAA on the hosted API for US customers
- Self-hosting either model on US infrastructure removes the data-residency question, at real hardware cost
- Kimi K3's open-weights license was not finalized at launch — confirm current terms before commercial use
- GLM 5.2 ships under a clear MIT license — commercial use and self-hosting are unambiguous
The Verdict
Best overall for most coding teams: GLM 5.2, on the strength of its documented output cap, cheaper output pricing, and broader independent benchmark corroboration.
Best for input-heavy, cache-hit-dominant workflows or teams that want the largest available open-weight model: Kimi K3, provided you can tolerate its thinner independent verification record and unfinalized launch license.
Best for front-end code generation specifically: Kimi K3, on the strength of its LMArena Frontend Code Arena win.
Either way, neither vendor publishes reliable official rate limits — pilot at your real load before committing a mission-critical workflow to either hosted API.
Researched from primary vendor documentation and public regulator sources. Pricing and availability are accurate as of Jul 30, 2026 and can change — confirm current terms with each vendor before you buy.
Frequently Asked Questions
- For most coding workloads, GLM 5.2 is the safer pick — it has a documented 128K output cap, cheaper output-token pricing, and broader independent benchmark corroboration (Design Arena, Artificial Analysis, Scale AI, BenchLM). Kimi K3 wins on raw parameter count (2.8T vs ~744B) and cache-hit input pricing, but has a thinner independent verification record and an unfinalized launch license.
- It depends on your input/output ratio. Kimi K3 is cheaper on cache-hit input ($0.30 vs GLM 5.2's $1.40 uncached, though GLM 5.2's own $0.26 cached rate is actually lower). GLM 5.2 is significantly cheaper on output tokens ($4.40 vs $15 per million) — a bigger factor for most agentic coding workloads that generate a lot of code.
- They are in the same class — both are roughly 1-million-token context windows. GLM 5.2's figure and its 128,000-token output cap are officially documented by Z.AI; Kimi K3's ~1M-token figure is Moonshot-reported without the same documented precision, and Moonshot has not published a fixed max-output figure.
- GLM 5.2 has the broader independent corroboration — a #1 finish on Design Arena's Code Categories plus independent reads from Artificial Analysis, Scale AI, and BenchLM. Kimi K3's strongest independent result is a #1 finish on LMArena's Frontend Code Arena, a narrower, front-end-specific test.
- Both are built by Chinese AI labs (Zhipu AI and Moonshot AI respectively), and neither offers a HIPAA BAA on its hosted API. Self-hosting either model on US infrastructure is the workaround for regulated data, at real hardware cost. GLM 5.2's MIT license is unambiguous for commercial self-hosting; Kimi K3's open-weights license terms were not finalized at launch — confirm before committing.
Need Help Choosing Between GLM 5.2 and Kimi K3?
Layer3 does not resell GLM 5.2 or Kimi K3. Tell us your workload — input/output token ratio, coding task type, and compliance requirements — and we'll give you an unbiased recommendation, or a plan to pilot both against your actual codebase.
Book a Consultation