GLM-5.3 与 Claude Fable 5 在 DeepSWE 上的成本、编码与路由对比

Key Takeaways

GLM-5.3 and Claude Fable 5 finish within noise of each other on DeepSWE accuracy, but GLM-5.3 costs a fifth as much per task and wins every multi-attempt metric. When two models are this close on quality, the price gap becomes the entire decision.

In our GLM-5.3 vs. Claude Fable 5 comparison on DeepSWE, a benchmark that tests a model's software engineering ability across many task types and programming languages, the two models are almost impossible to separate on quality. Fable 5 leads pass@1 by 0.7 points. It also costs 5.4x more per rollout and is the single most expensive configuration on the DeepSWE board. That combination makes the interesting question a narrow one: what does the premium buy when the accuracy is the same?

DeepSWE · Head to Head

We ran GLM-5.3 (max) against Claude Fable 5 (max) on all 113 DeepSWE tasks, four trials each, from the published per-trial records: 904 rollouts in total, 452 per model. Both belong to the disciplined, low-regression school, which is why they behave so much alike. Every figure below comes from this run, so it can differ from other public GLM-5.3 vs. Claude Fable 5 scorecards.

Single shot it is a tie. Fable 5 solves 69.7% of tasks on the first try under DeepSWE's official scoring, GLM-5.3 solves 69.0%, a gap well inside the noise band. The models separate once you allow retries, and they separate in GLM's favor. At two attempts GLM-5.3 leads 81.1% to 77.1%. At four it leads 87.6% to 84.1%.

The open model matches Fable's first-shot accuracy at a fraction of the price, and it also holds the higher ceiling once retries are allowed. There is no attempt count at which paying 5.4x for Fable buys more coverage.

At $3.99 a rollout, GLM-5.3 is 5.4x lower-cost than Fable at \$21.63: 17 solves per \$100 against Fable's 3. Fable is the most expensive configuration on the board, and the price does not come with a speed penalty for GLM. GLM-5.3 averages 35 minutes per rollout against Fable's 34, roughly even.

