Together AI、GLM-5.3 と Claude Fable 5 を DeepSWE で比較
本文の状態
日本語全文を表示中
詳細モードで約17分の本文を読めます。
同じ出来事の情報源
この情報源を基点に整理
Together AI Blog
Together AI が公開した DeepSWE ベンチマーク比較により、GLM-5.3 と Claude Fable 5 の精度は同等だが、前者の価格が後者の約 5 分の 1 でコスト効率に圧倒的な差があることが示された。
AI深層分析を開く2026年8月22日 15:42
AI深層分析
キーポイント
精度における実質的引き分け
DeepSWE ベンチマークにおける初回試行（pass@1）では、Claude Fable 5 が 69.7%、GLM-5.3 が 69.0% と誤差範囲内で互角であり、品質面で明確な優劣はつけられない。
再試行時の GLM-5.3 の優位性
複数回の試行（pass@2, pass@4）において GLM-5.3 が Claude Fable 5 を上回っており、高い成功率の上限と低価格を両立している。
劇的なコスト差の実証
1 回のロールアウトあたりのコストは GLM-5.3 が約$4 で Claude Fable 5 の約$21 と 5.4 倍の差があり、同じ金額で処理できるタスク数も前者が後者の約 6 倍となる。
実務における代替可能性
両モデルの相関係数が 0.65 と高いことから互いにほぼ代替可能であり、コスト効率を優先して GLM-5.3 を基本とし、Rust やシリアライゼーションなどの特定タスクのみで Fable を使用すべきである。
DeepSWEスコアボードでのパフォーマンス比較
1回試行では両モデルの精度はほぼ同等だが、再試行を許容するとGLM-5.3が上回る。GLM-5.3は4回試行で87.6%の解決率を示し、Fable 5の84.1%を上回った。
重要な引用
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.
The cost gap is 5.4x. $3.99 per rollout vs. $21.63.
They are near-substitutes.
At two attempts GLM-5.3 leads 81.1% to 77.1%. At four it leads 87.6% to 84.1%.
編集コメントを表示
編集コメント
精度が拮抗する状況下で価格差が 5 倍以上となる事例は、実務におけるモデル選定基準を明確にする重要な示唆を与える。特に GLM-5.3 のような高効率モデルの台頭は、大規模なコード生成タスクのコスト構造そのものを変える可能性を秘めている。
Source Article
元記事を日本語で読む
本文に関係しない購読案内、埋め込み通知、サイト内プロモーションは除いています。
初回試行では互角の結果でしたが、価格差は 5.4 倍あり、その差が最終的な決着をつけます。
主なポイント
GLM-5.3 と Claude Fable 5 は DeepSWE の精度において誤差範囲内で拮抗していますが、GLM-5.3 はタスクあたりのコストが約 5 分の 1 で、複数回試行時の評価項目すべてで勝利しています。このように品質がほぼ同等の場合、価格の差が意思決定を左右する最大の要因となります。
- 初回試行は互角です。Fable 5 の pass@1 は 69.7%、GLM-5.3 は 69.0% で、0.7 ポイントの差は両モデルの誤差範囲内に収まっています。
- GLM-5.3 が再試行で圧倒します。pass@2（81.1% vs. 77.1%）や pass@4（87.6% vs. 84.1%）でリードしており、より高い性能上限と低いコストを両立しています。
- コスト差は 5.4 倍です。ロールアウトあたり $3.99 対 $21.63。$100 の予算で GLM-5.3 は 17 タスクを解決できますが、Fable ではわずか 3 タスクです。
- 両者はほぼ代替可能です。タスクごとの相関は 0.65 で、このセットの中で最も高い一致率を示しています。そのため、両方を実行してもカバレッジの向上は限定的です。低コストモデルをメインに据え、Rust やシリアライゼーション関連の作業のみ Fable に任せるのが最適解です。
Together AI の GLM-5.3 と Claude Fable 5 を、さまざまなタスク種別やプログラミング言語に対応したソフトウェアエンジニアリング能力を評価するベンチマーク「DeepSWE」で比較しました。両モデルの性能はほぼ互角です。Fable 5 は pass@1 で 0.7 ポイントリードしていますが、ロールアウトあたりのコストは GLM-5.3 の 5.4 倍と、DeepSWE ベンチマーク上で最も高額な構成となっています。精度が同じなら「高価なモデルに何の価値があるのか」という問いが、自然と焦点を絞ることになります。
DeepSWE · Head to Head
GLM 5.3 と Claude Fable 5 の比較まとめ
| モデル | Pass@1 | 平均コスト | $100 あたり解決数 | 出力トークン数 | ステップ数 |
|---|---|---|---|---|---|
| glm-5.3 [max] | 69.0% ± 2.7% | $3.99 | 17 | 80k | 124 |
| claude-fable-5 [max] | 69.7% ± 2.3% | $21.63 | 3 | 114k | 85 |
GLM-5.3 (max) と Claude Fable 5 (max) を、公開された各試行の記録に基づき DeepSWE の全 113 タスクで比較しました。各モデル 4 回ずつ、合計 904 回のロールアウト（452 回ずつ）を実施した結果です。両者はいずれも「回帰を抑制し、安定性を重視する」アプローチを採用しているため、振る舞いが非常に似ています。以下に示す数値はすべて今回の実行データに基づくものであり、他の公開スコアカードとは異なる可能性があります。
DeepSWE スコアボード：pass@1 と pass@k
一度の試行（single shot）では、両モデルはほぼ同点です。DeepSWE の公式スコアリングに基づくと、Fable 5 は初回で 69.7% のタスクを解決し、GLM-5.3 は 69.0% です。この差は統計的な誤差の範囲内と言えます。
しかし、再試行（retries）を許容すると両者の差が明確になり、結果は GLM-5.3 が有利になります。2 回の試行では GLM-5.3 が 81.1%、Fable 5 が 77.1% です。4 回まで試行しても GLM-5.3 は 87.6% で Fable 5 の 84.1% を上回ります。
オープンモデルである GLM-5.3 は、Fable 5 と同等の初回成功率を達成しつつ、そのコストは大幅に低く抑えられています。さらに、再試行を許容した場合の上限性能も GLM-5.3 の方が高いです。Fable 5 に支払うコストが GLM-5.3 の約 5.4 倍であるにもかかわらず、それに見合うカバレッジ（解決率）を得られる試行回数はありません。
コスト比較：GLM-5.3 と Claude Fable 5 の価格
1 回の実行あたり GLM-5.3 は $3.99、Fable は $21.63 です。つまり、GLM-5.3 のコストは Fable よりも約 5.4 倍低いことになります。$100 あたりで GLM-5.3 は 17 件の解決が可能ですが、Fable ではわずか 3 件です。Fable は最も高価な構成であり、その価格に見合う速度の優位性は GLM-5.3 にありません。
実行にかかる時間は GLM-5.3 が平均 35 分、Fable が 34 分で、ほぼ同等です。
トークン使用量の傾向が、この結果の形状を説明しています。GLM-5.3 は Fable（114k トークン）に比べて出力トークン数が少なく（80k）、より冗長性の少ないモデルです。ただし、ステップ数は GLM-5.3 の 124 ステップに対し、Fable は 85 ステップと少なくなっています。
Fable は 1 ステップあたりの生成量が多いのに対し、GLM-5.3 はより多くのステップを低コストで実行します。速度では互角ですが、コストは GLM-5.3 が Fable の約 5 分の 1 です。
カバレッジと信頼性：GLM-5.3 と Fable 5 の違い
pass@1 を「カバレッジ（少なくとも 1 回でもタスクを解決した割合）」と「信頼性（そのタスクにおける成功率）」に分解して比較すると、両モデルはほぼ同じ領域に位置しますが、GLM-5.3 がわずかに広い範囲をカバーしています。
カバレッジでは GLM-5.3 が 87.6% で Fable の 84.1% を上回ります。一方、信頼性（試行ごとの成功率）は Fable が 82.0% と GLM-5.3 の 78.8% よりもわずかに安定しています。
また、Fable は 4 回の試行すべてで成功するタスクの数（56 件）が GLM-5.3（48 件）よりも多くなっています。
実務的には両モデルとも規律ある汎用モデルとして振る舞いますが、GLM-5.3 はわずかな信頼性の低下を許容して、ベンチマーク全体でより広い範囲をカバーするトレードオフを行っています。
失敗モード：各モデルがどのように間違えるか
この部分こそ、両者の類似性が最も明確に現れる箇所です。両モデルとも既存のテストスイートで 11% の割合で回帰エラーを発生させますが、これは GPT ファミリの 20% を大きく下回る水準です。つまり、厳重な回帰チェックを行わずとも、両モデルの結果を受け入れるには十分安全だと言えます。
違いは微細なものです。Fable は「大外れ」の割合がやや高く（18%対 GLM の 16%）、間違えた際に深刻なミスを犯す傾向がわずかに強いです。一方、GLM は「ほぼ正解」に近い失敗を少し多く見せます（61%対 57%）。全体的に、両モデルは同じように規律ある形で失敗します。この点こそが、両者の結果が強く相関している理由です。
タスク別：各モデルが得意とする領域
pass@1 の結果は同点ですが、得意分野の分布図は必ずしも一致していません。GLM-5.3 は構造化された、インタプリタ型の作業を得意とします。具体的には、クエリと設定（88対 72）、言語およびランタイム内部処理（83対 78）、状態保持型リアクション（73対 64）、並行処理と耐久性（62対 45）、そしてプログラム解析（64対 56）です。特に並行処理における 17 ポイントの差は、Fable の最も苦手とする分野を示しています。
これに対し Fable は、厳密な契約を要求される領域で応えます。データモデリングとシリアライズ（88対 79）、ビルドと運用（71対 68）、プロトコル準拠（55対 44）です。これらは GLM の最も弱い分野となります。GLM は 5 つの領域で Fable を上回りますが、Fable が並行処理で示した 45% というスコアこそが、このモデルを完全に排除しないための唯一の要因となっています。
GLM-5.3 と Claude Fable 5 のプログラミング言語別性能
Fable の強みはほぼ Rust に集中しています。Rust における Fable の正答率は 85% で、GLM-5.3 の 70% を上回る 15 ポイントの差があり、両モデルを比較した言語別で最大の開きです。シリアライズ処理が多用されるタスクでは、この強みが特に活きます。
一方、GLM-5.3 は JavaScript で最高水準の 90%（Fable は 75%）を記録し、Go では 76% と 71% でほぼ互角、TypeScript でも 61% と 57% と健闘しています。Python では Fable がわずかに上回る 70% です。
Rust やシリアライズ関連のタスクを除けば、Fable の 5.4 倍という高額な利用料が、実用的な精度の向上に直結する言語は存在しません。
GLM-5.3 と Claude Fable 5 の類似性
両モデルを併用することを検討している方にとって、重要な事実があります。タスクごとの正答率の相関は 0.65 で、今回の比較対象の中で最も高い一致度を示しています。
両モデルとも 88 タスクで成功していますが、GLM-5.3 のみで解決できたのは 11 タスク、Fable のみで解決できたのは 7 タスクです。また、両モデルが失敗したタスクは 7 つあります。ただし、どちらかが正解で他方が不正解という「4 対 0」の極端な不一致は、どの方向にも見られません。
両モデルを合わせたカバー範囲は 113 タスク中 106（93.8%）に及びますが、成功・失敗するタスクがほぼ共通しているため、GPT ファミリーモデルとの組み合わせと比較すると、多様性の向上効果は限定的です。つまり、両者はほぼ代替可能な関係にあるため、コストの低い GLM-5.3 を採用するのが合理的です。
両モデルを併用する際のルーティング戦略
もし両方のモデルを運用する場合、オープンソースモデルである GLM-5.3 をフロントエンドとして使い、テストスイートが回答を拒否した場合のみ Fable へエスカレーションするのが最も経済的です。GLM-5.3 のみでタスクあたりのコストは 10.74 ドル、解決率は 81.1% です。これは Fabe 単体での 69.7% よりも 11 ポイント高く、しかも Fable のタスクあたり価格（21.63 ドル）の半分以下です。
相関係数 0.65 を考慮すると、正直な推奨はシンプルになります。ほとんどの作業において、GLM-5.3 単体で Fable がカバーできる領域のほぼすべてを処理でき、コストは 5 分の 1 です。Fable は Rust やシリアライゼーションといった専門分野に特化した場合のみ、エスカレーション先として価値があります。
この結果が意味するもの
Fable 5 と GLM-5.3 は、最初の試行での精度において統計的な同点です。しかし、その時点で両者の差は終わります。
GLM-5.3 はコストが Fable の約 5.4 分の 1 で、pass@2 や pass@4、カバレッジの観点でも優れています。また、記述量が少なく、回帰テストにおける規律も同等であり、8 つのドメインのうち 5 つで勝利し、ボード上の JavaScript 分野においても最高スコアを記録しています。
Fable は今回測定したモデルの中で最も高価であり、GLM と比較すると 3 つのドメインでのみ勝利し、Rust やシリアライゼーションにおいてわずかな優位性がある程度です。両者の相関が 0.65 と非常に近いため、両方を併用してもポートフォリオとしてのメリットはほとんどありません。実務的な運用としては、GLM-5.3 をデフォルトとし、Rust 依存度が高いタスクやシリアライゼーションの成否がクリティカルな場合にのみ、高コストな Fable を限定的に投入する戦略が適切です。
DeepSWE · Full Results
GLM 5.3 vs Claude Fable 5, metric by metric
| 指標 | GLM 5.3 [max] | Fable 5 [max] |
|---|---|---|
| pass@1 (公式スコアリング) | 69.0% | 69.7% |
| pass@1 (エラーを失敗とみなす) | 68.8% | 67.3% |
| pass@2 / pass@4 | 81.1 / 87.6% | 77.1 / 84.1% |
| カバレッジ / 信頼性 | 87.6 / 78.8% | 84.1 / 82.0% |
| 堅牢 (4/4) / 壁 (0/4) | 48 / 14 | 56 / 18 |
| ロールアウトごとのコスト / 合計 | 1,806 | 9,346 |
| $100 あたり解決数 | 17 | 3 |
| 平均所要時間 / ステップ数 | 35 / 124 | 34 / 85 |
| 平均最大コンテキスト / 出力トークン数 | 155k / 80k | 205k / 114k |
| 失敗の解剖 (近接 / 大幅な見落とし / 回帰) | 61% / 16% / 11% | 57% / 18% / 11% |
| 獲得ドメイン数 (8 中) | 5 | 3 |
| 獲得言語 | 2 (JavaScript, TypeScript) | 3 (Rust はルーティング、Python, Go) |
| タスク別相関 / 和集合 | 0.65 / 113 中 106 (93.8%) | |
| Cascade GLM → Fable (精度 / コスト) | 81.1% / $10.74 (Fabe 単独の場合 69.7% / $21.63) | |
| Oracle 1-shot ルーター | 78.5% | |
| インフラエラー | 1 | 16 |
DeepSWE のタスク 113 件、各設定で 4 回の試行、最大限の努力を尽くした結果、ロールアウトは合計 904 回となりました。
よくある質問（FAQs）
GLM-5.3 は Claude Fable 5 より優れていますか？
DeepSWE の最初の試行では両者の性能に統計的な差は見られませんでした。Fable 5 が pass@1 で 69.7% を記録したのに対し、GLM-5.3 は 69.0% です。しかし、2 回目以降の試行では GLM-5.3 がすべての指標で勝利しています。pass@2 では 81.1%（Fable 5 は 77.1%）、pass@4 では 87.6%（同 84.1%）です。さらに、ロールアウトあたりのコストは GLM-5.3 の方が約 5.4 倍安価で、カバレッジも優れています。ただし、Fable 5 は「4 回連続でタスクを解決する」という点ではわずかに安定しており、成功数は 56 件（GLM-5.3 は 48 件）でした。
GLM-5.3 は Claude Fable 5 よりどれくらい安価ですか？
今回のテストでは、最大限の努力を尽くした設定において、GLM-5.3 のロールアウトあたりのコストは 3.99 ドルでした。一方、Claude Fable 5 は 21.63 ドルで、約 5.4 倍の開きがあります。解決したタスク数で換算すると、GLM-5.3 は 100 ドルあたり 17 件の解決を達成しましたが、Fable 5 はわずか 3 件でした。
コーディングにおいて GLM-5.3 と Claude Fable 5、どちらが優れていますか？
これは使用するプログラミング言語やタスクの種類によります。GLM-5.3 は JavaScript（90 vs 75）、Go（76 vs 71）、TypeScript（61 vs 57）で勝利し、8 つのドメインのうち 5 つを制覇しました。特に並行処理と耐久性の分野では 62 対 45 と大きくリードしています。
一方、Claude Fable 5 は Rust（85 vs 70）、Python（70 vs 66）で優位に立ち、データモデリングやシリアライゼーションを主軸とする厳密な契約ドメインでも 88 対 79 で勝利しています。
GLM-5.3 と Claude Fable 5 の使い分けはすべきか？
限定的な場面でのみ行うべきです。両モデルは、私たちが測定したどの組み合わせよりもタスクごとの相関が高く（0.65）、成功・失敗するタスクがほぼ同じです。そのため、両方を併用すれば 113 タスク中 106 をカバーできます。
GLM-5.3 を優先して呼び出すカスケード方式を採用すると、タスクあたり 10.74 ドルで 81.1% の成功率を達成でき、Fable 単体よりも遥かに優れています。しかし、多くのチームにとって最大のメリットは、デフォルトで GLM-5.3 を使い、Rust 依存度が高いタスクやシリアライズ処理が重要なケースにのみ Fable を割り当てることにあります。
GLM-5.3 はオープンウェイトモデルですか？
はい。GLM-5.3 はオープンウェイトモデルのため、自社サーバーでホストしたり、Together AI などの推論プロバイダーを通じて提供したりすることが可能です。一方、Claude Fable 5 はクローズドなモデルであり、Anthropic およびそのパートナー経由でのみ利用できます。
DeepSWE における pass@k とは？
pass@k は、タスクに対する k 回の試行のうち、少なくとも 1 回が非公開のテストスイートをパスしたかどうかを測る指標です。pass@1 は初回での正解を評価し、より高い k の値は、複数回の試行を通じて最終的に解決策に到達できるモデルを評価します。GLM-5.3 の優位性は、k が増えるほど顕著になります。
手法と留意点
- データ: DeepSWE v1.1 のエクスポートデータを基に、各設定で最大限の試行を行った結果（公式記録）から抽出。113 タスク×4 回試行ずつ、両モデルとも合計 452 回のトライアルを実施しました。
- スコアリング: メインのパス率には DeepSWE の公式スコアリングを採用（included_in_score を基準に、インフラエラーは除外）。Fable はモデルルーティングによるインフラエラーが 16 件発生したため、厳格な「エラー＝失敗」換算では 67.3% となり、公式スコアの 69.7% より低くなります。一方、GLM-5.3 のインフラエラーはわずか 1 件です。
- 評価指標: pass@2、pass@4、カバレッジ率、ユニオン（併合）率、相関値は、各タスクごとのパス数を基に算出しています。
- コスト: 公開されたトライアル単位の cost_usd を使用。Fable のコストは軌跡全体の total_cost_usd と完全に一致しますが、GLM-5.3 はインデックスのみを対象としています。なお、分析時点では GLM-5.3 バッチのターン別軌跡 JSON データはパブリック CDN に存在していませんでした。
- 失敗要因の分析: 公開されたテストごとの失敗率を基に構成。ニアミスとは、ベースラインが維持された状態で新規テストの少なくとも 80% がパスした場合を指し、回帰（レグレッション）とはベースラインテストが破綻したケースです。ドメイン分類にはアーティファクトベースのタスクタクソノミーを採用しました。
- カスケード処理: ベリファイアがエスカレーションの可否と独立性をタスクごとに判断すると仮定します。期待精度は順序に依存しませんが、コストは順序によって変動するため、低コスト側から優先して実行します。相関値 0.65 を考慮すると、ポートフォリオ効果には限界があります。オラクルルーティングとは、各タスクで単一ショットで最高の結果を出すモデルを選ぶもので、あらゆるシングルショットルーターの性能上限を示す指標です。
原文を表示
A statistical tie on the first attempt, and a 5.4x price gap that decides the rest.
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.
- The first attempt is level. Fable 5 posts 69.7% pass@1 and GLM-5.3 posts 69.0%, a 0.7 point gap that sits inside the error bars on both sides.
- GLM-5.3 owns the retries. It leads pass@2 (81.1% vs. 77.1%) and pass@4 (87.6% vs. 84.1%), so it has the higher ceiling as well as the lower price.
- The cost gap is 5.4x. $3.99 per rollout vs. $21.63. Per $100 spent, GLM-5.3 solves 17 tasks and Fable solves 3.
- They are near-substitutes. Per-task correlation is 0.65, the highest agreement in this set, so running both adds little coverage. Keep the lower-cost model and escalate to Fable only for Rust and serialization work.
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
GLM 5.3 vs Claude Fable 5 at a glance
| Model | Pass@1 | Avg cost | Solves / $100 | Out tok | Steps |
|---|---|---|---|---|---|
| glm-5.3 [max] | 69.0% ± 2.7% | $3.99 | 17 | 80k | 124 |
| claude-fable-5 [max] | 69.7% ± 2.3% | $21.63 | 3 | 114k | 85 |
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.
The DeepSWE scoreboard: pass@1 and pass@k
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.
Cost comparison: GLM-5.3 vs. Claude Fable 5 pricing
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.
Coverage vs. reliability: where GLM-5.3 and Fable 5 differ
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.
Failure modes: how each model gets it wrong
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.
Where each wins, by task type
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.
GLM-5.3 vs. Claude Fable 5 by programming language
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.
How similar are GLM-5.3 and Claude Fable 5?
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.
Routing between them: the portfolio play
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.
What it means
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.
DeepSWE · Full Results
GLM 5.3 vs Claude Fable 5, metric by metric
| Metric | GLM 5.3 [max] | Fable 5 [max] |
|---|---|---|
| pass@1 (official scoring) | 69.0% | 69.7% |
| pass@1 (errors as failures) | 68.8% | 67.3% |
| pass@2 / pass@4 | 81.1 / 87.6% | 77.1 / 84.1% |
| Coverage / reliability | 87.6 / 78.8% | 84.1 / 82.0% |
| Solid (4/4) / walls (0/4) | 48 / 14 | 56 / 18 |
| Cost per rollout / total | 1,806 | 9,346 |
| Solves per $100 | 17 | 3 |
| Avg minutes / steps | 35 / 124 | 34 / 85 |
| Avg peak context / output tokens | 155k / 80k | 205k / 114k |
| Failure anatomy (near / big miss / regression) | 61% / 16% / 11% | 57% / 18% / 11% |
| Domains won (of 8) | 5 | 3 |
| Languages won | 2 (JavaScript, TypeScript) | 3 (Rust a rout, Python, Go) |
| Per-task correlation / union | 0.65 / 106 of 113 (93.8%) | |
| Cascade GLM → Fable (accuracy / cost) | 81.1% / $10.74 (vs Fable alone 69.7% / $21.63) | |
| Oracle 1-shot router | 78.5% | |
| Infra errors | 1 | 16 |
113 DeepSWE tasks · 4 trials per config · both at max effort · 904 rollouts total
FAQs
Is GLM-5.3 better than Claude Fable 5?
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.
How much cheaper is GLM-5.3 than Claude Fable 5?
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.
Which is better for coding, GLM-5.3 or Claude Fable 5?
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.
Should I route between GLM-5.3 and Claude Fable 5?
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.
Is GLM-5.3 open weight?
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.
What is pass@k on DeepSWE?
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.
Method and caveats
- Data: DeepSWE v1.1 export, 113 tasks x 4 trials per configuration, both at max effort, from the published per-trial records. 452 trials per side.
- Scoring: headline pass rates use DeepSWE's official scoring (included_in_score, infra errors excluded). Fable has 16 infra errors from model routing, so its strict errors-as-failures score is 67.3 against 69.7 official. GLM-5.3 has 1.
- pass@2, pass@4, coverage, union, and correlation use per-task pass counts.
- Costs are the published per-trial cost_usd. Fable's matches the trajectory total_cost_usd exactly, while GLM's is index-only. Per-turn trajectory JSONs for the GLM-5.3 batch were not on the public CDN at analysis time.
- Failure anatomy uses published per-test fractions. Near miss means at least 80% of new tests pass with the baseline intact. Regression means a baseline test broke. Domains use an artifact-based task taxonomy.
- Cascade assumes a verifier decides escalation and independence given the task. Expected accuracy is symmetric in order, cost is not, so lead with the lower-cost model. Given the 0.65 correlation, portfolio benefit is limited. The oracle router is the per-task best single-shot pick, an upper bound on any one-shot router.
関連記事
News to Guide
ニュースの次に確認する
発表内容を、現在の料金や仕様と照らし合わせられる関連ガイドです。
今日のまとめ
AIデイリーブリーフで今日の重要ニュースをまとめ読み