Running agent skills and subagents on GLM-5.3-Flash: cost per run and where it breaks

A skill is a small contract: a SKILL.md, a handful of tools, and a loop that runs until a checker says stop. When you run dozens of those loops a day, or let a parent agent spawn five subagents per task, the model behind them stops being a quality question and becomes a unit-cost question. GLM-5.3-Flash is Z.ai's answer to that second question. It lists at $0.15 per million input tokens, $0.03 per million cached input tokens and $0.50 per million output tokens, against $1.40, $0.26 and $4.40 for GLM-5.3.

This guide is written for people who build and operate skills, not for people comparing leaderboards. It answers four practical questions. What does one skill run cost on Flash at list price? Where does the per-token discount shrink once reasoning tokens are counted? Which parts of Z.ai's tool-calling documentation constrain how you write a skill? And which skills should you route to Flash, keep on GLM-5.3, or send somewhere else entirely? Every benchmark figure quoted here is Z.ai-reported, and the cost tables are our own arithmetic on published prices with invented usage shapes. We ran no live skills against the model.

What Flash is, from a skill author's seat

Flash is the model that ran anonymously on OpenRouter and the OpenCode agent as the stealth model Ox Alpha from August 20, 2026, and Z.ai launched it under its own name on August 26. Z.ai's launch post calls it natively multimodal, with a 1M-token context window and a 320B-A18B design (320B total parameters, 18B active), released under the MIT license. Z.ai says the stealth period drew the most traffic of any model on OpenRouter that week.

For a skill author, four properties matter more than the architecture.

It is a different model, not a shrunken GLM-5.3. GLM-5.3 reuses the GLM-5.2 base and is text only. Flash has a newly trained base and accepts text, images, video and files. A skill that reads screenshots, PDFs or screen recordings can only do that natively on Flash, not on GLM-5.3.

Thinking is always on. Both models reject a request that tries to disable thinking. You choose an effort level of low, high or max, and max is the default. Section "Thinking is always on" below covers what that does to a skill that expects a quick, cheap step.

Limits are generous. The docs list a 1M-token context and 128K maximum output for both models. For a subagent that is handed a large repository slice, the window is rarely the constraint. The bill is.

Weights are public. Flash is on Hugging Face under MIT. If a skill handles code or documents that cannot leave your network, self-hosting is a real option, with SGLang, vLLM, TokenSpeed, Transformers and KTransformers named on the model card. GLM-5.3 weights are also public, but under a license listed as "other" with a clause aimed at very large model-as-a-service operators.

There are two siblings on the price page worth knowing. GLM-5.3-FlashX is a faster variant that the docs rate at 200 tokens per second and list at $0.37, $0.075 and $1.25 per million tokens. GLM-5.3-FlashX-Legal is a legal-domain model at the same prices. The docs said FlashX was not yet on the Coding Plan.

What one skill run costs

Per-token prices tell you little until you attach a run shape. We use four invented shapes that resemble things skill authors actually build. All input is split into uncached and cached tokens, because a skill loop resends its system prompt, tool definitions and growing transcript on every turn, and that stable prefix is what caching discounts.

Two things stand out. First, the ratio between GLM-5.3 and Flash is almost exactly 9 on every shape, because Flash is 9.3 times cheaper on input, 8.7 times on cached input and 8.8 times on output, so any blend lands near 9. Second, none of these runs costs more than a dollar. A skill that runs 200 times a day on shape B costs about $3.12 a day on Flash and about $27.80 on GLM-5.3, if the token counts hold. The absolute amounts are small enough that the choice is about volume and scale, not about any single run.

The cache decides more than the model choice

Cached input on Flash costs $0.03 per million tokens, a fifth of the $0.15 uncached rate. On shape B, with 170K of 200K input tokens cached, the input side costs about $0.0096. With no cache hits at all, the same run's input side would cost $0.03. Z.ai's pricing page also lists cached input storage as "Limited-time Free", so check the page again before you budget for a long-lived session, since that line is explicitly temporary.

So before you debate Flash against GLM-5.3, look at whether your skill is built to cache. Keep the SKILL.md body, tool schemas and project context at the front of the prompt and in a fixed order, and append new turns at the end. A skill that reorders tool results or rewrites the system prompt each turn spends more, on either model.

The Artificial Analysis chart, read carefully

Z.ai's launch post argues that Flash pushes the cost-performance frontier, citing the Artificial Analysis Intelligence Index v4.1.1 at a score of 57 and $0.045 per task.

The chart tags the Flash point as discounted and does not say which price was used. We could not find an independent index score for Flash on a current index version when we fetched the Artificial Analysis model page on October 29, 2026; its index and cost-per-task fields read N/A. So use the chart as a statement of Z.ai's position, and use your own run costs for budgeting.

