GLM-5.2 vs Kimi K3: Which Model Should You Choose?

Independent research — not an official Z.ai publication.Identity and provider disclosure

Model Research & Evaluation Editor

Editorial responsibility: GLM52.ai Editorial TeamPublished July 17, 2026 · Editorially reviewed July 20, 2026

How we research and review Report a correction

Disclosed editorial pen name · AI-generated portrait

GLM-5.2 versus Kimi K3 decision chart: both offer a one-million-token context; GLM-5.2 has lower API prices and downloadable MIT weights, while Kimi K3 adds native vision and leads Moonshot's comparison table

Moonshot launched Kimi K3 on July 16, 2026, one day before this review. Product details can change during launch week. We checked each specification and price against first-party pages on July 17.

The useful version of GLM-5.2 vs Kimi K3 asks one question: which model fits your work? A broad “which model is smarter?” verdict hides cost, input type, agent shell, test coverage, deployment needs, and failure risk.

This review separates four forms of evidence:

product facts from Z.ai and Moonshot documentation;
publisher scores from Moonshot’s Kimi K3 launch table;
arithmetic that you can replace with your token counts;
selection guidance that follows from those facts.

We did not run an independent model benchmark. We do not present a vendor chart as our own test.

Quick verdict

Kimi K3 holds the stronger launch-week capability case. Moonshot’s table gives K3 a lead over GLM-5.2 on every row where both models have a score. K3 accepts images and video, while the base GLM-5.2 API accepts text. Those two facts make K3 the stronger first test for visual frontend work, game creation, document analysis, and hard agent tasks.

GLM-5.2 holds the stronger cost and control case. Z.ai charges $1.40 per million fresh input tokens and $4.40 per million output tokens. Moonshot charges $3 and $15. Z.ai hosts the 753B GLM-5.2 checkpoint under the MIT license now. Moonshot says K3’s 2.8T weights will arrive by July 27.

The result has no universal winner. K3 gives you a higher capability hypothesis. GLM-5.2 gives you a lower-cost production hypothesis. Your acceptance tests decide which hypothesis survives.

Use this starting rule:

choose Kimi K3 when the task needs pixels, long autonomy, broad judgment, or costly-error control;
choose GLM-5.2 when tests can catch mistakes and volume, token cost, or deployment control drives the choice;
use a clean second session when you route a failed GLM task to K3. Kimi warns against a model switch inside an active K3 conversation.

Specifications at a glance

Decision factor	GLM-5.2	Kimi K3	What it means
Publisher	Z.ai	Moonshot AI	Separate APIs, policies, regions, and support paths
Release date	June 16, 2026	July 16, 2026	K3 has one month of release recency
Direct API model ID	`glm-5.2`	`kimi-k3`	Both support OpenAI-style chat calls, with model-specific rules
Input	Text	Text, image, video	K3 can inspect pixels inside the base model call
Output	Text	Text	Both models return text and tool calls
Context window	1,048,576 tokens	1,048,576 tokens	Capacity matches; recall and agent stability need task tests
Completion limit	131,072 tokens	Up to 1,048,576 within the context budget	A larger limit raises cost and review load
Standard API input	$1.40 / MTok	$3.00 / MTok	K3 costs 2.14× the GLM fresh-input rate
Cached input	$0.26 / MTok	$0.30 / MTok	The cache-hit rates sit close; cache rules matter
Standard API output	$4.40 / MTok	$15.00 / MTok	K3 costs 3.41× the GLM output rate
Model scale	753B parameters	2.8T parameters	Size affects infrastructure; it does not measure task quality
Weights on July 17	Downloadable, MIT	Moonshot promises release by July 27	GLM offers a self-host path now
Thinking control	On or off; effort choices	Required; `max` at launch	GLM gives apps more latency and behavior control
Best first test	Volume, text, control	Hard agents, vision, knowledge work	Match the model to the failure cost

The API limits above describe the direct provider endpoints. A gateway, coding plan, app, or hosted inference service can expose another context limit, rate, feature set, or price.

What changed with Kimi K3

Moonshot built Kimi K3 around three changes that alter this comparison.

First, K3 combines a 2.8-trillion-parameter mixture-of-experts model with Kimi Delta Attention and Attention Residuals. The model routes each token through 16 of 896 experts. Moonshot says this design gives K3 2.5× the scaling efficiency of Kimi K2. Treat that ratio as a publisher claim, not an independent measurement.

Second, K3 adds native visual understanding. Its API accepts image and video content. A coding agent can inspect a screenshot, change the page, view the result, and repeat the loop. GLM-5.2 needs a separate vision tool or model for that job.

Third, K3 targets long-horizon action. Moonshot shows code, research, presentation, spreadsheet, game, CAD, and chip-design cases. These cases prove that Moonshot built complete demonstrations. They do not prove that your next ticket will finish with the same quality, time, or supervision.

