Testing GLM-5.3 on a Budget with OpenCode Go: 10 Tasks, 4¢, Zero Failures

On August 14, 2026, Zhipu dropped GLM-5.3 — a post-training-only upgrade over GLM-5.2 with 128K max output tokens. I put it through its paces with OpenCode Go the same day — spoiler: it's awesome.

It's one of the pricier models on the OpenCode Go plan — a reasoning model at $1.40/M input and $4.40/M output, with a $15/month usage allowance, so every token counts. I wanted to answer a simple question: is it worth the premium over cheaper Go models like DeepSeek V4 Pro ($0.435/$0.87)? — without burning my monthly usage finding out.

So I built a tiny benchmark that cost under 4 cents total. Here's what I did and what I found.

The budget math

Before writing a single prompt, I worked out what a request actually costs:

	Price (per 1M tokens)
Input	$1.40
Output	$4.40
Cached read	$0.26

A self-contained prompt sent through opencode run (no tools, no file ops) is roughly 50 input + 100–180 output tokens. Even at the top end that's about $0.007 per request. Ten prompts ≈ 4 cents.

The trick to staying cheap: short, self-contained prompts that don't trigger agentic tool loops, and a shared system prompt so OpenCode's context stays in the cache ($0.26/M instead of $1.40/M).

Setup

One line. GLM-5.3 is already in the Go catalog under the model id opencode-go/glm-5.3, so after /connect → OpenCode Go it's just:

opencode run --model opencode-go/glm-5.3 "your prompt"

The test

A Bash harness loops over 10 prompts and runs each one through opencode run, timing it and saving the output:

#!/usr/bin/env bash
set -uo pipefail
MODEL="${MODEL:-opencode-go/glm-5.3}"
SUFFIX=$'\n\nAnswer directly. Do not run any code or use any tools. Just provide the answer.'
echo "task,wall_seconds,status" > results/summary.csv
idx=1
while IFS= read -r -d '' prompt; do
  start=$(date +%s.%N)
  opencode run --model "$MODEL" "$prompt$SUFFIX" > "results/$(printf '%02d' "$idx").md" 2>&1
  end=$(date +%s.%N)
  echo "$idx,$(echo "$end - $start" | bc -l),ok" >> results/summary.csv
  idx=$((idx+1))
done < <(python3 -c "import sys;print('\0'.join([p.strip() for p in open('prompts.txt').read().split('=====') if p.strip()]))")

The 10 prompts span the categories a coding agent actually needs: code generation, bug fixing, code review, SQL, regex, logic, math, structured output, explanation, and format-following.

Results

#	Category	Task	Result	Wall time
1	Codegen	Flatten a nested list (iterative)	✅ Correct stack-based solution	10.7s
2	Bug fix	Binary search off-by-one	✅ Caught the return lo bug	53.1s
3	Code review	max() in Go	✅ Found 3 real issues	15.4s
4	SQL	Top-3 paid per department	✅ DENSE_RANK() + tie handling	45.2s
5	Regex	Valid IPv4	✅ Correct	21.8s
6	Logic	8-ball / 2-weighing puzzle	✅ Correct 3-3-2 strategy	28.4s
7	Math	Derivative of x³·ln x	✅ x²(3·ln x + 1)	24.8s
8	JSON	Structured output	✅ Valid JSON, no fences	28.7s
9	Explain	JS dedup snippet	✅ Correct + 2 improvements	35.1s
10	Format	Exact bullet-list format	✅ Followed exactly	8.2s

10/10 correct. Total wall time ~4.5 minutes. Total cost ~$0.04.

Findings

1. It's a reasoning model — and it thinks a lot

This was the surprise. GLM-5.3 emits thinking tokens before answering, and the amount of thinking scales with task difficulty:

Task	Reasoning tokens	Output tokens
"List three benefits…" (easy)	37	35
SQL top-3 (medium)	95	107
Flatten nested list (hard)	749	179

On the hard task it thought ~4× more than it wrote. That reasoning is billed as output ($4.40/M), so it's the single biggest cost driver — and the biggest latency driver too.

2. Latency is the real price, not dollars

Wall times ranged from 8s to 53s. The binary-search fix (53s) and SQL query (45s) were the slowest, both reasoning-heavy. For a $4.40/M output model, the money is trivial — the waiting is what you'll notice in day-to-day use.

3. There's a hidden reasoning dial

When I hit GLM-5.3's raw OpenAI-compatible endpoint directly with default settings, it went off the rails: it burned 2,047 reasoning tokens on "flatten a list" and produced an empty answer because it hit the token cap while still thinking, with a 49-second time-to-first-token.

Passing "reasoning_effort": "low" changed everything:

low  => finish=stop  reasoning=2   total=6   content="444"

OpenCode Go's default tuning keeps the model usable out of the box, but if you're calling the API yourself, you'll want to set a reasoning effort explicitly.

4. The quality bar is genuinely high

The code review was the highlight — it caught the all-negative-input bug, the empty-slice edge case, and that the function shadows Go 1.21's built-in max, then pointed at slices.Max(). That's the kind of detail I'd expect from a flagship model.

Minor nitpicks: the Go fix used fmt.Errorf without importing fmt, and the JSON task invented a name ("Ahmed Hassan") when none was given. Both trivial.

The cost breakdown

Request type	Cost
Easy prompt (list three)	$0.0030
Medium prompt (SQL)	$0.0035
Hard prompt (flatten)	$0.0067
10-prompt suite total	~$0.04

Against a $15 monthly Go allowance, that's 0.27% of my monthly usage for a complete capability picture.

Verdict

GLM-5.3 passed every task with detail I'd call frontier-grade, at a cost that's basically free on the Go plan. The trade-off is latency: it's a deliberate thinker, so it's best for hard, non-trivial tasks rather than rapid-fire edits.

If you want a fast, cheap daily driver, DeepSeek V4 Pro on Go is the better value. If you want a model that reasons through the hard stuff and rarely gets it wrong, GLM-5.3 earns its premium — and you can test it yourself for the price of a gumball.

---

All prompts, the harness, and raw results are in the repo. Total spend for this entire experiment (including the failed raw-API probes): under **8 cents.