Why the output side decides the bill

Skill loops are input-heavy but cached, so the line that grows fastest with a harder task is output: reasoning tokens plus the answer. Z.ai published an effort chart for Flash that makes the point.

Reading the chart, Flash at max effort lands near 29.0 percent using roughly 139K output tokens per task, while GLM-5.3 at max lands near 34.5 percent using roughly 75K. Those token counts are chart readings, so treat them as approximate. Z.ai's own text for the GLM-5.3 side gives the 34.5 percent at about 75K figure explicitly.

The consequence for a skill budget is direct. If Flash emits about 1.9 times the output tokens of GLM-5.3 on the same task, the 8.8 times output price gap becomes roughly 4.7 times on output cost per task. Recomputing shapes B and C with Flash output inflated by 1.9 times (and GLM-5.3 unchanged) gives $0.0210 against $0.1390 for B and $0.0370 against $0.2515 for C. The ratios fall from about 9 to 6.6 and 6.8. Flash is still far cheaper, but the saving is closer to a factor of seven than nine, and it comes with a lower accuracy reading on the hardest coding tasks.

The retry budget

The cleanest way to think about this is a retry budget. If a Flash attempt used the same number of tokens as a GLM-5.3 attempt, you could run about nine Flash attempts for the price of one GLM-5.3 attempt on every shape in the table above. With the 1.9 times output inflation, the budget is closer to six or seven. A skill with a reliable checker, such as a test suite, a schema validator or a diff review step, can use that budget: run Flash, verify, and escalate to GLM-5.3 only on failure. A skill with no checker cannot, because it has no way to know that the cheap attempt failed.

That is the reason the routing rule later in this article is built around verification, not around task difficulty alone.

Thinking is always on

Z.ai's migration guide says thinking can no longer be disabled on GLM-5.3, and Flash follows the same rule. The request field thinking.type only accepts enabled. If your harness currently sends disabled for cheap steps, the guide tells you to switch it to enabled with effort set to low, and warns that otherwise the request fails.

For skill authors this has three practical effects.

There is no free step. A skill whose steps were designed to be instant, such as a classifier that returns a label or a router that picks a tool, will now spend reasoning tokens on each call. Set reasoning_effort to low for those steps and measure the output tokens, because the default is max.

Effort belongs in the skill, not in a global config. Different steps in one skill want different effort. A planning step may deserve high, a formatting step low. If your host lets a skill or subagent definition carry its own model parameters, put the effort level there.

Streaming settings matter. The Flash docs recommend temperature: 1, top_p: 0.95, reasoning_effort: max, thinking.clear_thinking: false and, for streaming, both stream: true and tool_stream: true. The docs do not explain clear_thinking in the pages we read, only recommend leaving it false. In a multi-turn skill, test it on your own loop and watch the input token counts, since we could not confirm what it changes.

Tool calling: what is documented and what is not

A skill is mostly tool calls, so this is the section to read slowly.

What the docs state. Z.ai's function-calling documentation says tool_choice defaults to auto and supports only auto. In practice that means you cannot force the model to call a specific tool, and you cannot force it to call any tool at all. A skill that depends on "always call submit_result at the end" must say so in the prompt and verify it in code. Streaming tool calls need tool_stream: true in the request.

What the benchmarks say. In Z.ai's own tables Flash scores 78.4 on Toolathlon Verified against 73.0 for GLM-5.3 and 59.9 for GLM-5.2, and 48.8 on AutomationBench v1.0.6 against 48.2 for GLM-5.3. Z.ai documents that Toolathlon Verified is pass@1 averaged over three runs from the official evaluation service. These are vendor-reported numbers, and they are the strongest argument for routing tool-heavy skills to Flash. They are also the rows where harness details matter most, so reproduce them on your own tools before trusting them.

What the HF commit history says. The chat template in both Hugging Face repositories changed on September 4, and again on October 14 and 15, with a commit titled "speed up tool-result validation and reordering". If you self-host, pin a revision. If you use a hosted endpoint, assume the provider may have picked up the change at a different time than another provider did.

What we could not find. We found no independent measurement of tool-call error rates, malformed-argument rates, parallel-call behavior or recovery after a tool error for either model. The vendor numbers above measure task success, not call-level reliability. Anything you need to know about malformed JSON arguments, hallucinated tool names or loops that repeat the same failing call has to come from your own evaluation.

Provider differences on OpenRouter

If you reach Flash through OpenRouter, you are choosing among providers. On October 29, 2026, the endpoints API listed 40 rows for z-ai/glm-5.3-flash, with input prices from $0.0457 to $0.225 and output prices from $0.0625 to $0.75 per million tokens, and quantization labels that included fp4, fp8, nvfp4 and unknown. The Z.AI row matched list price at $0.15 and $0.50. A cheaper row may serve a lower-precision build. For a tool-calling skill, lower precision is a plausible source of more malformed calls, though we did not measure it. Pin the provider in your routing preferences and run your own checks against the exact endpoint your skills will use.