The launch state needs one clear correction: K3 does not offer downloadable weights as of July 17. Moonshot calls K3 an open model and promises the full weights by July 27. Until the files and license arrive, buyers can use the API and Kimi products, but they cannot audit or host the promised checkpoint.

What the benchmark table shows

Moonshot’s launch table gives both models a score on 19 rows across coding, agents, office work, and reasoning. K3 leads all 19 rows. That pattern supports a strong K3 hypothesis. The table does not support a claim that K3 wins every real task.

The rows below show the most useful spread. “Gap” means score points, not a percent gain.

Benchmark	Kimi K3	GLM-5.2	Reported gap	Main caution
DeepSWE	67.5	46.2	K3 +21.3	Moonshot uses KimiCode for K3; GLM score comes from the GLM release
Program Bench	77.8	63.7	K3 +14.1	The models use different agent shells
Terminal-Bench 2.1	88.3	82.7	K3 +5.6	The table selects strong reported harnesses
FrontierSWE	81.2	67.3	K3 +13.9	Scores reflect the July 16 leaderboard and distinct stacks
SWE-Marathon	42.0	13.0	K3 +29.0	Long runs magnify harness and retry effects
PostTrain Bench	36.6	34.3	K3 +2.3	The gap is small beside run variance risk
MCP Atlas	84.2	82.6	K3 +1.6	Moonshot states one public set, turn limit, and judge for all models
Automation Bench	30.8	12.9	K3 +17.9	Scores remain low enough to demand supervision
GPQA-Diamond	93.5	91.2	K3 +2.3	A knowledge score does not stand in for code-agent reliability

Three conclusions hold.

K3 deserves the first test for hard work. The lead covers many task types, not one favorable row.
The biggest coding gaps appear on long or broad tasks. SWE-Marathon, DeepSWE, and FrontierSWE support K3’s long-horizon position.
Close rows matter. MCP Atlas, PostTrain Bench, and GPQA show small gaps. Price, speed, control, and error cost can outweigh those gaps.

A score does not equal your pass rate

A Terminal-Bench score of 88.3 does not give your next shell task an 88.3% success chance. Each benchmark supplies its own tasks, tools, timeouts, graders, context rules, and security limits. Your repository adds another language mix, test suite, dependency graph, and review standard.

Use public scores to select candidates. Use accepted work to select a default.

Why the test harness matters

An agent result comes from more than a model:

accepted result = model + prompt + agent shell + tools + permissions
                + context policy + effort + retries + time + grader

Moonshot’s table mixes KimiCode, Claude Code, Codex, benchmark-owned systems, and cited results. The footnotes disclose much of that mix, which helps readers judge the chart. The mix blocks a clean claim that each gap comes from model weights alone.

The MCP Atlas row offers a stronger comparison signal because Moonshot says all models use the 500-task public set, a 100-turn limit, and Gemini 3.1 Pro as judge. K3 scores 84.2 and GLM-5.2 scores 82.6. The small gap says “test both,” not “ignore cost.”

For a clean internal test, hold files, tools, permissions, stop rules, and graders constant. Let each model use provider-supported settings. Do not force a K3-specific field into GLM or a GLM thinking object into K3 and call the result fair.

API pricing and task cost

The direct API list prices create a clear GLM advantage.

Token type	GLM-5.2	Kimi K3	K3-to-GLM rate ratio
Fresh input / MTok	$1.40	$3.00	2.14×
Cached input / MTok	$0.26	$0.30	1.15×
Output / MTok	$4.40	$15.00	3.41×

For a task with 100,000 fresh input tokens and 10,000 output tokens:

GLM-5.2 = 0.10 × $1.40 + 0.01 × $4.40 = $0.184
Kimi K3 = 0.10 × $3.00 + 0.01 × $15.00 = $0.450

K3 costs 2.45× more for that request shape.

If the provider treats all 100,000 input tokens as cache hits:

GLM-5.2 = 0.10 × $0.26 + 0.01 × $4.40 = $0.070
Kimi K3 = 0.10 × $0.30 + 0.01 × $15.00 = $0.180

Output keeps the total gap wide. Moonshot says its API sees a cache-hit rate above 90% in coding workloads. That figure describes Moonshot’s traffic; it does not promise the same rate for your prompt order and file churn.

One clean K3 run can cost less than three GLM runs

Token price does not equal task price. In the fresh-input example, three GLM attempts cost $0.552. One K3 attempt costs $0.450. K3 wins the bill if it finishes once while GLM needs three equal-size runs.

Use this measure:

cost per accepted result = model spend + tool spend + review and repair cost
                           -----------------------------------------------
                                      accepted outputs

K3 needs a real success-rate gain to earn its premium. GLM wins when both models pass the same check with similar supervision.

