GLM-5.3 と GPT-5.6 Sol の DeepSWE コスト・コーディング比較
本文の状態
日本語全文を表示中
詳細モードで約18分の本文を読めます。
同じ出来事の情報源
この情報源を基点に整理
Together AI Blog
GLM-5.3 をまず実行し、失敗時に GPT-5.6 Sol にエスカレートする順序でタスクを処理することで、85.9% の成功率と 21% のコスト削減を実現した。
AI深層分析を開く2026年8月22日 14:42
AI深層分析
キーポイント
カスケード戦略の優位性
GLM-5.3 をまず実行し、失敗時に GPT-5.6 Sol にエスカレートする順序でタスクを処理することで、85.9% の成功率と 21% のコスト削減を実現した。
単体モデルの性能比較
GPT-5.6 Sol は 72.7% で単発試行（Pass@1）でわずかに優位だが、GLM-5.3 は再試行回数が増えるにつれて追いつき、4 回目では 87.6% と上回る結果を示した。
コスト効率の劇的改善
100 ドルあたりの解決タスク数は GLM-5.3 が 17 件に対し GPT-5.6 Sol は 9 件であり、GLM-5.3 の単価は約半分であるため、コストパフォーマンスが圧倒的に高い。
モデルの特性と補完性
両モデルの相関は低く（0.43）、互いに異なる 106 のタスクをカバーしており、この多様性がカスケード戦略の成功要因となっている。
試行回数による性能逆転
単一試行では GPT-5.6 Sol が優位だが、複数回試行を許容すると GLM-5.3 の成功率が逆転し、4 回目には 87.6% で Sol を上回る。
重要な引用
Sol wins the first try, GLM-5.3 wins the rest at half the price, and the cascade beats both: 85.9% at $6.61 a task.
Don't pick one. Run GLM-5.3 first, escalate to GPT-5.6 Sol when the tests fail.
At two attempts GLM-5.3 (81.1%) already ties Sol (81.0%); at four, GLM-5.3's 87.6% pass@4 leads 85.8%.
Sol is the precision corner: 84.5% reliability and 61 tasks solved four for four... GLM-5.3 trades to the other axis: wider coverage at 87.6% against 85.8%, but lower reliability at 78.8%.
編集コメントを表示
編集コメント
単一モデルの性能比較だけでなく、複数モデルを組み合わせる戦略の有効性を定量的に示した点は実務において非常に示唆に富む。特に GLM-5.3 の再試行時の強みとコスト優位性が明確になったことで、開発リソース配分の見直しを促す内容となっている。
Source Article
元記事を日本語で読む
本文に関係しない購読案内、埋め込み通知、サイト内プロモーションは除いています。
Sol が最初の試行で勝利し、GLM-5.3 が残りの試行を半額で制し、さらに両者を上回るカスケード方式が 1 タスクあたり 6.61 ドルで 85.9% の成功率を達成しました。
主なポイント
モデルは一つに絞らず、GLM-5.3 をまず試し、テスト失敗時に GPT-5.6 Sol にエスカレーションするのが正解です。このカスケード方式により、DeepSWE のタスク 85.9% が 1 タスクあたり 6.61 ドルで解決されます。一方、Sol 単独では 72.7%（1 タスクあたり 8.37 ドル）です。成功率は 13 ポイント高く、コストは 21% 安くなります。
- Sol はシングルショット（1 回試行）で僅差の勝利を収めました。GLM-5.3 の 69.0% に対し、72.7% の pass@1 を記録し、3.7 ポイントの差は標準偏差の数値内に収まる範囲です。
- GLM-5.3 はその後の再試行で全勝しました。pass@2 では Sol と同率（81.1% vs 81.0%）となり、pass@4 では 87.6% で Sol の 85.8% を上回ります。
- コスト差は 2.1 倍です。GLM-5.3 はロールアウトあたり 3.99 ドルに対し、Sol は 8.37 ドルです。100 ドルあたりの解決数は、GLM-5.3 が 17 タスク、Sol が 9 タスクとなります。
- Sol の方が高速かつ安定しています。1 ロールアウトあたり 19 分・61 ステップに対し、GLM は 35 分・124 ステップです。また、GLM は 61 タスク中 4 つを完遂し、Sol は 48 タスクでした。
- GLM-5.3 の失敗はクリーンです。失敗時の 11% で既に合格していたテストが破綻しますが、Sol ではその割合が 20% です。回帰バグに対する Sol の差分にはゲート処理が必要です。
- 両モデルの相関は低く（タスクあたり 0.43）、合わせて 113 タスク中 106 をカバーします。この補完性がカスケード方式を機能させる鍵となっています。
113 の DeepSWE タスクすべてにおいて、GLM-5.3（max）と GPT-5.6 Sol（max）を比較検証しました。各モデルとも 4 回ずつ試行し、公開された個別の試行記録に基づき合計 904 回のロールアウト（452 回ずつ）を実施しています。
Sol は精度に特化したフラッグシップモデルです。一方、GLM-5.3 はオープンウェイトで登場した挑戦者であり、両者の差を縮める成果を残しました。
以下のすべての数値は今回の検証結果に基づくものであり、他の公開されている GLM-5.3 と GPT-5.6 Sol のスコアカードとは異なる可能性があります。
DeepSWE · 直接対決
GLM 5.3 vs GPT 5.6 Sol 概観
| モデル | Pass@1 | 平均コスト | $100 あたり解決数 | 出力トークン数 | ステップ数 |
|---|---|---|---|---|---|
| glm-5.3 [max] | 69.0% ± 2.7% | $3.99 | 17 | 80k | 124 |
| gpt-5.6-sol [max] | 72.7% ± 2.2% | $8.37 | 9 | 60k | 61 |
DeepSWE ベンチマークにおいて、GPT-5.6 Sol は依然としてシングルショット（1 回の試行）での王者の座を維持しています。これは多様なタスク種別やプログラミング言語にわたってモデルのソフトウェアエンジニアリング能力を評価するベンチです。一方、GLM-5.3 は価格が半額で、単発スコアでは Sol よりもわずかに 4 ポイント低い 69.0% を記録しましたが、複数回の試行を許容するとすぐに逆転します。
これはオープンモデルが最先端に迫った最も近い事例であり、Sol のプレミアム機能に実際にどのような価値があるのかという問いが重要になります。
DeepSWE のスコアボード：pass@1 と pass@k
シングルショットでは Sol がわずかに先行し、公式スコアリング下で 72.7%（GLM-5.3 は 69.0%）を記録しました。しかし、再試行が可能になると順位は逆転します。
2 回の試行では GLM-5.3 の 81.1% が Sol の 81.0% と同率となり、4 回では GLM-5.3 の 87.6% が Sol の 85.8% を上回ります。オープンモデルの方が適用範囲が広いため、k 回の試行から最良の結果を選ぶ設定ではより正確な選択肢となります。しかも追加の試行にかかるコストは、Sol の半分です。
コスト比較：GLM-5.3 と GPT-5.6 Sol の価格
1 回の実行あたり GLM-5.3 は 3.99 ドルで、Sol（8.37 ドル）より約 2.1 倍安いです。価値換算では、100 ドルあたりの解決件数が Sol の 9 件に対し、GLM-5.3 は 17 件となります。
その分、Sol はレイテンシで優位性があります。平均実行時間は GLM-5.3 の 35 分・124 ステップに対して、Sol は 19 分 61 ステップです。生成トークン数も Sol が 60k で、GLM-5.3 は 80k です。
このトレードオフは非常に明確です。Sol は高速で簡潔な作業員であり、GLM-5.3 は時間がかかるものの低コストな選択肢です。人間が待機している場合は、レイテンシの短さだけで Sol の高価格に見合う価値があります。一方、予算制約やバッチキューを優先する場合は、GLM-5.3 がより賢い選択となります。
カバレッジと信頼性：精度 versus 到達範囲
pass@1 と pass@4 を分解して考えると、カバレッジ（4 回の試行で少なくとも 1 回解決したタスクの割合）と信頼性（4 回の試行すべてで解決したタスクの割合）という 2 つの軸が見えてきます。
Sol は「精度」の側を担います。信頼性は 84.5% で、4 回中 4 回成功したタスク数は 61 件です。これは、触れた課題を確実に解決するモデルの特徴を示しています。
一方、GLM-5.3 はもう一方の軸、「カバレッジ」に重点を置きます。カバレッジは 87.6% と Sol の 85.8% を上回りますが、信頼性は 78.8% と低く、4 回中 4 回成功したタスク数も 48 件と Sol より少ないです。
このカバレッジでの優位性は、pass@4 におけるリードと同じ事実を裏付けています。GLM-5.3 はベンチマークのより多くの課題にアプローチしますが、1 回の試行あたりの成功率は少し低くなっています。
失敗モード：各モデルがどのように間違えるか
失敗のパターンは明確に異なり、その傾向はオープンソースモデルに有利です。Sol は失敗事例の 20% でリポジトリ内の既存テストスイートを破綻させますが、これは GPT ファミリー特有の回帰バグの特徴です。一方、GLM-5.3 ではこの割合が 11% に抑えられています。GLM-5.3 がミスをする場合でも、多くの場合は「ほぼ成功」に留まります。つまり、ベースラインを維持したままわずかに外れるケースが多く、その確率は 61% に達します（Sol は 54%）。つまり、コストが低いモデルほど、厳格な回帰テストなしで採用しても安全だと言えます。Sol の出力を取り込む前には必ずフル回帰テストを実行すべきですが、GLM-5.3 にはそのほどのガードレールは必要ありません。
タスク別：各モデルが得意とする領域
得意分野の分布は、両モデルとも 4 つずつで拮抗しています。Sol はデータモデリングとシリアライゼーション（92%）、ビルドおよび運用ツール（73%）、並行処理と耐久性（72%）、プロトコル適合性（59%）を得意としています。これらは厳密な契約に基づく、システム寄りの作業です。一方、GLM-5.3 はクエリ言語や設定言語（88%、全項目で最高値）、言語およびランタイムの内部実装（83%）、ステートフルなリアクション（73%）、そしてプログラム解析（64% で Sol と同率）を得意としています。これらは構造化された、インタプリタ型の作業です。GLM-5.3 の明確な弱点はプロトコル適合性で 44% に留まり、Sol よりも 15 ポイント低いです。Sol には特定の弱点となる分野はなく、全体的に高いパフォーマンスを発揮しています。なお、各タスクの分類は、ベンチマークのプロンプトを基に LLM が自動で行ったものです。
プログラミング言語別に見る GLM-5.3 と GPT-5.6 Sol の性能差
GLM-5.3 が特に際立っているのは JavaScript です。解決率が 90% に達し、Sol の 75% を 15 ポイントも上回っています。これは現在利用可能なモデルの中で最も高い数値です。Rust においても GLM-5.3 は 70% で Sol の 60% を引き離しています。
一方、Sol が優位性を示すのは Python（74% vs 66%）、Go（79% vs 76%）、そして TypeScript（66% vs 61%）です。これらの結果を踏まえたルーティングルールはシンプルです。JavaScript と Rust のタスクには GLM-5.3 を割り当て、それ以外は Sol に任せるという方針です。GLM-5.3 はコストが低く、かつほぼ全ての分野で Sol に匹敵する性能を発揮します。
GLM-5.3 と GPT-5.6 Sol、その違いはルーティングに活かせるか？
両者の性能差は十分に明確で、タスクに応じた振り分けが可能です。個別のタスクにおける相関関係は 0.43 です。これは全体として非常に近い性能を持つ二つのモデルとしては、実質的な不一致があることを示しています。
両モデルともに 90 のタスクを解決していますが、GLM-5.3 が単独で解決したのは 9 タスク、Sol が単独で解決したのは 7 タスクでした。また、両者とも失敗したタスクは 7 つあります。両者の能力を合わせれば、113 タスク中 106 タスク（93.8%）をカバーできます。
興味深いのは、この不一致が一方に偏っている点です。GLM-5.3 は Sol が一度も正解に至らなかった 2 つのタスクで、4 回連続して完全解決しています（具体的には koota-pair-relation-tracking と participle-grammar-conflict-analysis）。逆に、Sol が GLM-5.3 を凌駕したケースはありません。つまり、オープンソースモデルである GLM-5.3 は、フラッグシップモデルが到達できない領域にも足を踏み入れているのです。
両者の使い分け：ポートフォリオ戦略としての最適解
この性能差と価格の組み合わせが、ボード上でも最も優れた選択肢となります。まずは GLM-5.3 を実行し、テストスイートで回答が却下された場合のみ Sol へエスカレーションするのがベストです。この構成では、タスクあたりのコストは 6.61 ドルで解決率が 85.9% に達します。
これは Sol 単独の 72.7% よりも 13 ポイント高く、Sol を一度だけ実行するコスト（8.37 ドル）よりも安価です。その理由は、オープンソースモデルがキューの大半を Sol の半額で処理し、残りの難問に対して Sol が独立した第 2 の試行として機能するためです。
さらにこのカスケード構成は、完璧な一発判定型ルーティング（83.8%）よりも優れています。なぜなら、2 回の独立した試行の方が、1 回の完璧な選択よりも確実だからです。最終的な精度がどちらのモデルを先頭にするかで変わらない場合でも、GLM を先に使う方がコストは抑えられます（6.61 ドル対 9.47 ドル）。したがって、低コスト側から始めるのが正解です。
何が示唆されているか
GPT-5.6 Sol は、単一試行での成功率という王冠を維持しています。これに伴い、初回成功率が最も高く、信頼性も抜群です。さらに、圧倒的に高速で、実行結果も簡潔です。ただし、その代償としてコストは約 2 倍になり、20% に及ぶ性能低下（レジッション）への対策が必要です。
一方、GLM-5.3 は「コストパフォーマンス」と「複数試行による最適解」の選択肢です。初回成功率では Sol と 4 ポイント以内の差しかなく、pass@2 や pass@4、カバレッジ率においては Sol を上回っています。価格は半額で、失敗のパターンもよりクリーンです。特に JavaScript 関連の実装において、GLM-5.3 は現在のところ最高水準を誇ります。
Sol に対する GLM-5.3 の明確な弱点は、プロトコルへの準拠性と純粋な処理速度です。しかし、両モデルの特性が本質的に異なるため、最も効果的な導入方法はどちらか一方に絞ることではありません。GLM-5.3 を低コストのフロントエンドとして使い、Sol を検証ゲート付きのエスカレーション（上級処理）担当とするハイブリッド構成が最適解です。これにより、フラッグシップモデル単体でタスクを処理するよりも安価に、かつそれを凌駕するカバレッジ率を実現できます。
DeepSWE · 完全な結果はこちら
GLM 5.3 vs GPT 5.6 Sol：指標別比較
| 指標 | GLM 5.3 [max] | GPT 5.6 Sol [max] |
|---|---|---|
| pass@1 (公式スコアリング) | 69.0% | 72.7% |
| pass@1 (エラーを失敗とみなす) | 68.8% | 72.3% |
| pass@2 / pass@4 | 81.1 / 87.6% | 81.0 / 85.8% |
| カバレッジ / 信頼性 | 87.6 / 78.8% | 85.8 / 84.5% |
| 堅牢 (4/4) / 壁 (0/4) | 48 / 14 | 61 / 16 |
| ロールアウトごとのコスト / 合計 | 1,806 | 3,783 |
| $100 あたり解決数 | 17 | 9 |
| 平均所要時間 / ステップ数 | 35 / 124 | 19 / 61 |
| 平均最大コンテキスト / 出力トークン数 | 155k / 80k | 187k / 60k |
| 失敗の解剖 (惜しいところ / 後退) | 61% / 11% | 54% / 20% |
| 勝利したドメイン (8 件中) | 4 | 4 |
| 勝利した言語 | 2 (JavaScript, Rust) | 3 (Python, Go, TypeScript) |
| タスクごとの相関 / 和集合 | 0.43 / 113 中 106 (93.8%) | |
| Cascade GLM → Sol (精度 / コスト) | 85.9% / $6.61 (Sol 単独の場合 72.7% / $8.37) | |
| Oracle 1-shot ルーター | 83.8% | |
| インフラエラー | 1 | 2 |
113 件の DeepSWE タスク、各設定で 4 回の試行、どちらも最大限の努力を払った結果、ロールアウトは合計 904 回でした。
よくある質問
GLM-5.3 は GPT-5.6 Sol より優れているのでしょうか？
評価指標によります。GPT-5.6 Sol は DeepSWE における単一試行の品質で勝利し、pass@1 は 72.7%（対 GLM-5.3 の 69.0%）です。また、4 回試行した際のタスク解決数も 61 件と GLM-5.3 の 48 件を上回り、ロールアウトあたりの処理速度も約 2 倍速いです。一方、GLM-5.3 は pass@2 で同率となり、pass@4 では 87.6%（対 GPT-5.6 Sol の 85.8%）で上回ります。さらにロールアウトあたりのコストは半分以下です。したがって、大量処理や再試行を許容するエージェントワークにおいては、GLM-5.3 がより優れたコストパフォーマンスの選択肢と言えます。
GLM-5.3 は GPT-5.6 Sol よりどれくらい安価なのでしょうか？
今回の実験では、最大限の努力を払った場合、GPT-5.6 Sol のロールアウトあたりのコストが 8.37 ドルであるのに対し、GLM-5.3 は 3.99 ドルでした。これは約 2.1 倍の差です。解決したタスク数で換算すると、GLM-5.3 は 100 ドルあたり 17 件の解決を達成し、GPT-5.6 Sol の 9 件を上回ります。つまり、ドルあたりの生産性は約 2 倍高いのです。
コーディングにおいては GLM-5.3 と GPT-5.6 Sol、どちらが優れているのでしょうか？
得意分野は分かれています。GLM-5.3 は JavaScript（90 対 75）と Rust（70 対 60）で勝利し、GPT-5.6 Sol は Python（74 対 66）、Go（79 対 76）、TypeScript（66 対 61）で上回りました。タスクのドメイン別に見ると、双方とも 4 つずつ勝利しています。GPT-5.6 Sol は厳密な契約要件やシステム関連の作業でリードし、GLM-5.3 はクエリ言語、設定言語、ランタイム内部の実装、そして状態管理を伴うリアクション処理で優位に立っています。
GLM-5.3 と GPT-5.6 Sol の使い分けはすべきか？
結果を検証できるなら、両モデルを組み合わせるメリットがあります。両者は相関が 0.43 と低く、失敗するパターンも異なるため、まずは GLM-5.3 を実行し、テストスイートで出力が却下された場合に GPT-5.6 Sol に切り替えるというフローを採用すると、1 タスクあたり 6.61 ドルで達成率 85.9% を記録できます。これは Sol モデル単体（72.7%、8.37 ドル）や、完璧な一発オラクルルーティング（83.8%）を上回る結果です。両モデルを併用することで、113 タスク中 106 タスクをカバーできます。
DeepSWE における pass@k とは？
pass@k は、与えられたタスクに対して k 回の試行のうち、少なくとも 1 回が非公開のテストスイートをパスしたかどうかを測定する指標です。pass@1 は「初回で正解すること」を評価しますが、k の値が大きくなるほど、「複数回の試行を経て最終的に解決に至る能力」を重視するようになります。GLM-5.3 の優位性は、k が増えるにつれて顕著になります。
手法と留意点
- データ: DeepSWE v1.1 のエクスポートデータを基に、各設定で最大限の試行（4 回）を行った 113 タスクの結果を使用しました。両モデルとも最大努力で実行され、公開された試行ごとの記録から抽出しています。左右合わせて計 452 回の試行が行われました。
- スコアリング: ヘッドラインでのパス率は DeepSWE の公式スコアリング（included_in_score を採用し、インフラエラーは除外）に基づいています。GLM-5.3 と Sol 2 はそれぞれインフラエラーを 1 つずつ発生させていますが、その影響は小さく、公式スコアと厳格なスコアの値はほぼ一致しています。pass@2、pass@4、カバレッジ率、ユニオン、相関などは、タスクごとのパス数を基に算出しました。
- コスト: 公開されたインデックスの cost_usd をそのまま使用しています。GLM-5.3 バッチのターンごとの軌跡データ（JSON）は分析時点ではパブリック CDN に存在しなかったため、本分析はインデックスレベルでの評価に限られています。
- 失敗の構造: 公開されたテストごとの失敗率を基に分析しています。「ニアミス」は、ベースラインが維持された状態で新規テストの少なくとも 80% がパスした場合と定義します。一方、「回帰（regression）」とは、ベースラインで通っていたテストが新たに失敗した場合を指します。ドメイン分類には、アーティファクトベースのタスク分類体系を採用しました。
- カスケード処理: ベリファイアがタスクに応じてエスカレーションを判断し、独立性を保つことを前提としています。期待される精度は順序に依存しない対称的な性質を持ちますが、コストは非対称です。そのため、低コスト側のモデルを先に配置する構成とします。オラクルルーターは、各タスクに対して単一ショットで最適なモデルを選定するものであり、あらゆるシングルショットルーターの性能上限を示す指標となります。
原文を表示
Sol wins the first try, GLM-5.3 wins the rest at half the price, and the cascade beats both: 85.9% at $6.61 a task.
Key Takeaways
Don't pick one. Run GLM-5.3 first, escalate to GPT-5.6 Sol when the tests fail. That cascade solves 85.9% of DeepSWE tasks at $6.61 each. Sol alone solves 72.7% at $8.37. Thirteen points better, 21% cheaper.
- Sol wins the single shot, narrowly. 72.7% pass@1 against GLM-5.3's 69.0%, a 3.7 point gap that sits inside a couple of standard deviations.
- GLM-5.3 wins every retry after that. It ties Sol at pass@2 (81.1 vs. 81.0) and leads pass@4 (87.6% vs. 85.8%).
- The price gap is 2.1x. $3.99 per rollout against $8.37. Per $100 spent, GLM-5.3 solves 17 tasks and Sol solves 9.
- Sol is faster and steadier: 19 minutes and 61 steps per rollout against GLM's 35 and 124, with 61 tasks solved four for four against 48.
- GLM-5.3's failures are cleaner. It breaks tests that already passed in 11% of its failures, against 20% for Sol. Gate Sol's diffs on regressions.
- The two diverge (0.43 per-task correlation) and cover 106 of 113 tasks between them, which is what makes the cascade work.
We ran GLM-5.3(max) against GPT-5.6 Sol (max) on all 113 DeepSWE tasks, four trials each, from the published per-trial records: 904 rollouts in total, 452 per side. Sol is the precision flagship. GLM-5.3 is the open-weight challenger that closed the gap. Every figure below comes from this run, so it can differ from other public GLM-5.3 vs. GPT-5.6 Sol scorecards.
DeepSWE · Head to Head
GLM 5.3 vs GPT 5.6 Sol 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 |
| gpt-5.6-sol [max] | 72.7% ± 2.2% | $8.37 | 9 | 60k | 61 |
GPT-5.6 Sol still holds the single-shot crown on DeepSWE, a benchmark that tests a model's software engineering ability across many task types and programming languages. GLM-5.3 arrives less than four points behind it at half the price and pulls ahead the moment you allow more than one attempt. This is the closest the open tier has come to the frontier, and the question worth answering is what Sol's remaining premium actually buys.
The DeepSWE scoreboard: pass@1 and pass@k
Single shot, Sol edges ahead: 72.7% pass@1 to GLM-5.3's 69.0% under DeepSWE's official scoring. Allow retries and the order flips. At two attempts GLM-5.3 (81.1%) already ties Sol (81.0%); at four, GLM-5.3's 87.6% pass@4 leads 85.8%. The open model has the wider reach, so in any best-of-k setting it is the more accurate choice, and its extra attempts cost half of Sol's.
Cost comparison: GLM-5.3 vs. GPT-5.6 Sol pricing
At $3.99 a rollout, GLM-5.3 is 2.1x cheaper than Sol ($8.37), which in value terms is 17 solves per $100 against Sol's 9. Sol buys that premium back on latency: an average 19 minutes and 61 steps against GLM's 35 minutes and 124 steps, with 60k output tokens to GLM's 80k. The tradeoff is unusually clean. Sol is the faster, terser worker; GLM-5.3 is the lower-cost one that takes the long route. If a human is waiting, Sol earns its premium on latency alone. If a budget or a batch queue is waiting, GLM-5.3 is the better buy.
Coverage vs. reliability: precision vs. reach
Decompose pass@1 and pass@4 into coverage (tasks solved at least once across four tries) and reliability (tasks solved on all four), and the split is clean. Sol is the precision corner: 84.5% reliability and 61 tasks solved four for four, the marks of a model that lands what it touches. GLM-5.3 trades to the other axis: wider coverage at 87.6% against 85.8%, but lower reliability at 78.8% and fewer solid tasks, 48 against 61. That coverage edge is the same fact as its pass@4 lead. GLM-5.3 touches more of the benchmark than Sol and converts each touch a little less often per shot.
Failure modes: how each model gets it wrong
The failure profiles differ sharply, and the split favors the open model. Sol breaks the repository's existing test suite in 20% of its failures, the GPT-family regression signature. GLM-5.3 does so in 11%; when it misses, it usually misses forward, a near miss with the baseline intact, at a 61% near-miss rate against Sol's 54%. So the lower-cost model is also the safer one to accept without a heavy regression gate. Put a full regression run around Sol before you take its diff. GLM-5.3 needs that guardrail less.
Where each wins, by task type
The domain map splits evenly, four each. Sol takes data modeling and serialization (92%), build and ops tooling (73%), concurrency and durability (72%), and protocol conformance (59%), which is the exact-contract, systems-heavy work. GLM-5.3 takes query and config languages (88%, the highest single cell on the board), language and runtime internals (83%), stateful reactivity (73%), and program analysis, a 64 to 64 tie it holds on volume. That is the structured, interpreter-style work. GLM-5.3's one clear hole is protocol conformance at 44%, 15 points behind Sol. Sol has no single weak domain; it is simply strong across the board. Task types here were classified by an LLM from each benchmark prompt.
GLM-5.3 vs. GPT-5.6 Sol by programming language
GLM-5.3's standout is JavaScript at 90%, 15 points clear of Sol's 75 and the best JS number of any model on the board. It also takes Rust, 70 to 60. Sol answers with Python (74 to 66), Go (79 to 76), and TypeScript (66 to 61). The routing rule is simple: JavaScript and Rust to GLM-5.3, the rest to Sol, with GLM-5.3 a lower-cost and close second almost everywhere.
How different are GLM-5.3 and GPT-5.6 Sol?
Different enough to route on. Per-task correlation is 0.43, real disagreement for two models this close on aggregate. They both solve 90 tasks; GLM-5.3 alone gets 9, Sol alone gets 7, and 7 defeat both. Their union covers 106 of 113 tasks (93.8%), and the hard disagreements run one way: GLM-5.3 sweeps two tasks four for four that Sol never lands (koota-pair-relation-tracking, participle-grammar-conflict-analysis), while Sol sweeps none that GLM-5.3 zeros. The open model reaches places the flagship does not.
Routing between them: the portfolio play
That divergence plus the price makes the cascade the best row on the board. Run GLM-5.3 first and escalate to Sol only when your test suite rejects the answer: 85.9% solved at $6.61 per task. That is thirteen points above Sol alone (72.7%) and still cheaper than one Sol rollout ($8.37), because the open model clears most of the queue at half of Sol's price and the hard remainder gets a second independent attempt. The cascade also beats a perfect one-shot oracle router (83.8%), because two independent attempts beat one perfect pick. Expected accuracy is the same whichever model leads, but GLM-first is cheaper ($6.61 against $9.47), so lead with the lower-cost model.
What it means
GPT-5.6 Sol keeps the single-shot crown and the things that come with it: the highest first-try rate, the highest reliability, and by far the fastest and most concise runs. You pay roughly double for that, and you must guardrail its 20% regression rate. GLM-5.3 is the value and best-of-k pick: within four points on the first shot, ahead on pass@2, pass@4, and coverage, at half the price, with a cleaner failure profile and the best JavaScript on the board. Its real weaknesses against Sol are protocol conformance and raw speed. And because the two genuinely diverge, the sharpest deployment is neither alone. It is GLM-5.3 as a lower-cost front end with Sol as the verifier-gated escalation, which lands flagship-beating coverage for less than the flagship's own per-task price.
DeepSWE · Full Results
GLM 5.3 vs GPT 5.6 Sol, metric by metric
| Metric | GLM 5.3 [max] | GPT 5.6 Sol [max] |
|---|---|---|
| pass@1 (official scoring) | 69.0% | 72.7% |
| pass@1 (errors as failures) | 68.8% | 72.3% |
| pass@2 / pass@4 | 81.1 / 87.6% | 81.0 / 85.8% |
| Coverage / reliability | 87.6 / 78.8% | 85.8 / 84.5% |
| Solid (4/4) / walls (0/4) | 48 / 14 | 61 / 16 |
| Cost per rollout / total | 1,806 | 3,783 |
| Solves per $100 | 17 | 9 |
| Avg minutes / steps | 35 / 124 | 19 / 61 |
| Avg peak context / output tokens | 155k / 80k | 187k / 60k |
| Failure anatomy (near miss / regression) | 61% / 11% | 54% / 20% |
| Domains won (of 8) | 4 | 4 |
| Languages won | 2 (JavaScript, Rust) | 3 (Python, Go, TypeScript) |
| Per-task correlation / union | 0.43 / 106 of 113 (93.8%) | |
| Cascade GLM → Sol (accuracy / cost) | 85.9% / $6.61 (vs Sol alone 72.7% / $8.37) | |
| Oracle 1-shot router | 83.8% | |
| Infra errors | 1 | 2 |
113 DeepSWE tasks · 4 trials per config · both at max effort · 904 rollouts total
FAQs
Is GLM-5.3 better than GPT-5.6 Sol?
It depends on the metric. GPT-5.6 Sol wins single-attempt quality on DeepSWE (pass@1 72.7% against 69.0%), solves more tasks four for four (61 against 48), and is roughly twice as fast per rollout. GLM-5.3 ties pass@2 and wins pass@4 (87.6% against 85.8%) at half the cost per rollout, so it is the stronger value pick for high-volume or retry-tolerant agent work.
How much cheaper is GLM-5.3 than GPT-5.6 Sol?
In our run, GLM-5.3 cost $3.99 per rollout against $8.37 for GPT-5.6 Sol at max effort, about 2.1x lower. Measured per solved task, GLM-5.3 returned 17 solves per $100 against Sol's 9, roughly twice the solved work per dollar.
Which is better for coding, GLM-5.3 or GPT-5.6 Sol?
They split the board. GLM-5.3 takes JavaScript (90 against 75) and Rust (70 against 60); Sol takes Python (74 against 66), Go (79 against 76), and TypeScript (66 against 61). By task domain it is four wins each: Sol leads the exact-contract and systems work, GLM-5.3 leads query and config languages, runtime internals, and stateful reactivity.
Should I route between GLM-5.3 and GPT-5.6 Sol?
Yes, if you can verify results. The two diverge (0.43 correlation) and fail differently, so running GLM-5.3 first and escalating to Sol when your test suite rejects the output reaches 85.9% at $6.61 per task, beating Sol alone (72.7% at $8.37) and a perfect one-shot oracle router (83.8%). Together the two cover 106 of 113 tasks.
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 first try; 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 by 4 trials per config, 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). GLM-5.3 has 1 infra error and Sol 2, so official and strict scoring nearly coincide. pass@2, pass@4, coverage, union, and correlation use per-task pass counts.
- Costs are the published per-trial cost_usd from the index. Per-turn trajectory JSONs for the GLM-5.3 batch were not on the public CDN at analysis time, so this analysis is index-level.
- Failure anatomy uses published per-test fractions. A near miss is at least 80% of new tests passing with the baseline intact; a regression means a baseline test broke. Domains use an artifact-based task taxonomy.
- The 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. The oracle router is the per-task best single-shot pick, an upper bound on any one-shot router.
関連記事
News to Guide
ニュースの次に確認する
発表内容を、現在の料金や仕様と照らし合わせられる関連ガイドです。
今日のまとめ
AIデイリーブリーフで今日の重要ニュースをまとめ読み