Why Theo Uses GLM-5.3-Flash for Coding Agent Work

An anonymous model called Ox Alpha appeared on OpenCode and OpenRouter with an extraordinary advertised capacity of 100 trillion tokens per day. I tried it heavily before learning its identity, and it turned out to be Z.ai’s GLM-5.3-Flash. Its combination of useful agent behavior and low price surprised me.

A friend tested it on a public subset of DeepSWE problems and obtained a striking score. I caution against taking that small result as a complete benchmark comparison. My excitement comes from using the model on real tasks as well as looking at published results.

The announcement describes a million-token context window and multimodal inputs, including images, audio and video. I connected the model to my T3 Code workflow through an OpenRouter-compatible proxy and tried it in a Codex harness, even though that setup required some tinkering.

My first task was to examine open pull requests and rank them by ease of merging and value. When an attempted tool call failed, the model tried command-line alternatives. That matters to me: a model that can recover from a tool problem is more useful than one that stops at the first error.

I then changed the instructions while it was working: exclude Codex-created PRs, focus on those attributed to Fable and Claude Code, and put the findings into an HTML report. Some models respond to a mid-task steer and then stop; here I wanted the agent to incorporate the change and keep going.

The live demonstration hit GitHub connection and skill-reading problems, some caused by my modified setup. Rather than pretend it went smoothly, I switched to an earlier run where I had asked the model to audit PRs updated over five days and assess overlap, risk and ease of action.

In that run delegation encountered authentication failures. The agent recognized the repeated failures and fell back to a direct audit using metadata, diffs, reviews, CI and local context. It produced a ranked report instead of waiting indefinitely for broken workers.

The report included links to candidate PRs, which seems small but saves me time. I reviewed and merged eight easy candidates it identified. I followed up by asking for another pass after those merges, excluding drafts and listing addressed issues.

The second report said 352 non-draft PRs remained in the same five-day cohort. It listed addressed issues and further candidates. This is my experience with one repository and task, not proof that the model’s judgments can be merged without human review.

I also got the model working through my Z.ai subscription. Performance was variable: the provider comparison I showed listed different latency and throughput figures. I initially misread a 4.4-second time to first token as minutes, then corrected myself.

At the time of the video, the displayed promotional API price was $0.075 per million input tokens and $0.25 per million output tokens, with a separate discounted cache-read rate. Prices, promotions, subscriptions and provider speeds can change; these figures describe that moment.

Z.ai describes a mixture-of-experts model with 320 billion total parameters and 18 billion active parameters. It is much smaller than some large models in total size. Parameter counts alone do not establish quality, but they help explain why serving economics can differ.

I think model evaluation gets confused when people always choose the most expensive reasoning setting, or assume there is one best model for every task. More effort can consume more of an allowance, and the right choice depends on both the work and how the model behaves.

My rough distinction is between intelligence and behavior: what a model knows or can reason about, and how reliably it follows a task, accepts new directions and uses tools. These are not rigorous independent measurements, but the distinction helps explain my experience.

I contrast a knowledgeable model that struggles with agentic execution with GLM-5.3-Flash, which I find less capable on hard problems but pleasant to direct. A model can seem more useful because it stays on task, even when it is not the strongest at every reasoning test.

For example, I use my private Skatebench to test naming skateboarding tricks. Gemini 3.1 Pro scored especially well in my runs, yet I have been frustrated by its coding-agent behavior. Those are my own tests and experiences, not a general ranking of the models.

With GLM-5.3-Flash, I care that it follows the instruction, remembers a new constraint mid-task and tries to unblock itself. I attribute some of that to post-training, although I cannot establish the precise cause just by watching the model work.

The live report filtered the PRs and produced a mobile-readable page. When I thought it had included other people’s work by mistake, I reread my prompt: I had actually asked for all open PRs. The agent had followed my broad instruction, and my own request was the problem.

The report separated high-confidence candidates from medium-confidence ones and highlighted valuable fixes. One potential fix concerned busy threads freezing clients. It gave me a lead I might not have noticed, but I still needed to inspect the PR and its circumstances.

I asked another agent to estimate the run’s token cost from local records. Its first calculation was roughly 48 cents, using the ordinary input rate for cached tokens. After I supplied the lower cache-read rate, it revised the estimate to about 12.06 cents.