One-million-token context

Both providers advertise 1,048,576 tokens. The shared capacity removes one easy tie-breaker. It does not establish equal recall, latency, tokenization, or stability across a million-token prompt.

GLM-5.2 caps output at 131,072 tokens. Kimi’s API accepts max_completion_tokens up to 1,048,576, subject to the total context budget. A huge completion can produce a large bill, a long wait, and an artifact that no person can review in one pass. Treat the number as a ceiling, not a target.

Test long context with questions that require evidence from the start, middle, and end of the prompt. Add conflicting names and stale files. Ask the model to cite file paths and line numbers. Then test whether it preserves constraints after tool errors and context compaction.

A curated 100K-token working set can beat a 1M-token repository dump. Give the agent architecture notes, contracts, relevant code, tests, and repository rules first. Add files when the task needs them.

Vision, tools, and reasoning controls

K3 and GLM-5.2 expose different control surfaces.

API behavior	GLM-5.2	Kimi K3	Decision impact
Native vision	No; base endpoint uses text	Images and video	K3 fits screenshot and document loops
Thinking mode	App can enable or disable it	Required	GLM can serve short tasks with less reasoning
Effort	Multiple levels	`max` at launch	K3 lacks a low-cost effort level at launch
Sampling	API examples expose temperature	Temperature and top-p stay fixed	A migrated app must remove unsupported controls
Function tools	Yes	Yes	Tool presence does not prove equal tool choice
Tool choice	Function calling and MCP	Required choice and dynamic tool loading	K3 can load tools as the task changes
Structured output	Yes	Strict JSON Schema	Both fit typed application output
Context cache	Yes	Automatic cache lookup	Stable prefixes help both models
Partial response prefix	No matching feature on the checked guide	Supported	K3 can continue from an assistant prefix

K3 vision has launch constraints. The API does not accept a public image URL. Send base64 data or a Moonshot file ID. Video uses the file path flow. K3’s official web-search tool carries an update warning, so Moonshot does not recommend it for near-term production use.

GLM-5.2 gives teams more control over thinking and sampling. K3 gives teams a richer multimodal and tool-loading surface. Choose the surface your application can use, not the longer feature list.

Open weights and self-hosting

GLM-5.2 wins the immediate open-weight comparison. Z.ai publishes the 753,329,940,480-parameter checkpoint on Hugging Face under MIT. The files remain huge: our GLM-5.2 local hardware guide measures about 1.5 TB for BF16 and about 756 GB for the official FP8 set before runtime overhead.

Moonshot reports 2.8 trillion parameters for K3. It plans to release full weights by July 27. Moonshot recommends a supernode with 64 or more accelerators for deployment. That guidance places K3 far outside a workstation setup.

Do not translate “open model” into “easy local model.” Ask four separate questions:

Can you download the exact weights and license?
Can your inference stack load the architecture and quantization format?
Can your hardware hold weights, cache, buffers, and concurrent requests?
Can your team operate the service at a useful speed and uptime?

GLM answers the first question now. K3 does not answer it until Moonshot ships the files and terms. Both models pose a major infrastructure project.

Limits that can break an agent run

Moonshot publishes two K3 limits that deserve a place near the verdict.

K3 needs its full thinking history

K3 expects an agent to return the complete assistant message in later turns, including thinking content. Moonshot warns that a missing history or a mid-session switch from another model can make output quality unstable. Start K3 with a clean session. Keep the returned message intact. Test your agent shell before a production rollout.

K3 can take too much initiative

Moonshot says K3 may make choices for the user when it meets a small issue or unclear intent. Strong autonomy helps open work, but it raises risk in deployment, finance, data deletion, and permission changes. Put boundaries in the system prompt or AGENTS.md. Require approval for costly or destructive actions.

GLM has another limit: the base model cannot inspect an image. A text extraction tool can bridge some documents, but it cannot replace pixel-level feedback for a frontend or CAD loop. GLM’s open weights demand heavy infrastructure.

Both vendors publish their own benchmark stories. Neither story supplies your service latency, regional capacity, uptime, privacy terms, or support quality. Run an API pilot in the region and account tier you plan to buy.

Launch demand can constrain one purchase layer without taking the direct API offline. Our GLM-5.2 vs Kimi K3 API availability guide separates Moonshot’s new-subscription pause from public API status, vendor error signals, account quota, and tested fallback capacity.

Alibaba’s new preview creates another access question: qwen3.8-max-preview is testable in Token Plan but its plan forbids application backends. Our GLM-5.2 vs Qwen3.8 comparison separates interactive preview access from production API readiness, public pricing, vision, and open weights.

Which model should you choose?

Choose Kimi K3 for hard, visual, high-value work

Start with K3 for screenshot-driven frontend repair, game or CAD iteration, image-heavy document analysis, deep research, broad repository change, and long tasks where a failed run costs more than the token premium.