Which skills to route to Flash

Use the following table as a starting policy, then adjust it from your own results.

The pattern is that Flash earns its place on skills with a cheap, automatic way to tell success from failure. Where a wrong answer is expensive and nothing checks it, price per token is the wrong variable.

Subagent fan-out

Parallel subagents are where Flash's price matters most. Shape C in the cost table is a parent agent that spawns five subagents, each reading a slice of a repository and returning a summary. At $0.0280 on Flash and $0.2515 on GLM-5.3, a hundred such fan-outs cost $2.80 against $25.15. The skills dispatching-parallel-agents, subagent-driven-development and create-subagents describe the orchestration patterns.

A sensible split is to run the workers on Flash and the parent, which plans and merges, on GLM-5.3. Workers do bounded reading and extraction, where a cheap model with a clear output schema is enough. The parent holds the plan and resolves conflicts between worker results, where a missed detail propagates. Two cautions apply. A worker that is only told "summarize this" will happily spend max-effort reasoning on it, so set effort explicitly in the subagent definition. And because tool_choice cannot force a call, give each worker an output contract that the parent validates before merging.

Writing the routing rule down

Teams tend to route by feeling and then argue about results. A written rule is easier to improve. The following policy is a generic sketch, not the configuration syntax of any particular host, and every threshold in it is a placeholder to be replaced with your own data.

route(skill_run):
  if skill.needs_images_or_video_or_files:      use GLM-5.3-Flash
  elif skill.has_automatic_checker:
      attempt 1..2 on GLM-5.3-Flash (effort: low or high)
      if checker fails twice:                   escalate to GLM-5.3 (effort: high)
  elif skill.failure_is_costly:                 use the strongest model you trust
  else:                                         use GLM-5.3-Flash and sample outputs for review
  record(tokens_in, tokens_cached, tokens_out, attempts, passed)

The last line is the important one. Without per-run records of tokens and pass or fail, you cannot compute cost per finished task, which is the only number that tells you whether routing to Flash saved money.

For a wider routing discussion across model vendors, see our posts on GPT-6 model routing for agent skills, GPT-6.1 Sol for agent workloads and Opus 5.5 versus Sonnet 5.5 for agent skills. The registry also lists general tooling: ai-cost-optimizer and clawrouter are routers, openrouter covers the gateway, context-budgeting deals with prefix and window management, and agent-evaluation is a starting point for the checks below. We list them as registry entries, not as endorsements; we did not test them with GLM-5.3-Flash.

Running Flash for a coding agent on a plan

If your skills run inside a coding agent such as Claude Code, OpenCode or Cline, the GLM Coding Plan may be a better fit than metered API calls. Z.ai's documentation describes tiers with a 5-hour credit limit and a weekly limit.

A call's credit cost is its uncached input tokens times an input multiplier, plus cached tokens times a cached multiplier, plus output tokens times an output multiplier, all divided by 10,000. The multipliers are 6.9, 1.7 and 24 for GLM-5.3, and 2.3, 0.56 and 8 for Flash. Peak hours are Monday to Friday, 14:00 to 18:00 in UTC+8 (06:00 to 10:00 UTC), and off-peak calls cost half the standard credits.

Applying that to our four shapes:

The credit ratio is about 3.0 on all three multipliers, which is why Z.ai's post says Flash gives about three times the usable quota of GLM-5.3. That is a much smaller advantage than the 9 times seen in dollar pricing, because the plan prices credits, not dollars. If you have a subscription, the plan flips the economics: you are no longer minimizing a dollar bill, you are maximizing runs per window. A Lite plan covers about 77 shape-B runs on Flash and 26 on GLM-5.3 per 5-hour window at peak rates.

The docs also say that requests for GLM-5.2 and GLM-5.1 on the plan are routed to GLM-5.3, and requests for GLM-4.7 are routed to Flash. If a skill pins an old model name, check which model actually serves it. One unresolved detail: Z.ai lists several base URLs, including a dedicated coding path and a general path. We did not find a page stating which one bills against plan credits and which against a pay-as-you-go balance, so confirm that before pointing a production agent at either.

An evaluation harness for the swap

Before routing a real skill to Flash, run a small controlled comparison. It takes an afternoon.