The displayed calculation uses about 323,000 uncached input tokens, 30,642 output tokens and roughly 5.9 million cache-read tokens. This is an estimate using the displayed API rates, not an itemized bill: I was using a subscription. The spoken claim of six billion input tokens conflicts with the displayed arithmetic.

That low estimated cost makes recurring repository triage appealing. I could have a model identify candidates regularly, then decide what deserves review. The useful outcome is not simply a cheap answer; it is finding work that I otherwise might miss.

There is a tradeoff: I do not think this model solves hard problems as well as Fable or Sol. But for easier tasks, it can carry out substantial agent work cheaply. That gives it a distinct role beside more capable and expensive models.

I compare it with DeepSeek V4 Flash, whose downloadable version I understand to lack vision. A separate vision API endpoint is not necessarily the same capability in downloadable weights. I also found the earlier model more likely to lose track during long tasks.

Z.ai’s announcement says the model combines sparse and linear attention and was trained on a multimodal corpus. The company describes those choices as reducing long-context serving costs. Its claims about architecture and benchmarks should be read as the developer’s account.

On the Artificial Analysis chart shown, GLM-5.3-Flash scores 57 at an estimated nine cents per task, while GPT-5.6 Luna is around five cents on that chart. The cost axis is logarithmic, and a four-cent difference should not be interpreted from visual spacing alone.

The same chart places Kimi K3 at a higher score and cost. I find the price-to-score tradeoff attractive, especially with open weights, but a composite score is not a substitute for testing the tasks and providers one actually uses.

Z.ai’s coding chart plots accuracy against output tokens at different effort settings. In the displayed comparison, GLM-5.3-Flash at high effort is near its maximum-effort score with substantially fewer tokens; I also compare it to Opus 4.8. The chart is the vendor’s benchmark, not a universal measurement.

The model’s visual input can be useful for inspecting a page it built and iterating on layout. I have found its computer-use behavior promising, although the quality of the final result depends on the tool setup and the task.

On the DeepSWE chart I examine, the model scores around 63% in the displayed configuration at a relatively low estimated cost. The earlier 80% figure came from a public subset and is not directly comparable to the full benchmark. Score, cost and evaluation settings all matter.

My reservation is token efficiency. The Artificial Analysis comparison I show puts GLM-5.3-Flash at around 47,000 output tokens per task, compared with roughly 20,000 for Luna and 17,000 for Sol in those settings. A low price per token can still produce a good overall cost.

Token efficiency matters beyond price: more generated tokens can mean more time and faster context-window consumption. Comparing quality at a similar level of work matters, so I would not judge a model on token count alone.

I also look at a design benchmark with and without design skills. The default layouts are acceptable but often familiar. With additional design guidance, some examples look much stronger, although animations and layout details still need refinement.

Some generated copy and visual details feel less generic to me than I expected. That is subjective, but it contributes to why I find this model pleasant: it can follow a design direction without constant correction, even when its underlying reasoning is limited.

In my Fish Slop game test, the model produced appealing movement and visual details, but it also made logic errors: fish could stop moving after eating or eat when not hungry. A polished-looking demo is not proof that the application logic is correct.

I also asked it to port the game to 3D. The result was not good enough for me to turn into a finished game, but producing the models and a working attempt was impressive for a smaller model. I had disabled computer use during that run, limiting its visual feedback.

Z.ai also showed a Blender scene made over a twelve-hour run. The resulting environment looked impressive to me, but it is a developer showcase rather than an independently controlled comparison of all models.

Z.ai says the anonymous Ox Alpha preview was served entirely on Chinese AI chips; the video cites research identifying Huawei Ascend hardware. I find the scale notable, while the precise economics and optimizations behind the service are not independently established in my demonstration.

For my personal tier list, I weigh unique usefulness rather than raw intelligence alone. I place GLM-5.3-Flash near Sol because it gives me a cheap, well-behaved option, while still believing that larger models can be smarter on difficult work.

I compare it with Muse Spark and DeepSeek V4 Flash: price, privacy options, vision and whether weights can be run locally affect the choice. Hosting arrangements and data policies differ, so the right answer depends on the user’s actual setup.

The anonymous preview made me try a model I might otherwise have dismissed. I plan to keep using GLM-5.3-Flash for inexpensive, thorough agent work, while retaining stronger models for harder tasks. The best way to judge it is to try it on work that matters to you.