K3 fits cases where an agent must select from a large tool catalog. Dynamic tool loading can keep irrelevant definitions out of the first prompt.

Choose GLM-5.2 for volume, text, and control

Start with GLM for test-driven code fixes, repository audits, batch transformations, scheduled text agents, and workloads with a clear machine grader. Its lower output rate matters when reasoning traces and tool loops produce many tokens.

Choose GLM when you need downloadable weights now, an MIT license, more provider choice, or thinking controls that match short and long tasks.

Use a two-model route when task difficulty changes

Send bounded, testable work to GLM. Escalate a failed or visual task to K3. Pass a clean brief, selected files, test results, and failure notes into a new K3 session. Do not move the raw GLM conversation into K3.

This route creates a practical split:

GLM handles low-cost exploration and repeatable execution;
K3 handles visual inspection, hard recovery, and high-risk judgment;
your acceptance suite decides when the route ends.

How to test both models

Run a small test before you move production traffic.

Pick five tasks with a finish line

Use real work: one bug fix, one cross-file feature, one tool failure, one long-context question, and one visual task if your product needs vision. GLM cannot enter the native-vision row, so record that as a product mismatch rather than a failed intelligence test.

Give each task pass conditions. Examples include passing tests, an unchanged API contract, a cited source count, a pixel-diff threshold, or a valid JSON schema.

Hold the workspace constant

Give both models the same repository snapshot, permissions, tools, time limit, and spending cap. Record each model’s supported effort and sampling fields. Start a new session for each run.

Score accepted work

Track these fields:

Measure	Why it matters
Pass or fail	Keeps the test tied to the task
Human corrections	Captures supervision cost
Tool errors	Exposes agent-shell fit
Input, cache, and output tokens	Produces an auditable API bill
Wall time	Captures user wait and queue effects
Out-of-scope changes	Measures control risk
Cost per accepted result	Joins quality and price

Choose the default that produces accepted work at the lower total cost. Keep the other model as a route for tasks that need its distinct strength.

Common questions

Is Kimi K3 better than GLM-5.2?

Kimi K3 leads all 19 shared rows in Moonshot’s launch table and adds native image and video input. That makes K3 the stronger capability hypothesis. GLM-5.2 costs less, offers downloadable MIT weights, and gives apps more thinking control. Your workload can reverse the practical verdict.

Which model costs less?

GLM-5.2 costs less at direct provider list rates. Z.ai charges $1.40 for fresh input and $4.40 for output per million tokens. Moonshot charges $3 and $15. For 100K fresh input and 10K output, GLM costs $0.184 and K3 costs $0.450.

Do both models have a 1M context window?

Yes. Both direct API guides list 1,048,576 tokens. The number describes capacity, not equal recall, speed, or agent stability. A third-party endpoint can impose another limit.

Can I run Kimi K3 or GLM-5.2 on local hardware?

Z.ai hosts the 753B GLM-5.2 weights under MIT now, but the checkpoint needs server-class hardware. Moonshot says K3 has 2.8T parameters and recommends 64 or more accelerators. It promises K3 weights by July 27, 2026. Neither model fits a normal laptop deployment.

Which model should a coding agent use?

Use K3 for hard, long, or visual coding work. Use GLM for high-volume text work with strong tests and cost limits. Run both in the agent shell you plan to deploy because the shell can change the result.

Can an app switch from GLM-5.2 to Kimi K3 inside one conversation?

Avoid that design. Moonshot says K3 depends on preserved thinking history and warns that a mid-session model switch can destabilize output. Start a new K3 session with a clean task brief, relevant files, and failure evidence.

Sources and method

Primary sources checked July 17, 2026:

Kimi K3 technical blog — launch claims, benchmark table, architecture, availability, weight schedule, deployment guidance, and limitations.
Kimi K3 API guide — context, vision, tools, output limits, reasoning controls, cache behavior, and request rules.
Kimi K3 API pricing — cache-hit, cache-miss, and output rates.
GLM-5.2 model guide — context, modalities, tools, output limit, and thinking controls.
Z.ai API pricing — GLM-5.2 input, cached-input, and output rates.
GLM-5.2 official model card — parameter count, MIT license, architecture notes, deployment support, and publisher benchmarks.
Z.ai release notes — GLM-5.2 release date.

We searched the exact comparison query and close variants on July 17, reviewed the leading comparison pages, and checked each decision-changing claim against a first-party page. The benchmark section selects rows from Moonshot’s launch table and keeps its harness cautions. The cost examples use provider list prices and visible arithmetic. Model recommendations remain inferences, not measured universal results.

Kimi K3 launched one day before this review. Recheck its weight release, license, API limits, effort levels, and prices after July 27. We will update this page when first-party facts change.