1. Freeze 20 to 40 real runs from your own logs, including several that failed or needed retries. Store the inputs and the expected outcome or checker.
2. Run both models at matched effort, then Flash one effort level lower. Record input, cached and output tokens for every call, and the number of attempts to pass.
3. Compute cost per finished task, not cost per call: total spend divided by the number of tasks that passed the checker.
4. Count call-level failures separately: malformed arguments, a wrong tool, a call to a tool that does not exist, the same failing call repeated, a missing final call. These are the failure modes that no published number measures.
5. Test with your real tool definitions and your real error messages. A tool that returns a long stack trace exercises the model differently from one that returns a short code.
6. Repeat on the exact provider and quantization that production will use.
7. Run the images and files test separately if the skill uses them, because the multimodal rows in Z.ai's table have the thinnest set of comparison models.
8. Re-run when the provider changes its build or chat template. The Hugging Face history shows the template did change after launch.

What we could not verify

• Every performance number here is Z.ai-reported. We did not rerun a benchmark.
• The effort-chart token counts and the Artificial Analysis chart values are read from images and are approximate. Z.ai's Code Bench is private.
• We found no independent index score for Flash on a current Artificial Analysis version, and no independent reproduction of Z.ai's GLM-5.3 table.
• We found no independent figures for tool-call reliability, parallel tool calls or error recovery for either model.
• The run shapes and credit estimates are invented examples built from list prices and the documented multipliers.
• We did not measure latency, throughput under load or long-context accuracy.
• Z.ai says Ox Alpha traffic was served on Chinese AI chips, and OpenRouter's notice says Ox Alpha prompts were retained by the provider. We report both as stated and verified neither.
• Third-party discount offers and reseller promotions were not verified and are left out.

Verdict

GLM-5.3-Flash is a good candidate for the high-volume, checkable, cache-friendly part of a skill workload. At $0.15 and $0.50 per million tokens it makes five-way subagent fan-outs cost a few cents, and it is the only one of the two GLM-5.3 models that reads images, video and files. The discount is real but narrower than the price ratio suggests, because Z.ai's own chart shows Flash spending more output tokens per task, and thinking cannot be switched off.

It is a poor fit for skills whose failures are silent and expensive, and for the hardest long-horizon coding, where Z.ai's own tables put GLM-5.3 ahead. The tool-calling picture is the least settled part: the documentation constrains you to tool_choice: auto, the vendor numbers look strong, and independent call-level evidence is absent. Treat the first week as an experiment with a written routing rule, per-run token records and an escalation path to GLM-5.3.

FAQ

How much does a skill run cost on GLM-5.3-Flash? At Z.ai list prices, our invented shapes cost $0.0012 for a one-shot triage skill, $0.0156 for a 20-turn fix-and-test loop and $0.0280 for a five-subagent fan-out. Your real figure depends on token counts and how much of the prompt is cached.

Is GLM-5.3-Flash nine times cheaper than GLM-5.3 in practice? Per token, yes: about 9.3 times on input and 8.8 times on output. Per finished task, Z.ai's own effort chart suggests roughly 4.7 to 6.8 times, because Flash emitted more output tokens. We computed that ratio from chart readings and it is approximate.

Can I force GLM-5.3-Flash to call a specific tool? Not according to Z.ai's function-calling docs: tool_choice only supports auto. Put the requirement in the skill prompt and validate the result in code.

Can I turn thinking off for cheap steps? No. Thinking is always on. Set reasoning_effort to low for simple steps, since the default is max.

Does Flash accept images in skills? Yes. Flash accepts text, image, video and file input and returns text. GLM-5.3 accepts text only.

Is it available on the GLM Coding Plan? Yes, with credit multipliers of 2.3, 0.56 and 8 against 6.9, 1.7 and 24 for GLM-5.3, which Z.ai summarizes as about three times the usable quota.

Should subagents all run on Flash? A reasonable default is Flash for bounded worker tasks with a validated output schema, and GLM-5.3 for the parent that plans and merges. Measure it on your own tasks before committing.

Sources

Checked October 29, 2026.

Z.ai, primary

• GLM-5.3-Flash: Frontier Intelligence, Flash Cost: architecture, benchmark tables, effort and Pareto charts, Ox Alpha statement
• GLM-5.3: Frontier Coding with Emergent Cyber Capabilities: benchmark table, effort chart, API changes
• Z.ai pricing page and release notes: list prices and launch dates
• GLM-5.3-Flash guide, GLM-5.3 guide, migration guide and function-calling docs: parameters, limits, thinking and tool_choice rules
• GLM Coding Plan overview: credits, multipliers, peak hours
• Z.ai on X: Flash pricing post

Weights and gateways

• GLM-5.3-Flash on Hugging Face and GLM-5.3 on Hugging Face: licenses, serving frameworks, commit history
• OpenRouter: z-ai/glm-5.3-flash and the Ox Alpha stealth page: provider rows and stealth notice

Independent and press

• Artificial Analysis: GLM-5.3-Flash: speed and license fields, index fields N/A at fetch time
• The Batch on Ox Alpha: press context