The token profile explains the shape of the run. GLM-5.3 is the less verbose model (80k output tokens to Fable's 114k) despite taking more steps (124 vs. 85). Fable writes more per step, GLM takes more and lower-cost steps. Neither is faster, but only one costs a fifth as much.

Decompose pass@1 into coverage (tasks solved at least once) and reliability (pass rate on those tasks) and the two land near the same corner of the plane, with GLM reaching slightly further. GLM-5.3 has the higher coverage at 87.6% against Fable's 84.1%. Fable is marginally steadier per attempt at 82.0% reliability against 78.8%, and solves more tasks four-for-four (56 vs. 48).

In practice both behave like disciplined generalists, with GLM trading a sliver of per-shot reliability for meaningfully wider reach across the benchmark.

This is where the family resemblance is clearest. Both models regress the existing test suite in only 11% of failures, far below the GPT-family's 20%, so both are safe to accept without heavy regression gating.

The differences are small. Fable carries the larger big-miss share (18% vs. GLM's 16%), meaning that when it is wrong it is slightly more often badly wrong. GLM fails by near miss a little more often (61% vs. 57%). Broadly, these two fail the same disciplined way, which is exactly why their results are so correlated.

Despite the tie on pass@1, the domain maps are not identical. GLM-5.3 takes the structured, interpreter-style work: query and config (88 vs. 72), language and runtime internals (83 vs. 78), stateful reactivity (73 vs 64), concurrency and durability (62 vs 45), and program analysis (64 vs 56). That concurrency result is a 17-point gap in Fable's weakest domain.

Fable answers with the exact-contract domains: data modeling and serialization (88 vs. 79), build and ops (71 vs. 68), and protocol conformance (55 vs. 44), which is GLM's weakest area. GLM wins five domains to Fable's three, and Fable's 45% on concurrency is the one lane to keep it out of entirely.

Fable's case rests almost entirely on one language. Its Rust is 85% to GLM's 70, a 15-point margin and the widest single-language gap in the matchup. Serialization-heavy work is the natural companion to that strength.

GLM answers with the best JavaScript on the board (90 vs 75), near-parity on Go (76 vs 71), and TypeScript (61 vs 57). Fable holds Python (70 vs 66). Outside Rust and serialization-heavy work, there is no language where Fable's 5.4x premium buys a meaningful accuracy edge.

Here is the catch for anyone hoping to run both. Per-task correlation between GLM-5.3 and Fable is 0.65, the highest agreement of any pairing in this set. Both solve 88 tasks. GLM alone gets 11, Fable alone gets 7, and 7 defeat both, with no four-for-zero disagreements in either direction.

Their union covers 106 of 113 tasks (93.8%), but because they succeed and fail on largely the same tasks, pairing them adds less diversity than pairing either with a GPT-family model. They are near-substitutes, and when two models substitute, you keep the lower-cost one.

If you do run both, the order and the economics still favor the open model as the front-end. Run GLM-5.3 first and escalate to Fable only when your test suite rejects the answer: 81.1% solved at \$10.74 per task. That is eleven points above Fable alone (69.7%) for half of Fable's own per-task price (\$21.63).

Given the 0.65 correlation, the honest recommendation is simpler: for most work GLM-5.3 alone captures nearly everything Fable would, at a fifth of the cost, and Fable is worth escalating to only for its Rust and serialization specialties.

Fable 5 and GLM-5.3 are a statistical tie on first-shot accuracy, and that is where the parity ends. GLM-5.3 is 5.4x lower-cost, higher on pass@2, pass@4, and coverage, less verbose, equally disciplined on regressions, and it wins five of eight domains plus the best JavaScript on the board.

Fable is the most expensive model measured here and, against GLM, wins only three domains plus a genuine Rust and serialization advantage. Because the two are near-substitutes at 0.65 correlation, there is little portfolio benefit to running both. The practical stance is GLM-5.3 as the default and Fable as a narrow, expensive escalation for Rust-heavy or serialization-critical tasks. Check out new GLM 5.3 Flash API.

DeepSWE · Full Results

113 DeepSWE tasks · 4 trials per config · both at max effort · 904 rollouts total

On DeepSWE they are a statistical tie on the first attempt: Fable 5 posts 69.7% pass@1 to GLM-5.3's 69.0%. GLM-5.3 wins every metric after that, including pass@2 (81.1% vs 77.1%), pass@4 (87.6% vs 84.1%), and coverage, at 5.4x lower cost per rollout. Fable solves more tasks four-for-four (56 vs 48), so it is marginally steadier on any single attempt.

In our run, GLM-5.3 cost \$3.99 per rollout against \$21.63 for Claude Fable 5 at max effort, a 5.4x gap. Measured per solved task, GLM-5.3 returned 17 solves per \$100 against Fable's 3.

It depends on the language and the task type. GLM-5.3 takes JavaScript (90 vs 75), Go (76 vs 71), and TypeScript (61 vs 57), and wins five of eight task domains including concurrency and durability, where it leads 62 to 45. Claude Fable 5 leads Rust (85 vs 70), Python (70 vs 66), and the exact-contract domains, led by data modeling and serialization at 88 vs 79.

Only selectively. The two models have the highest per-task correlation of any pairing we have measured (0.65), so they succeed and fail on largely the same tasks and their union covers 106 of 113. A GLM-first cascade does reach 81.1% at \$10.74 per task, well ahead of Fable alone, but the larger gain for most teams is simply defaulting to GLM-5.3 and reserving Fable for Rust-heavy or serialization-critical work.

Yes. GLM-5.3 is an open-weight model, so it can be self-hosted or served through inference providers such as Together AI. Claude Fable 5 is a closed model available only through Anthropic and its partners.

pass@k measures whether at least one of k attempts at a task passes the hidden test suite. pass@1 rewards getting it right on the first try, and higher k rewards a model that can eventually reach a solution across several tries. GLM-5.3's edge grows as k increases.