DEV Community: Jenny Met

Claude Opus 5 vs GPT-5.6 Luna：速度順位を使わない18問の正確性ベンチマーク

Jenny Met — Thu, 30 Jul 2026 00:50:02 +0000

先に結論

高難度ラウンドでは Claude Opus 5 が 17/18（94.4%）、GPT-5.6 Luna が 16/18（88.9%）でした。差は1問であり、Opusが常に上という証明ではありません。重要なのは失敗の形です。Opusは3本のアルゴリズムをそのまま実行できる形で納品した一方、厳密JSONで余計な囲みを付けました。Lunaは3つの形式指示をすべて守りましたが、2本のPythonファイルがimport時に停止しました。

なぜ問題を難しくしたのか

最初の8問は両モデルとも8/8で、差が出ませんでした。そこで第2ラウンドを18問に増やし、6分野それぞれに hard、harder、extreme を配置しました。正確な分数、多段階の物理モデル、完全なPythonファイル、誤った前提の拒否、一意な制約解、文字単位の出力形式を要求しています。説明が巧みかどうかではなく、決定的な主張を計算、JSONパース、Python実行で確認できるかを評価しました。

18問をどう採点したか

同一の問題文、system指示、temperature、問題別の出力予算を使いました。数学と物理は厳密値または数値許容差で検証し、コードは回答のまま保存して共通のhidden testへimportしました。JSONとCSVは「意味が通る」ではなく、機械入力として合格するかで判定しています。モデル自身のassertを削除すれば動く場合も、原因分析には使いますが初回納品を合格へ変更しません。回線遅延は生JSONにだけ残し、勝敗には一切使っていません。

6分野の結果

評価分野	Opus 5	GPT-5.6 Luna
数学的推論	3/3	3/3
複雑な物理	3/3	3/3
アルゴリズム納品	3/3	1/3
誤った前提への耐性	3/3	3/3
制約推論	3/3	3/3
指示遵守	2/3	3/3
Total	17/18 (94.4%)	16/18 (88.9%)

アルゴリズム差は「納品物」の差だった

Lunaが失敗した2問は、末尾の自己テストを外すと関数本体がhidden testを通過しました。しかし自己テストの期待値が誤っており、元ファイルはimport時にAssertionErrorを起こします。「完全なPythonファイル」という契約では失敗です。Opusの3ファイルは元のままimportと共通テストに通りました。本番では、正しそうな関数と、そのまま利用できる成果物を分けて考える必要があります。

厳密JSONではLunaが優位

Opusの唯一の失敗は逆方向でした。JSONのキーと値は正しいのに、「JSONオブジェクトだけ」という指示に反してMarkdownのコードフェンスを追加しました。独立再試行でも同じです。Lunaは指示遵守3問をすべて通過しました。出力を直接パーサーへ渡す処理では、囲みの有無も正確性の一部です。

出力予算と知能上の誤りを分離

初期試行の一部は、内部推論が出力予算を使い切りfinish_reason=lengthになりました。これは証拠として保存しましたが、知能の誤りには数えていません。両モデルの有効予算を同条件で増やしてから採点したためです。ただし、長い推論で可視成果物の領域が不足するという統合上のリスクは残ります。

本番ルーティングへの落とし込み

厳密JSON、CSV、短い抽出、大量の構造化処理はLunaを第一候補にしつつ、schema検証を必須にします。長いアルゴリズム、境界条件、防御的な実装はOpusを第一候補にします。数学、複雑な物理、誤前提、制約推論は本サンプルで同点なので、価格、API互換性、文章量で選ぶ方が合理的です。どちらでもJSONをparseし、数値を照合し、コードを回答のまま実行してください。

再現方法と生データ

実行スクリプトはscripts/opus5_vs_luna_hard_benchmark.py、全結果は.tmp/opus5-vs-luna-hard-benchmark-results.jsonです。独立再試行は.tmp/opus5-hard-failure-retry.jsonと.tmp/luna-hard-failure-retry.jsonにあります。APIはhttps://cn.crazyrouter.com/v1/chat/completionsを使用し、遅延値は生データでのみ確認できます。

よくある質問

17/18ならOpus 5が総合勝者ですか？

いいえ。この18問では1問リードした、という意味です。画像、ツール利用、超長文脈、複数ターンのagentは対象外です。

誤った自己テストをアルゴリズム失敗に含める理由は？

要求が完全なPythonファイルだからです。元ファイルがimportで落ちるなら、人手で直さずに利用できません。

なぜ速度を結論に入れないのですか？

遅延はモデルだけでなく、ゲートウェイ、上流負荷、経路状態にも左右されます。運用証拠としては有用でも、知能の正確性とは別です。

最終評価

検証可能な正確性を優先した本テストでは、アルゴリズム3問を完全納品したOpus 5が 17/18 対 16/18で1問リードしました。一方、厳密な指示遵守はLunaが上です。結論は万能の勝者ではなく、再現可能な失敗傾向に基づく使い分けです。

Crazyrouterで両モデルを実際のプロンプトに通して比較する

Claude Opus 5 frente a GPT-5.6 Luna: 18 pruebas verificables, sin ranking de velocidad

Jenny Met — Thu, 30 Jul 2026 00:45:32 +0000

Respuesta rápida

En la ronda difícil, Claude Opus 5 obtuvo 17/18 (94,4%) y GPT-5.6 Luna 16/18 (88,9%). Es una ventaja de una tarea en esta muestra, no una prueba de superioridad universal. Lo importante es el tipo de fallo: Opus entregó correctamente los tres archivos algorítmicos, pero rompió un contrato de JSON estricto; Luna cumplió las tres instrucciones de formato, aunque dos archivos de Python fallaron al importarse.

Por qué fue necesario subir la dificultad

La primera ronda de ocho tareas fue demasiado sencilla para separar a los modelos: ambos consiguieron 8/8. La segunda pasó a 18 tareas, con variantes hard, harder y extreme en seis categorías. Se exigieron fracciones exactas, modelos físicos por etapas, archivos ejecutables completos, rechazo de premisas engañosas, soluciones lógicas únicas y disciplina de salida carácter por carácter. Una explicación convincente no bastaba: cada afirmación decisiva debía poder verificarse con cálculo, parsing de JSON o ejecución de Python.

Cómo se puntuaron las 18 tareas

Los dos modelos recibieron el mismo enunciado, instrucción de sistema, temperature y presupuesto por tarea. Matemáticas y física se validaron contra valores exactos o tolerancias numéricas. El código se guardó tal como llegó y se importó en el mismo harness de pruebas ocultas. JSON y CSV se evaluaron como artefactos para máquinas. Que un archivo funcione después de borrar sus propios assert ayuda a diagnosticar el fallo, pero no convierte la entrega original en un aprobado. La latencia de ruta se conserva solo en el JSON original y no participa en ninguna decisión de ganador.

Resultados en seis dimensiones

Dimensión	Opus 5	GPT-5.6 Luna
Razonamiento matemático	3/3	3/3
Física compleja	3/3	3/3
Entrega de algoritmos	3/3	1/3
Rechazo de premisas falsas	3/3	3/3
Razonamiento con restricciones	3/3	3/3
Seguimiento de instrucciones	2/3	3/3
Total	17/18 (94.4%)	16/18 (88.9%)

La diferencia algorítmica fue una diferencia de entrega

En los dos fallos de Luna, las funciones principales superaron las pruebas ocultas después de eliminar los assert del final. El problema era que esos assert contenían resultados esperados incorrectos y el archivo original lanzaba AssertionError durante el import. Bajo un contrato de “archivo Python completo”, son fallos reales. Los tres archivos originales de Opus se importaron y superaron el mismo harness. En producción, una función plausible no equivale a un artefacto listo para integrar.

En JSON estricto, la ventaja cambió de lado

El único fallo de Opus fue casi el reflejo contrario. Las claves y los valores eran correctos, pero el modelo envolvió el objeto en un bloque Markdown pese a que se pedía exactamente un objeto JSON, sin nada más. El comportamiento se repitió en un segundo intento independiente. Luna aprobó las tres pruebas de instrucciones. Cuando la salida entra directamente en un parser, el envoltorio también forma parte de la corrección.

El presupuesto de salida se separó de los errores de inteligencia

Algunos intentos iniciales terminaron con finish_reason=length porque el razonamiento oculto consumió el presupuesto de salida. Se conservaron como evidencia, pero no se contaron como errores de inteligencia. Antes de puntuar se aumentó de forma equivalente el presupuesto efectivo de ambos modelos. Así se evita confundir configuración con razonamiento, sin ocultar el riesgo de integración de una respuesta que deja poco espacio al artefacto visible.

Cómo convertir los resultados en reglas de routing

Empieza con Luna para JSON estricto, CSV, extracción corta y trabajo estructurado de gran volumen, manteniendo siempre validación de esquema. Empieza con Opus para archivos algorítmicos largos, casos límite e ingeniería defensiva. En matemáticas, física compleja, rechazo de premisas falsas y restricciones hubo empate; en esas áreas, coste, compatibilidad y estilo de salida son mejores criterios. Con ambos modelos hay que validar el artefacto: parsear JSON, comprobar números clave y ejecutar el código sin limpiarlo a mano.

Reproducción y evidencia original

El runner es scripts/opus5_vs_luna_hard_benchmark.py. El resultado completo está en .tmp/opus5-vs-luna-hard-benchmark-results.json; los reintentos independientes están en .tmp/opus5-hard-failure-retry.json y .tmp/luna-hard-failure-retry.json. Se usó el endpoint limpio https://cn.crazyrouter.com/v1/chat/completions. Las latencias permanecen únicamente en los archivos de evidencia.

Preguntas frecuentes

¿17/18 convierte a Opus 5 en ganador absoluto?

No. Solo significa que lideró por una tarea en este conjunto. No se evaluaron visión, herramientas, contexto ultralargo ni agentes de varios turnos.

¿Por qué cuentan como fallo unas autopruebas incorrectas?

Porque se pidió un archivo Python completo. Si el original falla al importarse, un sistema posterior no puede usarlo sin reparación manual.

¿Por qué la latencia no aparece en el veredicto?

Depende del modelo, el gateway, la carga upstream y el estado de la ruta. Es evidencia operativa útil, pero no mide la precisión intelectual.

Veredicto final

En esta prueba centrada en precisión verificable, Opus 5 lideró 17/18 a 16/18 gracias a la entrega completa de los tres algoritmos. Luna fue mejor en cumplimiento estricto de formato. La conclusión práctica no es un campeón universal, sino una regla de routing basada en fallos reproducibles.

Prueba ambos modelos en Crazyrouter con tus propios prompts de producción

Claude Opus 5 vs GPT-5.6 Luna: 18 Verifiable Tasks, No Speed Leaderboard

Jenny Met — Thu, 30 Jul 2026 00:42:45 +0000

Quick answer

Claude Opus 5 scored 17/18 (94.4%) and GPT-5.6 Luna scored 16/18 (88.9%) on the harder round. That is a one-task lead in this sample—not proof that Opus is universally stronger. The useful result is the shape of the failures: Opus delivered all three algorithm files successfully but broke a strict JSON contract; Luna followed all three formatting instructions but shipped two algorithm files that failed during import.

Why the benchmark had to become harder

The first eight tasks were too easy to separate the models: both scored 8/8. The second round therefore used 18 tasks, with hard, harder, and extreme variants in each of six categories. The questions required exact fractions, multi-stage physical modeling, executable files, resistance to misleading assumptions, unique logical solutions, and byte-level output discipline. The goal was not to reward impressive prose. Every decisive claim had to be checked by deterministic rules, independent calculations, JSON parsing, or Python execution.

How the 18-task round was scored

Both models received the same task text, system instruction, temperature, and task-level output budget. Mathematical and physics answers were checked against exact values or numerical tolerances. Algorithm responses were saved as delivered and imported into the same hidden-test harness. Strict JSON and CSV tasks were validated as artifacts, not read charitably. A file that only works after deleting model-written assertions is useful diagnostic evidence, but it is not a successful first delivery. Route latency was retained in the raw JSON for infrastructure diagnosis and was excluded from every winner decision in this article.

Results across six dimensions

Dimension	Opus 5	GPT-5.6 Luna
Mathematical reasoning	3/3	3/3
Complex physics	3/3	3/3
Algorithm delivery	3/3	1/3
False-premise resistance	3/3	3/3
Constraint reasoning	3/3	3/3
Instruction following	2/3	3/3
Total	17/18 (94.4%)	16/18 (88.9%)

The algorithm gap was a delivery gap

Luna's two failed algorithm answers contained core functions that passed hidden tests after their own bottom-of-file assertions were removed. The problem was that the assertions encoded incorrect expected values, so importing the original files raised AssertionError before a caller could use the functions. Under a strict complete-file contract, those are failures. Opus's three original algorithm files imported and passed the shared harness. This distinction matters in production: a plausible function body is not the same thing as a deployable artifact.

The strict-JSON failure points in the other direction

Opus's only hard-round failure was almost the mirror image. The JSON keys and values were correct, but the model wrapped the object in a Markdown code fence even though the instruction required exactly one JSON object and nothing else. The same behavior reappeared in the independent retry. Luna returned valid strict output in all three instruction-following tasks. If your pipeline feeds model output directly into a parser, wrapper discipline is part of correctness, not a cosmetic preference.

Output budgets were separated from intelligence errors

Some early responses ended with finish_reason=length because hidden reasoning consumed the available output budget. Those attempts were preserved, but they were not counted as intelligence failures. The same effective budget was increased for both models before scoring. This avoids confusing capacity configuration with reasoning quality while still documenting a real integration risk: long reasoning can leave too little room for the visible artifact.

What this means for production routing

Use Luna first for strict JSON, CSV, short extraction, and high-volume structured work—but keep schema validation. Use Opus first for long algorithm files, defensive engineering, and tasks where the complete executable artifact matters more than brevity. For math, complex physics, false-premise resistance, and constraint reasoning, this sample was a tie, so cost, interface compatibility, and output style are better routing variables. In every case, validate the task artifact: parse JSON, check key numbers, and run generated code exactly as received.

Reproduction and raw evidence

The benchmark runner is scripts/opus5_vs_luna_hard_benchmark.py. The complete hard-round result is .tmp/opus5-vs-luna-hard-benchmark-results.json; independent failure retries are in .tmp/opus5-hard-failure-retry.json and .tmp/luna-hard-failure-retry.json. The API endpoint used was https://cn.crazyrouter.com/v1/chat/completions. Latency fields remain in those raw files for route diagnosis only.

FAQ

Does 17/18 make Opus 5 the overall winner?

No. It gives Opus a one-task lead on this specific 18-task set. The sample does not cover vision, tools, long-context retrieval, or multi-turn agents.

Why count faulty self-tests as algorithm failures?

Because the requested deliverable was a complete Python file. If the original file crashes on import, downstream systems cannot use it without manual repair.

Why is latency absent from the verdict?

Latency reflects the model, gateway route, upstream load, and channel state. It is valuable operational evidence but not a reliable measure of intelligence correctness.

Final verdict

In this correctness-first benchmark, Opus 5 led 17/18 to 16/18 because it delivered all algorithm artifacts successfully. Luna was stronger at strict instruction compliance. The practical conclusion is not a universal champion; it is a routing rule backed by reproducible failure modes.

Run both models through Crazyrouter with your own production prompts

Claude Opus 5 vs GPT-5.6-SOL: 프로덕션 QA로 검증한 10개 과제, 핵심 정확도는 동률

Jenny Met — Thu, 30 Jul 2026 00:25:45 +0000

Claude Opus 5 vs GPT-5.6-SOL: 프로덕션 QA로 검증한 10개 과제, 핵심 정확도는 동률

모델을 프로덕션에 투입할 때는 최종 답만 맞는다고 충분하지 않다. 응답이 중간에 잘리지 않았는지 finish_reason을 확인해야 하고, 생성된 코드는 실제 숨은 테스트를 통과해야 하며, JSON은 설명이나 코드 블록 없이 바로 파싱할 수 있어야 한다.

이번 비교에서는 Crazyrouter의 동일한 OpenAI-compatible endpoint를 통해 Claude Opus 5와 GPT-5.6-SOL에 10개의 지능 과제를 수행하게 했다. 별도로 엄격한 JSON 출력 과제를 추가해 지시 준수와 구조화 출력 안정성도 확인했다.

평가는 다음 질문에 초점을 맞췄다.

수학 답과 물리 모델이 정확한가?
잘못된 전제나 불충분한 통계적 결론을 식별하는가?
생성한 Python 코드가 숨은 테스트를 통과하는가?
문제에 포함된 모든 하위 요구 사항을 빠짐없이 완료하는가?
JSON 응답을 별도 정제 없이 바로 파싱할 수 있는가?
finish_reason이 정상 종료를 나타내는가?

결과는 단순한 승패보다 프로덕션 QA 관점에서 해석할 가치가 있다.

핵심 답변 정확도: Opus 5 10/10, GPT-5.6-SOL 10/10
모든 하위 요구 사항까지 완전히 완료: Opus 5 9/10, GPT-5.6-SOL 10/10
Python 알고리즘 과제의 숨은 테스트: 두 모델 모두 2/2
엄격한 JSON 최초 제출: Opus 5 0/1, GPT-5.6-SOL 1/1
Opus 5는 이후 두 번의 추가 재시도에서도 JSON 외의 텍스트를 덧붙여 형식 요구를 충족하지 못했다.

따라서 이번 결과는 핵심 정확도는 동률이지만, 완전한 과제 납품과 구조화 출력의 안정성은 동일하지 않았다고 정리하는 것이 정확하다.

API Key를 만들고 실제 업무 문제로 재검증하기

빠른 답변

질문	이번 테스트 결과
핵심 지능 과제의 답은 어느 쪽이 더 정확했나?	동률: 두 모델 모두 10/10
모든 하위 요구 사항을 더 많이 완료한 모델은?	GPT-5.6-SOL 10/10, Opus 5 9/10
코드 신뢰성은 어느 쪽이 더 높았나?	이번에는 동률. 두 알고리즘 과제 모두 숨은 테스트 통과
Opus 5가 어려운 확률 문제를 틀렸나?	아니다. 핵심 답은 정확했지만 `max_tokens=3200`에서 출력이 잘려 마지막 설명 요구를 누락했다.
엄격한 JSON 지시를 더 안정적으로 지킨 모델은?	이번에는 GPT-5.6-SOL. Opus 5는 최초 응답과 추가 재시도 2회, 총 3회 모두 추가 텍스트 또는 코드 블록을 포함했다.
이 결과로 GPT가 전반적으로 더 똑똑하다고 할 수 있나?	아니다. 핵심 추론 정확도와 형식·지시 준수는 분리해 평가해야 한다.
응답 속도도 평가했나?	아니다. 네트워크와 라우팅 영향을 분리할 수 없어 지능 점수에서 제외했다.

수학·물리·알고리즘의 핵심 정확성이 중요한 업무라면 이번 표본에서 두 모델 간 뚜렷한 격차는 없었다. 반면 응답 본문이 반드시 순수 JSON이어야 하거나, 단 한 번의 응답에서 모든 하위 요구 사항을 완료해야 한다면 이번 테스트에서는 GPT-5.6-SOL의 납품 완성도가 더 높았다.

네트워크 지연 시간을 지능 점수에서 제외한 이유

모델 API의 종단 간 응답 시간에는 모델의 추론 능력 외에도 여러 변수가 개입한다.

게이트웨이에서 각 상위 공급자까지의 네트워크 경로
요청 시점의 채널 부하와 계정별 속도 제한
캐시 적중 여부
실제로 요청을 처리한 서비스 인스턴스
상위 공급자가 reasoning token을 집계하거나 숨기는 방식

단일 요청이 몇 초 더 빨랐다는 사실은 모델의 추론 능력이 더 우수하다는 증거가 아니다. 그것은 네트워크 상태나 라우팅 결과, 순간적인 서버 부하를 측정한 것일 수 있다.

속도를 비교하려면 최소한 동일한 상위 공급자와 실행 조건을 고정하고, 충분한 횟수로 반복한 뒤 분산과 신뢰구간을 함께 보고해야 한다. 이번 테스트에는 그런 조건이 마련되지 않았으므로 네트워크 지연 시간을 지능 점수에서 명시적으로 제외했다.

따라서 이 글은 어떤 모델도 속도 승자로 선정하지 않는다. 지연 시간은 운영 관측 지표로는 유용하지만, 이번과 같은 지능 정확도 평가에 혼합하면 결과를 왜곡할 수 있다.

현재 제공되는 모델과 접속 범위는 Crazyrouter 모델 목록에서 확인할 수 있다. 비용 계획은 지능 평가와 분리해 Crazyrouter pricing을 참고해야 한다.

테스트 환경과 채점 기준

테스트 전 모델 목록 API를 호출해 정확한 모델 ID 두 개가 노출되는지 확인했다.

GET https://cn.crazyrouter.com/v1/models

claude-opus-5
gpt-5.6-sol

실제 요청에는 다음 endpoint를 공통으로 사용했다.

POST https://cn.crazyrouter.com/v1/chat/completions

각 테스트 배치에서 두 모델에 동일한 system prompt, user prompt, temperature, max_tokens를 적용했다. 외부 도구는 사용하지 않았으며, HTTP 200 응답만으로 과제 통과를 판정하지 않았다.

채점은 세 단계로 나눴다.

핵심 답변 정확도

주요 수치, 결론, 알고리즘 동작이 정확한지 평가했다.
완전한 과제 통과율

문제에 명시된 모든 하위 요구 사항을 빠짐없이 완료했는지 확인했다.
기계 검증 가능성

코드는 숨은 테스트를 통과하는지, JSON은 별도 정제 없이 직접 파싱되는지 검사했다.

자동 문자열 채점 후에는 사람이 다시 검토했다. LaTeX 표현, 대소문자, 정확한 분수와 반올림된 소수의 차이 때문에 거짓 음성이 발생할 수 있기 때문이다.

예를 들어 GPT-5.6-SOL은 확률 문제에서 기준 답안의 분수 표현을 그대로 복사하지 않았지만 동치인 수식과 정확한 소수를 제시했다. Opus 5는 물리 문제의 0.302 m를 유효숫자 두 자리인 0.30 m로 썼지만, 이를 오답으로 볼 근거는 없다.

10개 지능 과제 결과

과제	검증 기준	Claude Opus 5	GPT-5.6-SOL
정확한 마르코프 연쇄	`E[τ]=5`, `E[τ²]=43`, `Var(τ)=18`	정확	정확
2자유도 진동자	고유진동수 2개, 진폭 2개, 위상 2개	정확	정확
제약 조건 탐색	유일한 순서 `A,C,E,B,D`	정확	정확
Cantelli 오류 수정	확률은 식별 불가능하며 상한은 `0.2`	정확	정확
Python 순환 탐지 검토	bug, DAG 반례, 최소 수정	정확	정확
실험 설계	동일 문제 짝짓기, 난이도 통제, 신뢰구간	정확	정확
편향 동전의 `HHTH` 대기 시간	기댓값 약 `12.6547`과 올바른 상태 전이	핵심 답은 정확하나 출력이 잘려 마지막 설명 누락	정확하고 완전함
로그 집계 알고리즘	시간 구간, 실패 이벤트, 캐시 비율, 상위 사용자	숨은 테스트 통과	숨은 테스트 통과
비탄성 충돌과 용수철	`v1≈6.10`, `v2≈2.44`, `x≈0.302`	정확	정확
안정적 라우팅 알고리즘	cost, latency, reliability와 사전식 순서 규칙	숨은 테스트 통과	숨은 테스트 통과

이 표에서 가장 중요한 구분은 핵심적으로 맞았는가와 요구된 결과를 완전히 납품했는가가 서로 다른 평가 항목이라는 점이다.

Opus 5는 10개 과제의 핵심 답을 모두 맞혔다. 그러나 확률 문제에서 마지막 설명 하나가 누락되어 완전한 과제 통과율은 9/10이었다. GPT-5.6-SOL은 핵심 정확도와 완전한 과제 통과율이 모두 10/10이었다.

가장 어려운 확률 문제: `12.6547`은 맞았지만 응답은 완전하지 않았다

문제의 목표 패턴은 HHTH이며 편향 동전의 확률은 다음과 같다.

P(H)=0.62
P(T)=0.38

문제는 최장 접두사·접미사 일치 상태를 사용해 방정식을 세우고, 다음 두 가지 함정을 명시적으로 설명하도록 요구했다.

상태 HH에서 다시 H가 나왔을 때 왜 상태가 여전히 HH인가?
기대 대기 시간을 왜 단순히 1/P(HHTH)로 계산할 수 없는가?

두 모델 모두 올바른 기대 대기 시간을 계산했다.

E[N] ≈ 12.6547

GPT-5.6-SOL은 전체 유도를 완료했고, 패턴에 중첩이 존재하므로 다음 관계가 성립한다고 설명했다.

E[N] = 1 / P(HHTH) + 1 / P(H)

Opus 5도 올바른 상태 정의, 방정식, 정확한 분수와 소수 결과를 제시했다. 하지만 응답의 최종 상태는 finish_reason=length였다. 출력이 부가적인 상태별 기대값을 설명하던 중 종료되면서, 마지막 요구 사항인 “왜 확률의 역수를 직접 사용하면 안 되는가”에 대한 설명이 빠졌다.

이때 적용해야 할 채점 원칙은 명확하다.

최종 수치가 정확하면 핵심 답변 정확도에는 포함할 수 있다. 그러나 문제의 모든 요구 사항을 완료하지 않았다면 완전한 과제 통과로 처리할 수 없다.

이 응답에는 max_tokens=3200이 적용됐다. 따라서 프로덕션에서는 답변 본문만 저장해서는 안 된다. 최소한 원문 응답, finish_reason, 사용한 출력 예산을 함께 기록해야 한다. 앞부분이 정확하다는 이유만으로 전체 작업이 완료됐다고 판단해서는 안 된다.

이는 기존의 max_tokens 잘림 재검증에서도 확인할 수 있는 동일한 방법론적 문제다.

실행 가능한 코드 검증: 코드 모양이 아니라 숨은 테스트로 평가

코드 생성 결과는 길이, 주석의 양, 함수 분리 방식만 보고 평가하기 어렵다. 보기 좋은 코드가 반드시 정확한 코드는 아니며, 짧은 구현도 모든 경계 조건을 만족할 수 있다.

이번 테스트에서는 두 모델이 생성한 출력을 각각 .py 파일로 저장하고 격리 모드에서 동일한 테스트를 실행했다.

로그 집계 알고리즘

로그 집계 함수는 다음 조건을 모두 처리해야 했다.

반개방 시간 구간
성공 요청과 실패 요청에 서로 다른 집계 규칙 적용
사용자 또는 모델 값이 누락된 이벤트
cache hit rate
cost가 같을 때 사용자 이름의 사전식 순서 적용
입력 객체를 변경하지 않는 불변성

두 모델의 구현 모두 숨은 테스트를 통과했다.

신뢰성 제약이 있는 안정적 라우팅

두 번째 함수는 경로 탐색 과정에서 다음 조건을 함께 처리해야 했다.

총비용이 가장 낮은 경로 선택
비용이 같으면 latency가 가장 낮은 경로 선택
latency까지 같으면 reliability가 가장 높은 경로 선택
모든 조건이 같으면 경로의 사전식 순서로 선택
banned nodes 처리
최대 hops 제한
최소 reliability 제한
잘못된 edge 처리

두 모델 모두 이 과제의 숨은 테스트를 통과했다.

따라서 코드 부문의 결과는 두 모델 모두 2/2로 동률이다. 코드가 더 길거나 설명이 더 상세하다는 이유로 별도의 우승 모델을 정하지 않았다.

GPT-5.6-SOL의 다른 고난도 물리·의존성 알고리즘 결과는 GPT-5.6-SOL vs GPT-5.5 고난도 물리 및 코드 테스트에서 확인할 수 있다.

엄격한 JSON: 계산 정확도와 지시 준수를 분리해서 봐야 한다

별도의 엄격한 JSON 과제에서는 사고 데이터를 하나의 객체로 압축하되 다음 조건을 지키도록 요구했다.

exactly one JSON object and no Markdown

두 모델 모두 실패율, 장애 책임 채널, 재시도 후 복구되지 않은 요청 수를 정확하게 계산했다. 차이는 JSON 바깥의 출력에서 발생했다.

GPT-5.6-SOL은 첫 시도에 JSON만 반환했고 json.loads로 직접 파싱할 수 있었다.
Opus 5는 첫 시도에 코드 블록과 Verification을 추가했다.
Opus 5의 첫 번째 추가 재시도에서는 압축된 JSON 뒤에 Verification을 덧붙였다.
Opus 5의 두 번째 추가 재시도에서는 다시 코드 블록과 설명을 추가했다.

수치로 정리하면 엄격한 JSON 최초 제출은 GPT-5.6-SOL 1/1, Opus 5 0/1이다. Opus 5는 그 뒤 두 번 더 재시도했지만 계속 형식 요구를 충족하지 못했다.

이는 “계산을 못했다”는 의미가 아니다. Opus 5가 생성한 필드와 값은 정확했다. 실패 원인은 데이터 오류가 아니라 출력 형식과 지시 준수다.

이 차이를 핵심 지능 정확도에 섞어 하나의 총점으로 만들면 다음 두 문제를 구분할 수 없게 된다.

모델이 올바른 값을 계산했는가?
모델이 지정된 구조만 출력했는가?

프로덕션에서는 최소한 다음과 같은 로컬 검증기를 둘 수 있다.

import json

REQUIRED_KEYS = [
    "window",
    "total_requests",
    "failed_requests",
    "failure_rate_pct",
    "provider_owned_failures",
    "customer_owned_failures",
    "recovered_by_retry",
    "unrecovered_failures",
    "root_cause",
    "action",
]


def parse_incident_json(raw: str) -> dict:
    payload = json.loads(raw)
    if list(payload) != REQUIRED_KEYS:
        raise ValueError("unexpected schema or key order")
    if payload["failed_requests"] != 84:
        raise ValueError("failed request count mismatch")
    return payload

system prompt만으로 구조화 출력을 보장할 수는 없다. 더 안전한 구성은 다음 세 요소를 함께 적용하는 것이다.

공급자가 지원하는 구조화 출력 매개변수 사용
응답에 대한 로컬 schema 검증
파싱 또는 검증 실패 시 재시도하거나 다른 모델로 전환

즉, 구조화 출력은 프롬프트 작성만의 문제가 아니라 애플리케이션 계층의 검증 문제다.

같은 API로 재검증하는 방법

다음은 OpenAI-compatible chat completions endpoint를 사용하는 최소 실행 예제다. API endpoint 자체에는 UTM 매개변수를 추가하지 않는다.

import os
import requests

BASE_URL = "https://cn.crazyrouter.com/v1"
API_KEY = os.environ["CRAZYROUTER_API_KEY"]


def ask(model: str, prompt: str, max_tokens: int = 4000) -> dict:
    response = requests.post(
        f"{BASE_URL}/chat/completions",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json",
        },
        json={
            "model": model,
            "messages": [
                {"role": "system", "content": "Answer accurately and follow every requested constraint."},
                {"role": "user", "content": prompt},
            ],
            "temperature": 0.2,
            "max_tokens": max_tokens,
        },
        timeout=600,
    )
    response.raise_for_status()
    return response.json()


for model in ("claude-opus-5", "gpt-5.6-sol"):
    result = ask(model, "Your benchmark prompt here")
    choice = result["choices"][0]
    print(model, choice.get("finish_reason"), choice["message"].get("content", ""))

실제 회귀 테스트에서는 답변 텍스트뿐 아니라 다음 항목도 함께 저장하는 편이 좋다.

response ID
returned model
원본 응답
finish_reason
요청에 사용한 max_tokens
로컬 검증 결과
코드 테스트 또는 schema 검증의 실패 원인

현재 모델이 노출되는지는 Crazyrouter 모델 목록에서 확인한 뒤, 실제 업무 prompt로 소규모 회귀 테스트를 진행할 수 있다.

프로덕션 도입을 위한 QA 지침

두 모델 모두 후보로 고려할 수 있는 작업

명확한 기준 답안이 있는 수학·물리 문제
단위 테스트를 실행할 수 있는 Python 알고리즘
잘못된 전제나 불충분한 통계 결론을 식별하는 작업
로컬 검증기로 성공 여부를 판정할 수 있는 업무 흐름

이번 10개 과제에서 두 모델 모두 핵심 정확도 10/10을 기록했고, 코드 과제의 숨은 테스트도 각각 2/2를 통과했다. 따라서 검증 가능한 작업이라면 두 모델 모두 후보군에 포함할 근거가 있다.

이번 결과에서 GPT-5.6-SOL을 우선 검토할 수 있는 작업

모든 하위 요구 사항을 한 번의 응답에서 완료해야 하는 작업
응답 원문이 반드시 순수 JSON이어야 하는 연동
설명문에서 구조화 데이터를 다시 추출하는 후처리를 줄여야 하는 시스템

이 판단은 GPT-5.6-SOL의 핵심 추론 정확도가 더 높았다는 뜻이 아니다. 두 모델의 핵심 정확도는 동일한 10/10이었다. 차이는 이번 표본에서 확인된 완전한 과제 납품과 JSON 형식 준수에 있다.

Opus 5를 사용할 때 추가할 보호 장치

긴 유도 과정에는 충분한 max_tokens 할당
모든 응답에서 finish_reason 검사
JSON을 하위 시스템에 전달하기 전에 반드시 파싱
추가 Markdown, 코드 블록, 설명 텍스트가 포함됐을 때의 명시적 대체 경로 구성
잘림이나 schema 위반 시 재시도 또는 모델 전환
핵심 정답과 전체 요구 사항 완료 여부를 별도로 기록

Opus 5의 확률 문제는 핵심 계산이 틀린 사례가 아니다. max_tokens=3200 경계에서 finish_reason=length로 끝나면서 마지막 설명이 누락된 사례다. 이를 추론 오류로 분류하면 원인을 잘못 진단하게 된다.

Claude 계열 내부의 납품 특성을 추가로 비교하려면 Claude Opus 5 vs Claude Fable 5 실제 API 테스트를 참고할 수 있다.

프로덕션 체크리스트

모델을 실제 시스템에 연결할 때는 단일 “정답률” 대신 다음 항목을 개별적으로 수집하는 것이 좋다.

[ ] 핵심 답변이 정확한가?
[ ] 모든 하위 요구 사항을 완료했는가?
[ ] finish_reason이 예상한 종료 상태인가?
[ ] 응답이 max_tokens 경계에서 잘리지 않았는가?
[ ] JSON이 json.loads로 직접 파싱되는가?
[ ] 필수 키, 자료형, 값 범위가 schema와 일치하는가?
[ ] 생성된 코드가 공개 테스트뿐 아니라 숨은 테스트도 통과하는가?
[ ] 입력 객체의 불변성과 경계 조건을 지키는가?
[ ] 실패 시 재시도 또는 모델 전환 경로가 있는가?
[ ] 네트워크 지연 시간과 지능 정확도를 별도 지표로 기록하는가?

FAQ

Claude Opus 5와 GPT-5.6-SOL 중 어느 모델이 더 똑똑한가?

이번 10개 과제에서는 두 모델 모두 핵심 답변 정확도 10/10을 기록했다. 따라서 이 결과만으로 어느 한쪽이 전반적으로 더 똑똑하다고 결론 내릴 수 없다.

완전한 과제 통과율은 왜 동률이 아닌가?

Opus 5의 고난도 확률 문제 응답이 max_tokens=3200에서 잘렸기 때문이다. 기대값 12.6547과 상태 방정식은 정확했지만, 마지막 설명 요구를 완료하지 못했고 finish_reason=length가 반환됐다. 따라서 핵심 정확도에는 포함되지만 완전한 과제 통과에는 포함되지 않는다.

핵심 정확도와 완전한 과제 납품은 어떻게 다른가?

핵심 정확도는 주요 수치, 결론, 알고리즘 동작이 맞는지를 평가한다. 완전한 과제 납품은 여기에 더해 문제에서 요구한 모든 설명, 형식, 하위 항목까지 빠짐없이 제공했는지를 평가한다. 정답을 계산했더라도 마지막 설명이나 필수 필드가 빠지면 완전한 납품은 아니다.

엄격한 JSON 실패를 지능 오류로 봐야 하나?

수학 또는 추론 오류로 직접 분류해서는 안 된다. Opus 5는 JSON의 필드와 값을 정확하게 계산했지만 JSON 외의 코드 블록이나 Verification 설명을 추가했다. 따라서 더 정확한 분류는 형식 및 지시 준수 실패다.

Opus 5는 JSON 재시도에서 성공했나?

아니다. 최초 응답은 엄격한 JSON 기준에서 0/1이었고, 이후 두 번의 추가 재시도에서도 JSON 뒤의 Verification 또는 코드 블록과 설명을 추가했다. 즉, 총 3회 모두 순수 JSON만 반환하라는 요구를 지키지 못했다.

두 코드 과제는 어떻게 평가했나?

각 모델의 출력을 Python 파일로 저장하고 동일한 숨은 테스트를 실행했다. 테스트에는 경계 조건, 정렬 규칙, 잘못된 입력, 입력 불변성 등이 포함됐다. 두 모델 모두 두 과제를 통과해 각각 2/2를 기록했다.

왜 응답 속도 승자를 발표하지 않았나?

종단 간 응답 시간은 네트워크 경로, 채널 부하, 캐시, 상위 공급자 상태, 라우팅된 인스턴스 등에 영향을 받는다. 동일한 상위 환경을 고정하고 충분히 반복하지 않은 단일 지연 시간은 지능 정확도를 나타내지 않는다. 그래서 이번 점수에서는 네트워크 지연 시간을 제외했으며 속도 승자를 정하지 않았다.

`finish_reason`을 반드시 검사해야 하는 이유는 무엇인가?

본문에 올바른 답이 포함돼 있어도 응답이 중간에 끝났을 수 있기 때문이다. 이번 Opus 5 사례처럼 finish_reason=length이면 핵심 답을 계산한 뒤에도 마지막 요구 사항이 누락될 수 있다. 프로덕션에서는 본문과 함께 finish_reason을 성공 판정 조건에 포함해야 한다.

10개 과제만으로 장기 모델을 선정해도 되나?

충분하지 않다. 이번 결과는 작지만 재현 가능한 능력 표본이다. 실제 도입 전에는 업무 문제를 20–50회 반복해 핵심 정확도, 완전한 과제 통과율, 코드 테스트 통과율, 형식 위반률을 각각 집계하는 것이 좋다.

자체 모델 비교는 어떻게 시작해야 하나?

실제 업무를 대표하는 prompt 10–30개를 먼저 선정하고, 각 문제에 기계적으로 실행 가능한 통과 기준을 정의해야 한다. 이후 동일한 API 조건으로 두 모델에 같은 입력을 보내고 결과를 비교한다. 결론을 먼저 정한 뒤 그 결론을 뒷받침하는 사례만 선택해서는 안 된다.

구조화 출력은 prompt만 잘 쓰면 보장할 수 있나?

보장할 수 없다. 명확한 system prompt와 user prompt는 필요하지만 충분하지 않다. 가능하면 공급자의 구조화 출력 기능을 사용하고, 로컬 schema 검증과 파싱 실패 시 재시도 또는 모델 전환을 함께 구성해야 한다.

최종 결론

이번 테스트의 핵심은 어느 한 모델을 단순 승자로 선언하는 것이 아니다. 프로덕션에서는 핵심적으로 맞는 답을 생성하는 능력과 요구한 형식과 모든 하위 항목을 완전하게 납품하는 능력을 분리해 검증해야 한다.

Claude Opus 5와 GPT-5.6-SOL은 10개 지능 과제에서 모두 핵심 답변 정확도 10/10을 기록했다. GPT-5.6-SOL은 모든 하위 요구 사항에서 10/10, 엄격한 JSON 최초 제출에서 1/1을 기록했다. Opus 5는 하위 요구 사항 완료에서 9/10, 엄격한 JSON 최초 제출에서 0/1이었으며 두 번의 추가 재시도에서도 형식 요구를 충족하지 못했다.

Opus 5의 차이는 핵심 추론 실패가 아니었다. 고난도 확률 문제에서는 정답 12.6547을 계산했지만 max_tokens=3200 경계에서 finish_reason=length로 종료돼 마지막 설명이 빠졌다. JSON 과제에서도 데이터는 정확했지만 출력 외피가 요구 형식과 달랐다.

따라서 기준 답안이나 숨은 테스트를 운영할 수 있는 업무라면 두 모델 모두 후보가 될 수 있다. 반면 하위 시스템이 모델의 JSON을 직접 소비한다면 다음 요소는 선택 사항이 아니라 필수 구성 요소로 봐야 한다.

finish_reason 검사
구조화 출력 schema 검증
코드의 실제 실행 및 숨은 테스트
출력 잘림 감지
형식 위반 시 재시도
필요할 때의 모델 전환

그리고 네트워크 지연 시간은 지능 점수와 분리해야 한다. 이번 테스트에는 속도 승자가 없으며, 확인된 차이는 핵심 정확도가 아니라 완전한 과제 납품과 구조화 출력 준수에 있다.

Crazyrouter 계정을 만들고 Opus 5 / GPT-5.6-SOL을 직접 테스트하기

Claude Opus 5 против GPT-5.6-SOL: проверка на 10 задачах — по точности основных ответов ничья

Jenny Met — Thu, 30 Jul 2026 00:25:29 +0000

Claude Opus 5 против GPT-5.6-SOL: проверка на 10 задачах — по точности основных ответов ничья

Что именно означает «модель умнее» — быстрее отвечает, правильно решает задачу или строго соблюдает формат?

В этом сравнении скорость намеренно не учитывается. Вместо нее оцениваются критерии, которые можно независимо проверить: правильность математических результатов, полнота физической модели, прохождение локальных тестов кода, распознавание ошибочных предпосылок и выполнение всех требований задания.

Обе модели получили одинаковые условия через один OpenAI-compatible endpoint Crazyrouter. Основной набор состоял из 10 задач; строгое соблюдение JSON проверялось отдельно.

Результаты:

точность основных ответов: Claude Opus 5 — 10/10, GPT-5.6-SOL — 10/10;
полное выполнение всех подпунктов: Claude Opus 5 — 9/10, GPT-5.6-SOL — 10/10;
скрытые тесты двух задач на Python: обе модели — 2/2;
строгий JSON с первой попытки: Claude Opus 5 — 0/1, GPT-5.6-SOL — 1/1;
в двух дополнительных попытках Opus по-прежнему добавлял к JSON посторонний текст или оформление.

Итог нельзя свести к одному общему баллу: по правильности основных рассуждений модели выступили одинаково, но по полноте и формату ответа — по-разному.

Создать API Key и повторить тестирование на собственных задачах

Краткий ответ

Вопрос	Результат теста
Какая модель точнее решила основные задачи?	Ничья: обе модели получили 10/10
Какая модель выполнила больше заданий целиком?	GPT-5.6-SOL — 10/10; Opus 5 — 9/10
Какая модель надежнее генерирует код?	В этом наборе ничья: обе прошли скрытые тесты двух алгоритмических задач, то есть 2/2
Ошибся ли Opus в сложной задаче по теории вероятностей?	Нет. Основной ответ правильный, но вывод был оборван при `max_tokens=3200`, поэтому последнее требуемое объяснение отсутствовало
Какая модель точнее соблюдает строгий JSON?	В этом тесте GPT-5.6-SOL: 1/1 с первой попытки против 0/1 у Opus; две дополнительные попытки Opus также не соответствовали формату
Доказывает ли это, что GPT в целом умнее?	Нет. Правильность рассуждений, полноту ответа и соблюдение формата следует оценивать раздельно

Если приоритет — проверяемая правильность математики, физики и алгоритмов, этот набор не выявил преимущества одной модели. Если ответ должен без дополнительной обработки разбираться как JSON или содержать каждый обязательный подпункт, GPT-5.6-SOL в данном тесте показал более стабильную доставку результата.

Почему задержка сети не входит в оценку интеллекта

Полное время ответа API зависит не только от самой модели. На него влияют:

сетевой маршрут от шлюза до вышестоящего сервиса;
текущая нагрузка на канал и ограничения учетной записи;
попадание в кеш;
выбор конкретного обслуживающего экземпляра;
способ учета или сокрытия reasoning token вышестоящим сервисом.

Разница в несколько секунд в одиночном запросе прежде всего характеризует текущую инфраструктуру и маршрутизацию. Она не доказывает более высокую точность рассуждений.

Чтобы содержательно сравнивать задержку, потребовалось бы зафиксировать вышестоящий сервис, выполнить достаточное число повторов и опубликовать распределения результатов с доверительными интервалами. Без этого задержка пригодна для эксплуатационного мониторинга, но не для оценки интеллекта модели.

Поэтому время ответа полностью исключено из итогового счета, и победитель по скорости здесь не определяется. Список доступных моделей можно проверить на странице моделей Crazyrouter, а планирование затрат следует проводить отдельно по странице тарифов Crazyrouter.

Среда и методика проверки

Перед запуском использовался список моделей, чтобы убедиться в доступности точных идентификаторов:

GET https://cn.crazyrouter.com/v1/models

claude-opus-5
gpt-5.6-sol

Все основные запросы отправлялись по одному пути:

POST https://cn.crazyrouter.com/v1/chat/completions

Внутри каждого тестового набора обе модели получали одинаковые:

system prompt;
user prompt;
значение temperature;
значение max_tokens.

Внешние инструменты не подключались. Успешный HTTP-ответ сам по себе не считался доказательством прохождения задачи.

Три независимых уровня оценки

Точность основного ответа

Проверялись ключевые числа, выводы, состояние математической модели и поведение алгоритма.
Полное выполнение задания

Проверялось наличие всех подпунктов, которые были явно перечислены в условии.
Машинная проверяемость

Код запускался локально на скрытых тестах, а строгий JSON передавался стандартному анализатору.

Такое разделение принципиально важно. Правильное число не гарантирует выполнения всего задания, а верные данные внутри ответа не гарантируют, что ответ соответствует требуемому формату.

После автоматической проверки проводилась ручная перепроверка. Иначе различия в записи LaTeX, регистре, точной дроби и округленном десятичном значении могли бы дать ложные отрицательные результаты. Например, GPT-5.6-SOL в вероятностной задаче не повторил эталонную дробь буквально, но привел эквивалентную формулу и правильное десятичное значение. Opus в физической задаче записал 0.302 m как 0.30 m с двумя значащими цифрами — это также не является ошибкой.

Результаты 10 задач

Задача	Проверяемый результат	Claude Opus 5	GPT-5.6-SOL
Точная цепь Маркова	`E[τ]=5`, `E[τ²]=43`, `Var(τ)=18`	Правильно	Правильно
Осциллятор с двумя степенями свободы	Две собственные частоты, две амплитуды и две фазы	Правильно	Правильно
Поиск с ограничениями	Единственный порядок `A,C,E,B,D`	Правильно	Правильно
Исправление применения неравенства Кантелли	Вероятность не идентифицируется, верхняя граница равна `0.2`	Правильно	Правильно
Проверка Python-кода поиска циклов	Ошибка, контрпример на DAG и минимальное исправление	Правильно	Правильно
Планирование эксперимента	Парное сравнение на одинаковых задачах, контроль сложности и доверительный интервал	Правильно	Правильно
Ожидание шаблона `HHTH` для смещенной монеты	Математическое ожидание около `12.6547` и правильные переходы состояний	Основной ответ правильный, последнее объяснение отсутствует из-за обрыва	Правильно и полностью
Алгоритм агрегирования журналов	Временное окно, события отказа, доля попаданий в кеш и пользователи с максимальными затратами	Скрытые тесты пройдены	Скрытые тесты пройдены
Неупругое столкновение и пружина	`v1≈6.10`, `v2≈2.44`, `x≈0.302`	Правильно	Правильно
Алгоритм стабильной маршрутизации	cost, latency, reliability и лексикографическое правило	Скрытые тесты пройдены	Скрытые тесты пройдены

Сводный результат основного набора:

основные ответы — 10/10 у обеих моделей;
полное выполнение всех подпунктов — 9/10 у Opus 5 и 10/10 у GPT-5.6-SOL;
скрытые тесты кода — 2/2 у обеих моделей.

Самая сложная задача по теории вероятностей

В задаче требовалось найти ожидаемое число бросков до появления шаблона HHTH для смещенной монеты:

P(H)=0.62
P(T)=0.38

Состояния нужно было построить по принципу самого длинного префикса шаблона, совпадающего с суффиксом уже полученной последовательности. Кроме вычислений, условие требовало объяснить два потенциально неочевидных момента:

почему после состояния HH и очередного H процесс остается в HH;
почему математическое ожидание нельзя просто записать как 1/P(HHTH).

Обе модели получили правильный основной результат:

E[N] ≈ 12.6547

GPT-5.6-SOL завершил весь вывод и учел перекрытия шаблона:

E[N] = 1 / P(HHTH) + 1 / P(H)

Opus 5 также правильно определил состояния, составил уравнения и привел точную дробь вместе с десятичным результатом. Однако ответ завершился с:

finish_reason=length

При границе:

max_tokens=3200

вывод оборвался после дополнительных математических ожиданий для состояний. Последнее требуемое объяснение — почему нельзя использовать только обратную вероятность шаблона — в ответ не попало.

Это различие напрямую показывает, зачем разделять два критерия:

Правильное итоговое значение засчитывается как правильность основного ответа. Отсутствие обязательного объяснения означает, что задача выполнена не полностью.

Методологически это тот же риск, который рассматривался в повторном тесте обрыва по max_tokens: вместе с содержимым ответа необходимо сохранять finish_reason и заданный бюджет вывода. Частично правильный ответ нельзя автоматически считать полной доставкой результата.

Проверка исполняемого кода

Качество программного решения нельзя надежно оценить по длине ответа, количеству комментариев или внешней аккуратности реализации. Поэтому сгенерированный код сохранялся в файлы .py и запускался локально в изолированном режиме на одинаковом наборе скрытых тестов.

Агрегатор журналов

Функция должна была корректно обрабатывать:

полуоткрытое временное окно;
разные правила учета успешных и неуспешных запросов;
отсутствующих пользователей и модели;
cache hit rate;
лексикографическую сортировку пользователей при одинаковом cost;
запрет на изменение входных объектов.

Обе реализации прошли скрытые тесты.

Стабильная маршрутизация с ограничением надежности

Алгоритм поиска пути должен был последовательно применять следующие критерии:

минимальная общая стоимость;
при равной стоимости — минимальная задержка;
при равной стоимости и задержке — максимальная надежность;
при полном равенстве — лексикографический порядок пути.

Дополнительно проверялись:

banned nodes;
максимальное число hops;
минимально допустимая reliability;
некорректные ребра.

Обе модели прошли и этот набор. Таким образом, результат по исполняемому коду — 2/2 у Claude Opus 5 и 2/2 у GPT-5.6-SOL. Оснований объявлять победителя по этим двум задачам нет.

Другой набор сложных задач по физике и алгоритмам приведен в материале GPT-5.6-SOL vs GPT-5.5: тест сложной физики и кода.

Строгий JSON: проверка формата, а не математических способностей

В отдельном задании нужно было представить данные об инциденте в виде одного объекта. Требование формулировалось однозначно:

exactly one JSON object and no Markdown

Обе модели правильно вычислили:

долю отказов;
принадлежность отказов к каналам;
число запросов, не восстановленных после повторной попытки.

Различие возникло только на уровне выходного формата:

GPT-5.6-SOL с первой попытки вернул только JSON, который можно было сразу передать в json.loads;
Opus 5 с первой попытки добавил ограждение блока кода и раздел Verification;
в первой дополнительной попытке Opus выдал компактный JSON, но затем снова добавил Verification;
во второй дополнительной попытке Opus опять добавил ограждение блока кода и пояснение.

Итог строгой проверки с первой попытки:

Claude Opus 5 — 0/1;
GPT-5.6-SOL — 1/1.

Две дополнительные попытки Opus также остались несоответствующими строгому формату. При этом сами данные и значения полей были правильными.

Поэтому корректная классификация такова: данные верны, формат не соблюден. Это нарушение инструкции и контракта ответа, а не ошибка вычисления.

Минимальная локальная проверка

import json

REQUIRED_KEYS = [
    "window",
    "total_requests",
    "failed_requests",
    "failure_rate_pct",
    "provider_owned_failures",
    "customer_owned_failures",
    "recovered_by_retry",
    "unrecovered_failures",
    "root_cause",
    "action",
]


def parse_incident_json(raw: str) -> dict:
    payload = json.loads(raw)
    if list(payload) != REQUIRED_KEYS:
        raise ValueError("unexpected schema or key order")
    if payload["failed_requests"] != 84:
        raise ValueError("failed request count mismatch")
    return payload

Этот код проверяет три независимых свойства:

ответ действительно разбирается как JSON;
схема и порядок ключей соответствуют ожидаемому контракту;
одно из критических значений совпадает с эталоном.

Один system prompt не гарантирует структурированный вывод. В рабочей системе безопаснее использовать поддерживаемые поставщиком параметры структурированного ответа, выполнять локальную проверку schema и предусматривать повторный запрос либо переключение модели после ошибки разбора.

Как воспроизвести сравнение через один API

Ниже приведен минимальный исполняемый пример для OpenAI-compatible chat completions endpoint. К самому API endpoint UTM-параметры не добавляются.

import os
import requests

BASE_URL = "https://cn.crazyrouter.com/v1"
API_KEY = os.environ["CRAZYROUTER_API_KEY"]


def ask(model: str, prompt: str, max_tokens: int = 4000) -> dict:
    response = requests.post(
        f"{BASE_URL}/chat/completions",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json",
        },
        json={
            "model": model,
            "messages": [
                {"role": "system", "content": "Answer accurately and follow every requested constraint."},
                {"role": "user", "content": prompt},
            ],
            "temperature": 0.2,
            "max_tokens": max_tokens,
        },
        timeout=600,
    )
    response.raise_for_status()
    return response.json()


for model in ("claude-opus-5", "gpt-5.6-sol"):
    result = ask(model, "Your benchmark prompt here")
    choice = result["choices"][0]
    print(model, choice.get("finish_reason"), choice["message"].get("content", ""))

Для воспроизводимого теста недостаточно сохранить только видимый текст ответа. На каждом запуске также следует записывать:

точный model ID;
response ID;
returned model;
исходный prompt;
temperature;
max_tokens;
finish_reason;
необработанное содержимое ответа;
результат локальной проверки;
версию тестового набора.

Текущую доступность моделей можно проверить в списке моделей Crazyrouter, после чего запустить небольшой регрессионный набор на собственных рабочих запросах.

FAQ

Claude Opus 5 или GPT-5.6-SOL — какая модель умнее?

По этому набору нельзя обоснованно назвать одну модель в целом более умной. На 10 объективно проверяемых задачах обе получили 10/10 по правильности основных ответов.

Почему полное выполнение заданий не закончилось ничьей?

Ответ Opus на сложную задачу по вероятностям был оборван при max_tokens=3200 и завершился с finish_reason=length. Число 12.6547 и уравнения были правильными, но последнее требуемое объяснение отсутствовало. Поэтому Opus получил 9/10 по полной доставке, а GPT-5.6-SOL — 10/10.

Почему обрыв ответа не считается ошибкой основного рассуждения?

Потому что основной математический результат был получен правильно. Однако задача содержала дополнительное требование, которое не было выполнено. Правильность рассуждений и полнота ответа — разные показатели.

Следует ли считать нарушение строгого JSON ошибкой интеллекта?

Не как математическую ошибку. Opus правильно вычислил поля и значения, но нарушил требование к внешнему формату. Это следует учитывать как ошибку соблюдения инструкции и машинного контракта.

Что именно произошло при повторных попытках Opus с JSON?

С первой попытки Opus добавил ограждение блока кода и Verification. В первой дополнительной попытке после компактного JSON снова появился Verification. Во второй дополнительной попытке модель вновь добавила ограждение блока кода и пояснение. Таким образом, все три ответа не соответствовали требованию «ровно один JSON-объект без Markdown».

Как оценивались две задачи на программирование?

Код сохранялся в файлы Python и запускался на одинаковых скрытых тестах. Проверялись граничные условия, правила сортировки, некорректные входные данные и неизменность входных объектов. Обе модели прошли обе задачи — 2/2.

Почему в сравнении нет победителя по скорости?

Полное время API-запроса зависит от сетевого маршрута, кеша, нагрузки канала, ограничений учетной записи и выбранного обслуживающего экземпляра. Без фиксированного вышестоящего сервиса, большого числа повторов и доверительных интервалов задержка не является показателем интеллекта. Поэтому она исключена из оценки.

Достаточно ли 10 задач для долгосрочного выбора модели?

Нет. Это небольшой воспроизводимый срез возможностей, а не окончательный рейтинг. Перед внедрением следует использовать собственный набор рабочих задач и раздельно считать точность основных ответов, полноту выполнения, прохождение тестов кода и частоту нарушений формата.

Как начать собственное сравнение?

Выберите 10–30 реальных рабочих запросов и заранее задайте для каждого машинно проверяемые критерии. Затем отправляйте обеим моделям одинаковые входные данные с одинаковыми параметрами и сохраняйте необработанные ответы вместе с finish_reason. Критерии необходимо определить до просмотра результатов.

Что важнее для backend-системы: точность или формат?

Оба свойства важны, но проверять их нужно отдельно. Правильный ответ в неразбираемом формате может быть бесполезен для конвейера. И наоборот, синтаксически корректный JSON не гарантирует правильность значений. Надежная система проверяет и содержание, и контракт ответа.

Итоговый вывод

Главный результат этого сравнения — не безусловная победа одной модели, а четкое разделение двух аспектов качества:

Claude Opus 5 и GPT-5.6-SOL получили по 10/10 за правильность основных ответов. GPT-5.6-SOL полнее выполнил все подпункты — 10/10 против 9/10 — и с первой попытки соблюл строгий JSON: 1/1 против 0/1. Opus сохранил правильность рассуждений, но потребовал более строгого контроля бюджета вывода и формата.

Если задачу можно проверять по эталонному ответу или скрытым тестам, обе модели заслуживают включения в список кандидатов. Если последующие компоненты напрямую потребляют JSON, локальная проверка, контроль finish_reason, повторные запросы и переключение модели должны рассматриваться как обязательная часть архитектуры.

Создать учетную запись Crazyrouter и запустить собственное сравнение Opus 5 и GPT-5.6-SOL

Claude Opus 5 vs GPT-5.6-SOL：10 道智能正确率实测，核心答案打平

Jenny Met — Thu, 30 Jul 2026 00:25:07 +0000

Claude Opus 5 vs GPT-5.6-SOL：10 道智能正确率实测，核心答案打平

Claude Opus 5 和 GPT-5.6-SOL，谁更聪明？

如果用一次响应时间回答这个问题，结论很可能测到的是线路、路由和上游负载，而不是模型能力。因此这轮对比主动放弃“谁更快”的叙事，只保留可以独立验收的内容：数学答案是否正确、物理建模是否完整、代码能否通过隐藏测试、错误前提能否被识别，以及题目要求是否全部完成。

我们通过 Crazyrouter 的同一个 OpenAI-compatible endpoint，对两个模型执行了 10 道智能题，并把严格 JSON 作为单独的指令遵守测试。结果比“谁碾压谁”更值得参考：

核心答案正确率：Opus 5 为 10/10，GPT-5.6-SOL 为 10/10；
完整完成全部子要求：Opus 5 为 9/10，GPT-5.6-SOL 为 10/10；
两道 Python 算法题隐藏测试：双方均为 2/2；
严格 JSON 首次交付：Opus 5 为 0/1，GPT-5.6-SOL 为 1/1；Opus 后续两次复测仍附加了额外文字。

所以，本轮可以说“核心正确率打平”，但不能说两者的交付行为完全相同。

创建 API Key，用自己的真实题库复测

快速结论

问题	本轮结果
谁的核心智能答案更正确？	打平：双方 10/10
谁完整完成了更多题目要求？	GPT-5.6-SOL：10/10；Opus 5：9/10
谁的代码更可靠？	本轮打平，两道算法题均通过隐藏测试
Opus 的概率题算错了吗？	没有，核心答案正确；只是输出被 `max_tokens=3200` 截断，遗漏最后一个解释要求
谁更遵守严格 JSON？	本轮 GPT-5.6-SOL 更稳；Opus 连续 3 次添加了额外文本或代码围栏
能据此宣布 GPT 更聪明吗？	不能。格式遵守和核心推理正确率应分开统计

如果你的业务以数学、物理或算法正确性为主，这组样本没有拉开明显差距。如果业务要求响应必须是可直接解析的 JSON，或者每个子要求都不能缺失，那么 GPT-5.6-SOL 在本轮表现得更完整。

为什么这次不比较速度

模型 API 的端到端耗时会受到多个变量影响：

网关到不同上游的网络路径；
当时渠道负载与账户限流；
是否命中缓存；
路由到哪个实际服务实例；
上游如何统计或隐藏 reasoning token。

一次请求快几秒，并不能证明模型推理更强。除非固定上游、重复足够多次并报告置信区间，否则延迟更适合做运维观测，不适合当作“智能分数”。

这也是为什么本文没有把任何响应耗时指标放进胜负表。如果你关心可用模型和接入范围，可以先查看 Crazyrouter 模型列表；成本规划则应单独参考 Crazyrouter pricing。

测试环境与评分方式

测试前调用模型列表接口，确认两个精确模型 ID 均可见：

GET https://cn.crazyrouter.com/v1/models

claude-opus-5
gpt-5.6-sol

正式请求统一使用：

POST https://cn.crazyrouter.com/v1/chat/completions

每个测试批次内，两款模型使用相同的 system prompt、user prompt、temperature 和 max_tokens。测试不启用外部工具，也不把 HTTP 200 自动当成任务通过。

评分拆成三层：

核心答案正确率：关键数值、结论和算法行为是否正确；
完整任务通过率：是否完成题目列出的全部子要求；
机器可验收性：代码是否通过隐藏测试，JSON 是否可直接解析。

自动字符串评分之后又做了人工复核。原因很简单：LaTeX 写法、大小写、精确分数与小数舍入都可能造成假阴性。比如 GPT-5.6-SOL 的概率题没有照抄参考分数，但给出了等价公式和正确小数；Opus 的物理题把 0.302 m 写成两位有效数字 0.30 m，也不能因此算错。

10 道智能题结果

任务	验收要点	Claude Opus 5	GPT-5.6-SOL
精确马尔可夫链	`E[τ]=5`、`E[τ²]=43`、`Var(τ)=18`	正确	正确
二自由度振子	两个固有频率、两个振幅、两个相位	正确	正确
约束搜索	唯一顺序 `A,C,E,B,D`	正确	正确
Cantelli 纠错	概率不可识别，上界为 `0.2`	正确	正确
Python 环检测审查	bug、DAG 反例、最小修复	正确	正确
实验设计	同题配对、难度控制、置信区间	正确	正确
偏置硬币等待 `HHTH`	期望约 `12.6547` 与正确状态转移	核心正确，最后一项解释因截断缺失	正确且完整
日志聚合算法	时间窗口、失败事件、缓存率、Top 用户	隐藏测试通过	隐藏测试通过
非弹性碰撞与弹簧	`v1≈6.10`、`v2≈2.44`、`x≈0.302`	正确	正确
稳定路由算法	cost、latency、reliability 与字典序规则	隐藏测试通过	隐藏测试通过

最难的概率题：答案正确不等于任务完整

目标模式为 HHTH，偏置硬币满足 P(H)=0.62、P(T)=0.38。题目要求用最长前后缀匹配状态建立方程，并特别解释两个容易出错的地方：

状态 HH 后再次出现 H，为什么仍然停留在 HH；
为什么期望等待时间不能直接写成 1/P(HHTH)。

两款模型都得到了正确期望：

E[N] ≈ 12.6547

GPT-5.6-SOL 完成了全部推导，并指出模式存在重叠，因此：

E[N] = 1 / P(HHTH) + 1 / P(H)

Opus 5 也给出了正确状态、方程、精确分数和小数结果，但响应最终为 finish_reason=length。输出停在附加状态期望值处，没有完成最后一项“为什么不能直接使用倒数概率”的解释。

这道题提醒我们：

最终数值正确，可以计入核心答案正确率；没有完成全部问题，则不能计入完整任务通过率。

这和此前的 max_tokens 截断复测是同一个方法论问题：必须同时保存答案、finish_reason 和输出预算，不能看到半段正确内容就宣布任务完成。

两道代码题：必须真正运行，而不是看起来像代码

代码生成对比最容易被“写得很长”“注释很多”“结构优雅”误导。我们没有人工挑喜欢的实现，而是把两款模型输出保存成 .py 文件，在隔离模式下执行统一测试。

日志聚合器

函数需要处理：

半开时间窗口；
成功与失败请求的不同计数规则；
缺失用户和模型；
cache hit rate；
cost 相同情况下的用户字典序排序；
不修改输入对象。

两款模型的实现都通过了隐藏测试。

带可靠性约束的稳定路由

函数需要在路径搜索中同时处理：

总成本最低；
成本相同时延迟最低；
再相同时可靠性最高；
最后按路径字典序选择；
banned nodes、最大 hops、最小可靠性和非法边。

两款模型同样全部通过。因此本轮代码能力结论是打平，而不是根据代码长度猜测赢家。

如果你希望看 GPT-5.6-SOL 在另一组复杂物理与依赖算法中的表现，可以参考 GPT-5.6-SOL vs GPT-5.5 高难物理与代码实测。

严格 JSON：这是指令遵守测试，不是数学智力题

严格 JSON 题要求把事故数据压缩为一个对象，并明确写了：

exactly one JSON object and no Markdown

两款模型都算对了失败率、渠道归属和重试后未恢复数量。差异出现在输出外壳：

GPT-5.6-SOL 首次只返回 JSON，可直接交给 json.loads；
Opus 5 首次添加代码围栏和 Verification；
Opus 第一次复测输出紧凑 JSON，但后面继续添加 Verification；
Opus 第二次复测再次添加代码围栏和解释。

因此 Opus 是“数据正确、格式失败”，不是“不会计算”。把这一项混入智能正确率，会把两个不同问题混成一个模糊总分。

生产中可以做最基本的本地验收：

import json

REQUIRED_KEYS = [
    "window",
    "total_requests",
    "failed_requests",
    "failure_rate_pct",
    "provider_owned_failures",
    "customer_owned_failures",
    "recovered_by_retry",
    "unrecovered_failures",
    "root_cause",
    "action",
]


def parse_incident_json(raw: str) -> dict:
    payload = json.loads(raw)
    if list(payload) != REQUIRED_KEYS:
        raise ValueError("unexpected schema or key order")
    if payload["failed_requests"] != 84:
        raise ValueError("failed request count mismatch")
    return payload

只靠 system prompt 不能保证结构化输出。更稳妥的方式是：使用供应方支持的结构化输出参数、执行本地 schema 校验，并在解析失败时重试或切换模型。

如何通过同一个 API 复测

下面的最小示例使用 OpenAI-compatible chat completions endpoint。API endpoint 本身不添加 UTM 参数。

import os
import requests

BASE_URL = "https://cn.crazyrouter.com/v1"
API_KEY = os.environ["CRAZYROUTER_API_KEY"]


def ask(model: str, prompt: str, max_tokens: int = 4000) -> dict:
    response = requests.post(
        f"{BASE_URL}/chat/completions",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json",
        },
        json={
            "model": model,
            "messages": [
                {"role": "system", "content": "Answer accurately and follow every requested constraint."},
                {"role": "user", "content": prompt},
            ],
            "temperature": 0.2,
            "max_tokens": max_tokens,
        },
        timeout=600,
    )
    response.raise_for_status()
    return response.json()


for model in ("claude-opus-5", "gpt-5.6-sol"):
    result = ask(model, "Your benchmark prompt here")
    choice = result["choices"][0]
    print(model, choice.get("finish_reason"), choice["message"].get("content", ""))

正式测试时还应保存 response ID、returned model、原始答案和本地验收结果。你可以在 Crazyrouter 模型列表确认当前模型可见性，再用自己的业务 prompt 做小批量回归。

生产选型建议

两款模型都适合的场景

有明确参考答案的数学与物理求解；
可以运行单元测试的 Python 算法；
需要识别错误前提或不充分统计结论；
能通过本地验证器判断任务是否成功的工作流。

本轮更适合优先 GPT-5.6-SOL 的场景

每一个子要求都必须在一次响应中完成；
原始正文必须是纯 JSON；
希望减少从解释文本中提取结构化数据的工作。

使用 Opus 5 时应增加的保护

长推导设置更充足的 max_tokens；
必须检查 finish_reason；
JSON 先解析再进入下游；
对额外 Markdown 或解释文字做明确回退处理。

这不意味着 Opus 5 的推理较弱。本轮它的 10 道核心答案全部正确，且两份代码都通过隐藏测试。差别主要体现在“是否把所有要求完整装进最终响应”。

如果你还在比较 Claude 系列内部的交付行为，可以阅读 Claude Opus 5 vs Claude Fable 5 真实 API 测试。

FAQ

Claude Opus 5 和 GPT-5.6-SOL 谁更聪明？

本轮 10 道可客观验收的智能题中，双方核心答案都是 10/10，因此没有证据支持“其中一款全面更聪明”。

为什么完整任务通过率不是平局？

Opus 的高难概率题输出被 max_tokens=3200 截断，虽然期望值和状态方程正确，但遗漏了最后一项解释。GPT 完成了全部子要求。

JSON 失败应该算智能错误吗？

不应直接算作数学或推理错误。更准确的分类是格式与指令遵守失败，因为 Opus 计算出的所有 JSON 字段和值都正确。

两道代码题如何评分？

模型输出被保存为 Python 文件，然后运行相同的隐藏测试，覆盖边界条件、排序规则、非法输入和输入不可变性。两款模型都通过。

为什么不公布速度赢家？

端到端速度会受到线路、渠道、缓存、上游负载和路由影响。在没有固定上游和足够重复次数时，它不能代表智能正确率。

10 道题足够决定长期选型吗？

不够。这是一次小样本、可复现的能力切片。上线前应把真实业务题库重复 20–50 次，分别统计核心正确率、完整任务通过率、代码测试通过率和格式违规率。

我应该怎样开始自己的模型对比？

先选择 10–30 个真实业务 prompt，为每题定义机器可执行的通过标准，再通过统一 API 发送相同输入。不要先决定赢家，再挑支持结论的案例。

最终结论

这轮测试最重要的结果不是“GPT 赢”或“Opus 赢”，而是一个更可操作的判断：

Claude Opus 5 与 GPT-5.6-SOL 在 10 道智能题上的核心答案正确率均为 10/10；GPT-5.6-SOL 在完整子要求和严格 JSON 交付上更稳定，Opus 5 则需要更严格的输出预算与格式验收。

如果你的任务有参考答案或隐藏测试，两款模型都值得进入候选集。如果下游系统直接消费 JSON，则应把格式验证、重试和模型回退视为必要组件，而不是可选优化。

创建 Crazyrouter 账户并运行自己的 Opus 5 / GPT-5.6-SOL 测试

Claude Opus 5 vs Claude Fable 5: 7개 실제 API 테스트와 프로덕션 라우팅 제안

Jenny Met — Sun, 26 Jul 2026 14:59:28 +0000

Claude Opus 5 vs Claude Fable 5: 7개 실제 API 테스트와 프로덕션 라우팅 제안

Claude Opus 5와 Claude Fable 5, 둘 중 무엇을 골라야 할까요? 한 번의 성공 응답만 보면 두 모델 모두 아주 멋진 수학 유도까지 잘해냅니다. 하지만 실제 프로덕션 경험을 좌우하는 건 대개 다른 세 가지입니다. 작업을 안정적으로 끝까지 전달할 수 있는지, 지연 시간이 상호작용에 적합한지, 실패 후 자동 복구가 가능한지입니다.

우리는 2026년 7월 25일, 동일한 OpenAI-compatible API를 통해 같은 프롬프트와 같은 파라미터로 두 모델에 대해 7종류의 작업을 테스트했습니다. 결과는 “더 큰 모델이 무조건 더 좋다”는 단순한 서사로는 설명되지 않았습니다.

claude-fable-5는 공통 성공 작업에서 더 빠르고 더 간결했습니다.
claude-opus-5는 최종적으로 7개 작업 전부를 커버했습니다.
Fable 5는 일반 코드 리뷰와 사고 JSON 프롬프트에서 연속으로 content_filter를 트리거했습니다.
Opus 5는 물리 문제에서 처음 두 번 HTTP 200을 반환했지만, 실제로는 인사말 한 줄만 답했고, 3번째 시도에서야 정상 완료했습니다.

즉, 프로덕션에서의 선택 기준은 모델 ID 하나로 끝나면 안 됩니다. 더 안정적인 방식은 작업 유형별로 주 모델을 정하고, 그 위에 콘텐츠 검증, 재시도, 모델 폴백을 덧씌워 이상 케이스를 감싸는 것입니다.

같은 API로 Opus 5와 Fable 5를 테스트하기

빠른 결론

질문	이번 테스트의 답
어떤 모델이 더 많은 작업을 커버했나?	Opus 5: 본 테스트 6/7, 재시도 후 7/7
어떤 모델이 더 빠른가?	공통 성공 작업에서 Fable 5의 P50 총 지연이 약 24% 낮음
어떤 모델이 더 간결한가?	Fable 5, 평균 가시 출력 token이 약 43% 적음
어떤 모델이 코드 리뷰와 엄격한 JSON에 더 적합한가?	이번에는 Opus 5가 더 안정적; Fable 5는 두 문제에서 연속 3회 필터링됨
HTTP 200만 보면 되는가?	안 된다; 두 모델 모두 HTTP 200이지만 작업이 전달되지 않은 사례가 있었다
라우팅은 어떻게 하는 것이 좋은가?	검증된 작업은 Fable 5 우선, 필터링 또는 빈 본문이면 Opus 5로 회귀; Opus의 이상 인사말은 자동 재시도

입력 유형이 예측 불가능하거나, 일반 비즈니스 프롬프트가 필터링되는 일을 최대한 피해야 한다면 Opus 5를 우선 고려하세요. 반대로 작업 구조가 고정돼 있고 이미 회귀 테스트를 마쳤으며, 상호작용 속도와 출력 길이가 더 중요하다면 Fable 5가 첫 번째 선택으로 더 적합합니다.

테스트 방법

테스트 전에 모델 목록 API를 호출해, 두 개의 정확한 모델 ID가 모두 보이는지 확인했습니다.

GET https://cn.crazyrouter.com/v1/models

claude-opus-5
claude-fable-5

모든 정식 요청은 동일한 endpoint로 보냈습니다.

POST https://cn.crazyrouter.com/v1/chat/completions

공통 조건은 다음과 같습니다.

동일한 system prompt
동일한 user prompt
temperature = 1
각 문제에 동일한 max_tokens 사용
stream = true
도구 및 인터넷 사용 비활성화

통일된 system prompt는 정확한 응답과 출력 형식 준수만 요구했고, 어느 모델에도 유리한 역할 설정은 넣지 않았습니다.

Answer the user's task accurately. Follow every requested output format and length constraint exactly. Do not use external tools.

우리가 기록한 것은 최종 텍스트만이 아닙니다. 다음도 함께 기록했습니다.

HTTP 상태와 finish_reason
response ID와 반환된 model
첫 번째 가시 token 시점과 총 지연 시간
completion tokens, reasoning tokens
가시 응답이 작업 검증을 통과했는지 여부
비정상 요청이 같은 파라미터로 재시도 시 복구되는지 여부

이 테스트는 특정 상위 채널 하나를 지정한 실험이 아니라, Crazyrouter 게이트웨이의 end-to-end 테스트입니다. 따라서 결과는 모델 동작뿐 아니라 상위 필터링, 게이트웨이 라우팅, 당시 채널 상태까지 함께 반영합니다. 즉, “사용자가 이 API를 통해 실제로 무엇을 겪게 되는가”를 답하는 데 적합하고, Claude 계열의 순수 오프라인 능력 순위표로 포장하기에는 적절하지 않습니다.

모델 테스트에서 왜 finish_reason과 출력 예산을 기록해야 하는지 궁금하다면, Claude Fable 5 vs GPT-5.5의 max_tokens 재검증도 함께 보세요.

7개 결과 총표

테스트 항목	Claude Opus 5	Claude Fable 5	프로덕션 영향
정확한 수학: 마르코프 체인	통과	통과	두 모델 모두 1차 모멘트, 2차 모멘트, 분산을 정확히 도출
수치 물리: 결합 진동자	처음 두 번은 인사말만, 3번째에 통과	1차 호출에 통과	Opus는 콘텐츠 수준 검증과 재시도가 필요
제약 탐색	통과	통과	두 모델 모두 유일해를 찾음
통계적 오류 수정	통과	통과	두 모델 모두 잘못된 전제를 거부하고 올바른 상한을 제시
Python 코드 리뷰	통과	연속 3회 `content_filter`	Fable은 현재 회귀 테스트 없이 코드 리뷰 트래픽에 적합하지 않음
엄격한 JSON 사고 요약	통과	연속 3회 `content_filter`	Fable은 현재 이런 유형의 운영 사고 텍스트에 적합하지 않음
실험 설계	통과	통과	두 모델 모두 비짝지어진 샘플과 난이도 혼합을 식별 가능

주 테스트의 1회 전달률은 다음과 같습니다.

Claude Opus 5: 6 / 7 = 85.7%
Claude Fable 5: 5 / 7 = 71.4%

재시도를 포함하면:

Claude Opus 5: 7 / 7
Claude Fable 5: 5 / 7

여기서 “전달”은 요청 성공이 아니라, 비즈니스가 문제 요구사항에 맞는 가시 응답을 받는다는 뜻입니다. HTTP 200, 모델명, token usage가 존재하더라도, 본문이 비어 있거나 필터링되었거나 인사말만 돌아오면 여전히 작업 실패입니다.

수학, 제약, 통계: 두 모델 모두 신뢰할 수 있음

수학 문제는 3상태 마르코프 체인을 사용해, 상태 1에서 상태 3에 처음 도달할 때까지의 대기 시간을 계산하도록 요구했습니다.

E1[τ]
E1[τ²]
Var1(τ)

두 모델 모두 다음 값을 제시했습니다.

E1[τ] = 5
E1[τ²] = 43
Var1(τ) = 18

또한 둘 다 transient matrix Q와 1차, 2차 모멘트 방정식을 제시했습니다. 이 문제에서는 “최종 숫자는 맞지만 유도는 서로 다르다” 같은 일도 없었습니다.

제약 탐색 문제는 A, B, C, D, E 다섯 개 발표를 다섯 개 시간대에 배치하되, 즉시 인접, 선후 관계, 간격, 비인접 조건을 모두 만족시키도록 요구했습니다. 두 모델 모두 다음의 유일한 순서를 찾았습니다.

A, C, E, B, D

통계 오류 수정 문제는 일부러 잘못된 결론을 제시했습니다. “평균이 10이고 분산이 4이므로 P(X≥14)=0.5”라는 주장입니다. 두 모델 모두 2차 모멘트만으로는 꼬리 확률을 유일하게 정할 수 없다고 지적했고, 단측 Chebyshev/Cantelli 부등식을 통해 다음을 도출했습니다.

P(X >= 14) <= 0.2

이 세 가지 작업은 Fable 5의 속도 우위가 기초 추론 정확성을 희생해서 얻어진 것이 아님을 보여줍니다. 명확하고 짧고 검증 가능한 수학·논리 작업에서는 Fable 5를 더 가벼운 첫 번째 hop으로 써도 충분합니다.

이전의 Claude Fable 5 vs Claude Sonnet 5 API 테스트와 GLM-5.2 vs Fable 5 출력 예산 테스트도, 어떤 모델이 프로덕션에 적합한지 판단하려면 정확성, 출력 예산, 전달 형태를 함께 봐야 한다는 점을 보여줍니다.

물리 문제: Fable은 1차에 완료, Opus는 3번째에 복구

물리 문제는 접지 감쇠와 결합 감쇠가 있는 2자유도 진동자를 다루며, 두 개의 비감쇠 고유 진동수와 ω=8 rad/s에서 두 질량 블록의 복소 주파수 응답을 계산하도록 요구했습니다.

참고값은 다음과 같습니다.

ω1 = 10.0204 rad/s
ω2 = 16.2149 rad/s
|X1| = 0.14929 m, phase = -12.15°
|X2| = 0.07174 m, phase = -13.90°

Fable 5는 첫 호출에서 곧바로 모든 정답을 냈습니다. 반면 Opus 5의 처음 두 호출은 프로덕션 팀이 특히 주의해야 할 이상 징후를 보였습니다. 인터페이스는 HTTP 200과 finish_reason=stop을 반환했지만, 본문은 아래 한 줄뿐이었습니다.

Hi! How can I help you today?

이 두 응답의 prompt tokens는 모두 10으로, 실제 입력과는 분명히 맞지 않았습니다. 같은 요청을 3번째 실행했을 때, Opus 5는 34.901초 후 완전한 응답을 반환했고, 여섯 개 수치가 모두 검증을 통과했습니다.

따라서 이런 이상은 “물리 문제를 틀렸다”가 아니라 “요청 컨텍스트가 정상 처리되지”로 분류해야 합니다. 가장 간단한 방어선은 사람이 로그를 보는 일이 아니라, 호출 측에서 작업 수준의 검증을 두는 것입니다. 즉, 답변에 ω1, ω2, X1, X2가 모두 포함되어야 하며, 하나라도 빠지면 재시도해야 합니다.

코드와 엄격한 JSON: 이번 라운드 최대 차이는 Fable의 필터링

코드 문제에서는 Python DFS 사이클 탐지기를 리뷰하게 했습니다. 버그는 아주 평범했습니다. 노드의 DFS가 끝난 뒤 visiting 집합에서 제거하지 않아, 이미 완료된 노드가 여전히 재귀 스택에 있는 것으로 잘못 인식되고, 그 결과 DAG에서도 순환이 있다고 오탐지하는 문제였습니다.

Opus 5는 최소 수정으로 다음을 정확히 지적했습니다.

visiting.discard(node)
visited.add(node)
return False

Fable 5는 코드 분석 대신 finish_reason=content_filter를 반환했고, 본문은 비어 있었습니다. system prompt 편향이나 우발적 라우팅을 배제하기 위해 우리는 세 차례 테스트했습니다. 원본 테스트, 정제한 system prompt로 재검증, 독립 단문 재시도. 결과는 모두 content_filter였습니다.

엄격한 JSON 문제에도 위험한 내용은 없었습니다. 입력은 15분 내 요청 총수, 실패 수, 채널 귀인, 재시도 복구 수, 처리 조치만 포함했고, 출력은 JSON 객체 하나였습니다. Opus 5의 JSON은 바로 파싱 가능했지만, Fable 5는 역시 3회 연속 필터링되었습니다.

이 두 실패는 안전 필터 자체가 모델 API의 프로덕션 능력 중 하나임을 보여줍니다. 일반적인 코드 리뷰나 사고 회고 텍스트에서 안정적으로 오필터링되는 모델이라면, 수학 문제에서 더 빠르더라도 그대로 모든 업무 트래픽을 맡길 수는 없습니다.

두 개의 독립 재시도 response ID는 다음과 같습니다.

코드 리뷰: gen-1784915384-vGI1PtuNXZG0IJ2YiaCz
사고 JSON: gen-1784915390-buOWZQSnqjgHeJ6nUogF

지연 시간과 출력 길이

실패 요청의 짧은 소요 시간을 “속도 우위”로 잘못 계산하지 않기 위해, 여기서는 두 모델이 모두 성공한 네 개 공통 작업만 비교했습니다. 수학, 제약 탐색, 통계 오류 수정, 실험 설계입니다.

지표	Claude Opus 5	Claude Fable 5
P50 총 지연	10.729 s	8.147 s
P50 첫 번째 가시 token	8.376 s	6.974 s
평균 가시 completion tokens	797.5	452.3

이 작은 샘플에서는 Fable 5의 P50 총 지연이 약 24% 낮고, 첫 번째 가시 token은 약 17% 낮으며, 답변은 약 43% 짧았습니다. 채팅, 대량 요약, 고빈도 구조화 작업에서는 이런 차이가 사용자 대기 시간과 하위 처리량에 직접적인 영향을 줍니다.

다만 4문항의 중앙값을 SLA처럼 쓰면 안 됩니다. 상위 부하, 캐시, 라우팅, rate limit은 모두 지연을 바꿀 수 있습니다. 정식 출시 전에는 반드시 자신의 비즈니스 프롬프트로 20~50회 반복 테스트를 하고, P50, P95, P99와 각 통과 결과의 실제 비용을 집계해야 합니다.

Fable 5의 본 테스트 응답에는 cost 필드가 있었고, 7회 합계는 약 $0.24596였습니다. 반면 Opus 5의 usage에는 동일한 기준의 cost 필드가 제공되지 않았습니다. 따라서 이 글에서는 달러 가격 우열을 판단하지 않습니다. 필드가 없다고 해서 무료라는 뜻도 아니며, 검증되지 않은 가격으로 메우는 것도 옳지 않습니다.

최종 제안

이번 라운드에서 가장 가치 있는 결론은 누가 더 높은 점수를 받았느냐가 아니라, 두 모델의 실패 형태가 다르다는 점입니다.

Fable 5의 강점은 공통 작업이 더 빠르고 더 짧다는 점입니다. 반면 일부 일반 업무 프롬프트는 안정적으로 필터링될 수 있습니다.
Opus 5의 강점은 재시도 후 전체 작업을 커버한다는 점입니다. 반면 때때로 실제 입력과 무관한 인사말을 반환할 수 있습니다.

따라서 Fable 5는 이미 검증된 고빈도 작업 앞단에 두고, Opus 5는 더 넓은 커버리지의 폴백으로 두는 것이 좋습니다. 그리고 두 경로 모두 콘텐츠 수준 검증을 적용해야 합니다. 그래야 모델 비교 결과를 실제 신뢰성으로 전환할 수 있고, 단순한 순위표에 머무르지 않을 수 있습니다.

API Key를 생성하고 이 듀얼 모델 라우팅을 재현하기

FAQ

Claude Opus 5가 Claude Fable 5보다 항상 더 강한가요?

이 작은 샘플만으로 “모든 작업에서 더 강하다”고 결론내릴 수는 없습니다. 두 모델 모두 수학, 제약, 통계 오류 수정, 실험 설계에서는 통과했습니다. Fable 5는 더 빠르고 더 짧았고, Opus 5는 작업 커버리지가 더 완전했습니다. 선택은 모델 이름이 아니라 구체적인 작업 성공률에 근거해야 합니다.

Claude Fable 5는 프로덕션 환경에 적합한가요?

회귀 테스트를 거친 작업에는 적합합니다. 이번 테스트에서는 여러 추론 작업에서 정확했고 더 빨랐지만, 코드 리뷰와 사고 JSON에서는 연속 필터링이 있었습니다. 출시 전에는 실제 프롬프트로 필터링률을 측정하고, Opus 5나 다른 모델로의 폴백을 구성해야 합니다.

왜 HTTP 200인데도 실패로 보나요?

HTTP 200은 인터페이스가 응답을 완료했다는 뜻일 뿐입니다. 본문이 비어 있거나, finish_reason=content_filter이거나, 출력이 잘렸거나, 인사말만 돌아왔다면 업무를 완료할 수 없습니다. 프로덕션 지표는 HTTP 성공률이 아니라 “검증 통과율”을 집계해야 합니다.

returned model이 왜 `anthropic/claude-fable-5`인가요?

요청은 claude-fable-5를 사용했지만, 응답의 returned model은 provider 접두사가 붙은 anthropic/claude-fable-5로 안정적으로 반환되었습니다. 이는 정규화된 별칭으로 볼 수 있으며, 접두사 변화만으로 모델 교체가 일어났다고 증명할 수는 없습니다.

두 모델의 달러 비용을 바로 비교할 수 있나요?

이번에는 불가능합니다. Fable 5 응답에는 cost 필드가 있었지만, Opus 5는 같은 기준의 필드를 제공하지 않았습니다. 엄밀한 비용 비교는 통합 과금 로그에서 수집하고, “검증 통과 결과 1건당 비용”을 지표로 삼아야 합니다.

몇 번 반복해야 출시 결정을 내릴 수 있나요?

핵심 작업군마다 최소 20~50회는 반복하고, 정상 입력, 경계 입력, 장문 입력, 필터링을 유발하기 쉬운 입력을 모두 포함하는 것이 좋습니다. 최소한 작업 성공률, 필터링률, 빈 본문율, 절단률, P50/P95/P99 지연, 비용을 기록해야 합니다.

테스트는 어떻게 시작하나요?

OpenAI-compatible base URL로 https://cn.crazyrouter.com/v1를 사용하고, claude-opus-5와 claude-fable-5를 각각 호출하세요. 프롬프트와 파라미터를 고정하고, 원본 응답을 저장한 뒤, 로컬 assertion 또는 구조 검증으로 작업이 실제로 완료되었는지 판정하면 됩니다.

Claude 듀얼 모델 테스트를 시작하기

Claude Opus 5 vs Claude Fable 5: 7 bài kiểm thử API thực tế và khuyến nghị định tuyến production

Jenny Met — Sun, 26 Jul 2026 14:58:19 +0000

Claude Opus 5 vs Claude Fable 5: 7 bài kiểm thử API thực tế và khuyến nghị định tuyến production

Nên chọn Claude Opus 5 hay Claude Fable 5? Nếu chỉ nhìn vào một lần trả lời thành công, cả hai mô hình đều có thể viết ra lời giải toán rất đẹp. Nhưng thứ thực sự ảnh hưởng đến trải nghiệm production thường là ba vấn đề khác: tác vụ có được giao ổn định hay không, độ trễ có phù hợp với tương tác hay không, và sau lỗi có thể tự phục hồi hay không.

Ngày 25/07/2026, chúng tôi dùng cùng một OpenAI-compatible API, cùng prompt và cùng tham số để kiểm thử hai mô hình trên 7 nhóm tác vụ. Kết quả không rơi vào câu chuyện đơn giản kiểu “mô hình lớn hơn thì chắc chắn tốt hơn”:

claude-fable-5 nhanh hơn và súc tích hơn trên các tác vụ mà cả hai cùng hoàn thành thành công;
claude-opus-5 cuối cùng bao phủ đủ cả 7 nhóm tác vụ;
Fable 5 liên tục kích hoạt content_filter trên prompt review code và prompt JSON sự cố vốn rất bình thường;
Với bài vật lý, hai lần đầu Opus 5 trả về HTTP 200 nhưng chỉ phản hồi một câu chào không liên quan, đến lần thứ 3 mới hoàn thành bình thường.

Điều này có nghĩa là khi chọn mô hình cho production, bạn không nên chỉ có một model ID duy nhất. Cách an toàn hơn là: chọn mô hình chính theo loại tác vụ trước, sau đó bọc các bất thường bằng kiểm định nội dung, retry và fallback mô hình.

Kiểm thử Opus 5 và Fable 5 bằng cùng một API

Kết luận nhanh

Câu hỏi	Kết quả trong vòng kiểm thử này
Mô hình nào bao phủ nhiều tác vụ hơn?	Opus 5: 6/7 ở bài kiểm thử chính, 7/7 sau retry
Mô hình nào nhanh hơn?	Trên các tác vụ cả hai cùng thành công, tổng độ trễ P50 của Fable 5 thấp hơn khoảng 24%
Mô hình nào xuất ra ngắn gọn hơn?	Fable 5, trung bình ít visible output token hơn khoảng 43%
Mô hình nào phù hợp hơn cho review code và JSON nghiêm ngặt?	Trong vòng này Opus 5 ổn định hơn; Fable 5 bị lọc liên tục 3 lần ở hai bài
Có thể chỉ nhìn HTTP 200 không?	Không; cả hai mô hình đều từng trả HTTP 200 nhưng không giao được tác vụ
Nên định tuyến thế nào?	Với tác vụ đã xác minh, ưu tiên Fable 5; khi bị lọc hoặc body rỗng thì fallback sang Opus 5; khi Opus trả câu chào bất thường thì tự động retry

Nếu kiểu input của bạn khó dự đoán, hoặc bạn cần hạn chế tối đa việc prompt nghiệp vụ bình thường bị lọc, hãy ưu tiên cân nhắc Opus 5. Nếu cấu trúc tác vụ cố định, đã được regression test, và tốc độ tương tác cùng độ dài output quan trọng hơn, Fable 5 phù hợp hơn để làm bước gọi đầu tiên.

Chúng tôi đã kiểm thử như thế nào

Trước khi kiểm thử, chúng tôi gọi endpoint danh sách mô hình để xác nhận hai model ID chính xác đều hiển thị:

GET https://cn.crazyrouter.com/v1/models

claude-opus-5
claude-fable-5

Tất cả request chính thức đều đi qua cùng một endpoint:

POST https://cn.crazyrouter.com/v1/chat/completions

Điều kiện chung như sau:

Cùng system prompt
Cùng user prompt
temperature = 1
Mỗi bài dùng cùng max_tokens
stream = true
Không bật tool và không truy cập web

System prompt thống nhất chỉ yêu cầu trả lời chính xác và tuân thủ định dạng output, không thêm role setting thiên vị mô hình nào:

Answer the user's task accurately. Follow every requested output format and length constraint exactly. Do not use external tools.

Chúng tôi không chỉ ghi lại phần văn bản cuối cùng, mà còn ghi:

Trạng thái HTTP và finish_reason;
response ID và returned model;
Thời gian đến visible token đầu tiên và tổng độ trễ;
completion tokens, reasoning tokens;
Câu trả lời hiển thị có đạt tiêu chí nghiệm thu tác vụ hay không;
Request bất thường có thể phục hồi bằng retry với cùng tham số hay không.

Đây là một bộ kiểm thử end-to-end qua gateway Crazyrouter, không phải thí nghiệm cố định một kênh upstream duy nhất. Vì vậy, kết quả đồng thời phản ánh hành vi mô hình, bộ lọc upstream, định tuyến gateway và trạng thái kênh tại thời điểm đó. Nó phù hợp để trả lời câu hỏi “người dùng thực tế sẽ gặp gì khi đi qua API này”, nhưng không phù hợp để đóng gói thành bảng xếp hạng năng lực offline thuần túy của họ Claude.

Nếu muốn hiểu vì sao kiểm thử mô hình bắt buộc phải ghi finish_reason và output budget, bạn có thể đọc tiếp bài kiểm thử lại max_tokens giữa Claude Fable 5 và GPT-5.5.

Bảng tổng hợp kết quả 7 tác vụ

Chiều kiểm thử	Claude Opus 5	Claude Fable 5	Tác động production
Toán chính xác: chuỗi Markov	Đạt	Đạt	Cả hai đều cho moment bậc nhất, moment bậc hai và phương sai chính xác
Vật lý số: dao động tử ghép	Hai lần đầu chỉ trả câu chào, lần thứ 3 đạt	Đạt ở vòng đầu	Opus cần nghiệm thu ở cấp nội dung và retry
Tìm kiếm ràng buộc	Đạt	Đạt	Cả hai đều tìm được nghiệm duy nhất
Sửa lỗi thống kê	Đạt	Đạt	Cả hai đều bác bỏ tiền đề sai và đưa ra cận trên đúng
Review code Python	Đạt	3 lần liên tiếp `content_filter`	Hiện tại Fable chưa phù hợp cho lưu lượng review code chưa regression test
Tóm tắt sự cố JSON nghiêm ngặt	Đạt	3 lần liên tiếp `content_filter`	Hiện tại Fable chưa phù hợp với loại văn bản sự cố production này
Thiết kế thí nghiệm	Đạt	Đạt	Cả hai đều nhận ra mẫu không bắt cặp và nhiễu do độ khó

Tỷ lệ giao tác vụ một lần trong bài kiểm thử chính:

Claude Opus 5: 6 / 7 = 85.7%
Claude Fable 5: 5 / 7 = 71.4%

Sau khi thêm retry:

Claude Opus 5: 7 / 7
Claude Fable 5: 5 / 7

Ở đây, “giao tác vụ” không có nghĩa là request thành công, mà là nghiệp vụ nhận được câu trả lời hiển thị đúng yêu cầu bài. Dù HTTP 200, tên mô hình và token usage đều tồn tại, nếu body rỗng, bị lọc hoặc chỉ trả câu chào, tác vụ vẫn được tính là thất bại.

Toán, ràng buộc và thống kê: cả hai mô hình đều đáng tin cậy

Bài toán dùng chuỗi Markov ba trạng thái, yêu cầu tính thời gian chờ từ trạng thái 1 đến lần đầu chạm trạng thái 3:

E1[τ]
E1[τ²]
Var1(τ)

Cả hai mô hình đều đưa ra:

E1[τ] = 5
E1[τ²] = 43
Var1(τ) = 18

Chúng cũng đều viết ra ma trận tạm thời Q và các phương trình moment bậc nhất, bậc hai. Ở bài này không xuất hiện tình huống “con số cuối cùng đúng nhưng suy luận không nhất quán”.

Bài tìm kiếm ràng buộc yêu cầu xếp năm bài nói A, B, C, D, E vào năm khung thời gian, đồng thời thỏa mãn các điều kiện về liền kề ngay lập tức, thứ tự trước sau, khoảng cách và không kề nhau. Cả hai đều tìm ra thứ tự duy nhất:

A, C, E, B, D

Bài sửa lỗi thống kê cố tình đưa ra một kết luận sai: “trung bình bằng 10, phương sai bằng 4, nên P(X≥14)=0.5.” Cả hai mô hình đều chỉ ra rằng hai moment đầu không đủ để xác định duy nhất xác suất đuôi, và dùng bất đẳng thức Chebyshev/Cantelli một phía để nhận được:

P(X >= 14) <= 0.2

Ba nhóm tác vụ này cho thấy lợi thế tốc độ của Fable 5 không đến từ việc hy sinh độ đúng của suy luận cơ bản. Với các bài toán và logic rõ ràng, ngắn, có thể nghiệm thu được, nó hoàn toàn có thể đóng vai trò bước gọi đầu nhẹ hơn.

Các bài kiểm thử API Claude Fable 5 vs Claude Sonnet 5 và kiểm thử output budget GLM-5.2 vs Fable 5 trước đó cũng cho thấy: để đánh giá một mô hình có phù hợp production hay không, cần nhìn đồng thời vào độ đúng, output budget và hình thái giao tác vụ.

Bài vật lý: Fable hoàn thành ngay vòng đầu, Opus phục hồi ở lần thứ ba

Bài vật lý yêu cầu xử lý một hệ dao động tử hai bậc tự do có damping nối đất và damping ghép, tính hai tần số riêng không damping, cũng như đáp ứng tần số phức của hai khối lượng tại ω=8 rad/s.

Giá trị tham chiếu là:

ω1 = 10.0204 rad/s
ω2 = 16.2149 rad/s
|X1| = 0.14929 m, phase = -12.15°
|X2| = 0.07174 m, phase = -13.90°

Fable 5 đưa ra đầy đủ kết quả đúng ngay vòng đầu. Trong khi đó, hai lần gọi đầu tiên của Opus 5 xuất hiện một bất thường đáng để đội production lưu ý hơn: API trả về HTTP 200 và finish_reason=stop, nhưng body chỉ có:

Hi! How can I help you today?

Prompt tokens của cả hai response này đều chỉ là 10, rõ ràng không khớp với input thật. Khi thực thi cùng request lần thứ 3, Opus 5 trả về đầy đủ sau 34.901 giây, và cả sáu giá trị số đều qua kiểm tra.

Vì vậy, loại bất thường này không nên được phân loại là “tính sai bài vật lý”, mà nên được phân loại là “ngữ cảnh request không được xử lý đúng”. Tuyến phòng thủ đơn giản nhất không phải là để con người đọc log, mà là đặt nghiệm thu cấp tác vụ ở phía caller: câu trả lời phải chứa ω1, ω2, X1, X2; thiếu bất kỳ trường nào thì retry.

Code và JSON nghiêm ngặt: bộ lọc của Fable là khác biệt lớn nhất trong vòng này

Bài code yêu cầu mô hình review một bộ phát hiện chu trình DFS bằng Python. Bug rất thông thường: sau khi DFS xong một node, code không xóa node đó khỏi tập visiting, khiến node đã hoàn tất vẫn bị xem nhầm là đang nằm trong recursion stack, từ đó báo nhầm có chu trình trên DAG.

Opus 5 chỉ ra đúng bản sửa tối thiểu:

visiting.discard(node)
visited.add(node)
return False

Fable 5 không trả về phân tích code, mà là finish_reason=content_filter, body rỗng. Để loại trừ thiên lệch system prompt và định tuyến ngẫu nhiên, chúng tôi làm ba vòng: kiểm thử gốc, kiểm thử lại với system prompt sạch, và retry độc lập một bài. Kết quả đều là content_filter.

Bài JSON nghiêm ngặt cũng không có nội dung nguy hiểm. Input chỉ gồm tổng số request trong 15 phút, số lỗi, quy kết theo kênh, số lần retry phục hồi và hành động xử lý, yêu cầu output một JSON object. JSON mà Opus 5 trả về có thể parse trực tiếp; Fable 5 cũng bị lọc liên tục 3 lần.

Hai nhóm thất bại này cho thấy: bản thân safety filter cũng là một năng lực production của API mô hình. Nếu một mô hình thường xuyên lọc nhầm trên review code bình thường hoặc văn bản postmortem sự cố, thì dù nó nhanh hơn ở bài toán, nó cũng không thể trực tiếp tiếp quản toàn bộ lưu lượng nghiệp vụ.

response ID của hai lần retry độc lập:

Review code: gen-1784915384-vGI1PtuNXZG0IJ2YiaCz
JSON sự cố: gen-1784915390-buOWZQSnqjgHeJ6nUogF

Độ trễ và độ dài output

Để tránh tính thời gian ngắn của request thất bại thành “lợi thế tốc độ”, phần này chỉ so sánh bốn tác vụ chung mà cả hai mô hình đều thành công: toán, tìm kiếm ràng buộc, sửa lỗi thống kê, thiết kế thí nghiệm.

Chỉ số	Claude Opus 5	Claude Fable 5
Tổng độ trễ P50	10.729 s	8.147 s
P50 đến visible token đầu tiên	8.376 s	6.974 s
Visible completion tokens trung bình	797.5	452.3

Trong mẫu nhỏ này, tổng độ trễ P50 của Fable 5 thấp hơn khoảng 24%, visible token đầu tiên thấp hơn khoảng 17%, và câu trả lời ngắn hơn khoảng 43%. Với chat, tóm tắt hàng loạt và tác vụ có cấu trúc tần suất cao, những khác biệt này sẽ ảnh hưởng trực tiếp đến thời gian chờ của người dùng và khối lượng xử lý downstream.

Tuy nhiên, đừng biến median của 4 bài thành SLA. Tải upstream, cache, định tuyến và rate limit đều có thể làm thay đổi độ trễ. Trước khi lên production chính thức, bạn nên lặp lại 20–50 lần bằng prompt nghiệp vụ của chính mình, rồi thống kê P50, P95, P99 và chi phí thực của mỗi kết quả đạt nghiệm thu.

Response trong bài kiểm thử chính của Fable 5 cung cấp trường cost, tổng 7 lần khoảng $0.24596. Usage của Opus 5 không cung cấp cost cùng tiêu chuẩn, nên bài viết này không kết luận thắng thua về giá USD. Thiếu field không có nghĩa là miễn phí, và cũng không nên tự điền giá chưa được xác minh.

Chiến lược định tuyến production được khuyến nghị

Gọi một mô hình duy nhất là cách dễ viết nhất, nhưng nó phơi bày toàn bộ hành vi ngẫu phát của mô hình cho người dùng cuối. Với hai mô hình trong vòng kiểm thử này, cách phân công hợp lý hơn như sau:

Fable 5 làm bước gọi đầu tiên

Phù hợp với:

Toán, suy luận ràng buộc và tóm tắt ngắn đã vượt regression test;
Tương tác nhạy với first token và tổng độ trễ;
Tác vụ muốn kiểm soát độ dài câu trả lời và giảm gánh nặng hậu xử lý.

Điều kiện là họ tác vụ đã được kiểm thử lọc, và phía caller sẽ kiểm tra content_filter, body rỗng và trường bị thiếu.

Opus 5 làm fallback bao phủ rộng

Phù hợp với:

Kiểu input khó dự đoán;
Các tình huống cần bao phủ tác vụ rộng hơn như review code, JSON nghiêm ngặt, vật lý phức tạp;
Trường hợp Fable 5 bị lọc và cần tự động phục hồi request của người dùng.

Opus 5 cũng không được miễn kiểm tra. Bất thường trả câu chào trong vòng này chứng minh rằng HTTP 200 và stop vẫn có thể không có câu trả lời nghiệp vụ.

Ví dụ Python OpenAI-compatible

Ví dụ dưới đây gọi Fable 5 trước; khi gặp lọc, body rỗng hoặc không đạt nghiệm thu thì fallback sang Opus 5; nếu Opus vẫn chỉ trả câu chào, nó sẽ retry thêm một lần.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://cn.crazyrouter.com/v1",
)


def valid_answer(text: str, required_terms: tuple[str, ...]) -> bool:
    normalized = (text or "").strip()
    if not normalized:
        return False
    if normalized.lower().startswith("hi! how can i help"):
        return False
    return all(term in normalized for term in required_terms)


def call_model(model: str, prompt: str) -> tuple[str, str | None]:
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        temperature=1,
        max_tokens=3000,
    )
    choice = response.choices[0]
    return choice.message.content or "", choice.finish_reason


def routed_completion(prompt: str, required_terms: tuple[str, ...] = ()) -> str:
    for model, attempts in (("claude-fable-5", 1), ("claude-opus-5", 2)):
        for _ in range(attempts):
            text, finish_reason = call_model(model, prompt)
            if finish_reason == "content_filter":
                break
            if valid_answer(text, required_terms):
                return text
    raise RuntimeError("No model produced a valid business answer")


answer = routed_completion(
    "Return a JSON incident summary with keys total, failed, recovered.",
    required_terms=('"total"', '"failed"', '"recovered"'),
)
print(answer)

Triển khai production cũng nên ghi lại model, response ID, finish_reason, tổng độ trễ và nguyên nhân nghiệm thu thất bại. Nhờ đó, bạn có thể phân biệt mô hình tính sai, output bị cắt, nội dung bị lọc và định tuyến làm mất input, thay vì gom tất cả vào một nhãn mơ hồ là “mô hình lỗi”.

Nếu bạn đang lên kế hoạch cho hạ tầng đa mô hình, có thể tham khảo sự khác nhau giữa AI API Gateway, aggregator và API mô hình kết nối trực tiếp, cũng như kiểm thử bảy chiều Kimi K3 vs Opus 4.8.

Khuyến nghị cuối cùng

Kết luận có giá trị nhất trong vòng này không phải là ai đạt điểm cao hơn, mà là hình thái thất bại của hai mô hình khác nhau:

Lợi thế của Fable 5 là nhanh hơn và ngắn hơn trên các tác vụ chung; rủi ro là một số prompt nghiệp vụ bình thường có thể kích hoạt bộ lọc một cách ổn định.
Lợi thế của Opus 5 là bao phủ toàn bộ tác vụ sau retry; rủi ro là đôi khi trả về câu chào không liên quan đến input thật.

Vì vậy, nên đặt Fable 5 ở phía trước cho các tác vụ tần suất cao đã được xác minh, dùng Opus 5 làm fallback bao phủ rộng hơn, và thực hiện nghiệm thu cấp nội dung cho cả hai tuyến. Khi đó, kết quả so sánh mô hình mới chuyển hóa thành độ tin cậy thực tế, thay vì chỉ dừng lại ở một bảng xếp hạng.

Tạo API Key để tái hiện bộ định tuyến hai mô hình này

FAQ

Claude Opus 5 chắc chắn mạnh hơn Claude Fable 5 không?

Không thể từ mẫu nhỏ này kết luận rằng Opus mạnh hơn trên mọi tác vụ. Cả hai đều vượt qua toán, ràng buộc, sửa lỗi thống kê và thiết kế thí nghiệm; Fable 5 nhanh hơn, ngắn hơn, còn Opus 5 có mức bao phủ tác vụ đầy đủ hơn. Lựa chọn nên dựa trên tỷ lệ thành công của tác vụ cụ thể, không phải tên mô hình.

Claude Fable 5 có phù hợp với production không?

Có, với các tác vụ đã được regression test. Trong vòng này, nó trả lời đúng và khá nhanh trên nhiều loại tác vụ suy luận, nhưng review code và JSON sự cố lại liên tục kích hoạt bộ lọc. Trước khi triển khai, bạn nên dùng prompt thật để đo tỷ lệ lọc và cấu hình fallback sang Opus 5 hoặc mô hình khác.

Vì sao HTTP 200 vẫn được tính là thất bại?

HTTP 200 chỉ cho biết API đã hoàn tất response. Body rỗng, finish_reason=content_filter, output bị cắt, hoặc chỉ trả một câu chào đều không hoàn thành tác vụ nghiệp vụ. Chỉ số production nên thống kê “tỷ lệ đạt nghiệm thu”, chứ không chỉ thống kê tỷ lệ HTTP thành công.

Vì sao returned model là `anthropic/claude-fable-5`?

Request dùng claude-fable-5, còn returned model trong response ổn định là anthropic/claude-fable-5 có tiền tố provider. Có thể xem đây là alias đã chuẩn hóa; chỉ riêng thay đổi tiền tố không đủ để chứng minh đã xảy ra thay thế mô hình.

Có thể so sánh trực tiếp chi phí USD của hai mô hình không?

Trong vòng này thì không. Response của Fable 5 cung cấp trường cost, còn Opus 5 không cung cấp field cùng tiêu chuẩn. So sánh chi phí nghiêm ngặt nên lấy dữ liệu từ log tính phí thống nhất, và dùng chỉ số “chi phí trên mỗi kết quả đạt nghiệm thu”.

Nên lặp lại bao nhiêu lần trước khi quyết định triển khai?

Khuyến nghị mỗi họ tác vụ lõi lặp lại ít nhất 20–50 lần, bao phủ input bình thường, input biên, input dài và input dễ kích hoạt bộ lọc. Tối thiểu cần ghi tỷ lệ thành công tác vụ, tỷ lệ lọc, tỷ lệ body rỗng, tỷ lệ bị cắt, độ trễ P50/P95/P99 và chi phí.

Bắt đầu kiểm thử như thế nào?

Dùng https://cn.crazyrouter.com/v1 làm OpenAI-compatible base URL, rồi lần lượt gọi claude-opus-5 và claude-fable-5. Cố định prompt và tham số, lưu response gốc, sau đó dùng assertion cục bộ hoặc schema validation để xác định tác vụ có thực sự hoàn thành hay không.

Bắt đầu kiểm thử Claude hai mô hình của bạn

Claude Opus 5 vs Claude Fable 5: 7 Real API Tests and Production Routing Advice

Jenny Met — Sun, 26 Jul 2026 14:57:12 +0000

Claude Opus 5 vs Claude Fable 5: 7 Real API Tests and Production Routing Advice

How should you choose between Claude Opus 5 and Claude Fable 5? If you only look at a single successful answer, both models can produce polished mathematical derivations. In production, however, the experience is usually shaped by three other questions: can the task be delivered reliably, is latency suitable for interactive use, and can the system recover automatically after failures?

On July 25, 2026, we tested the two models across 7 task categories through the same OpenAI-compatible API, using identical prompts and parameters. The results did not fit the simplistic story that “the larger model is always better”:

claude-fable-5 was faster and more concise on tasks where both models succeeded;
claude-opus-5 ultimately covered all 7 task categories;
Fable 5 repeatedly triggered content_filter on ordinary code-review and incident-JSON prompts;
On the physics task, Opus 5 returned HTTP 200 twice but answered only with an unrelated greeting; it completed normally on the third attempt.

That means production model selection should not boil down to a single model ID. A safer pattern is: choose the primary model by task type, then wrap abnormal cases with content validation, retries, and model fallback.

Test Opus 5 and Fable 5 through the same API

Quick Takeaways

Question	Result in this round
Which model covered more tasks?	Opus 5: 6/7 in the main test, 7/7 after retry
Which model was faster?	On mutually successful tasks, Fable 5 had roughly 24% lower P50 total latency
Which model produced shorter answers?	Fable 5, with about 43% fewer average visible output tokens
Which model was better for code review and strict JSON?	Opus 5 was more stable in this round; Fable 5 was filtered 3 times in a row on both tasks
Is HTTP 200 enough?	No; both models had HTTP 200 responses that did not deliver the task
Recommended routing pattern?	Use Fable 5 first for validated tasks, fall back to Opus 5 on filtering or empty content; automatically retry Opus when it returns an abnormal greeting

If your input types are unpredictable, or if you need to minimize false filtering on ordinary business prompts, Opus 5 deserves priority. If the task structure is fixed, has already been regression-tested, and interactive speed and output length matter more, Fable 5 is a better first hop.

How We Tested

Before testing, we called the model-list endpoint to confirm that both exact model IDs were visible:

GET https://cn.crazyrouter.com/v1/models

claude-opus-5
claude-fable-5

All formal requests used the same endpoint:

POST https://cn.crazyrouter.com/v1/chat/completions

The shared conditions were:

Same system prompt
Same user prompt
temperature = 1
Same max_tokens for each task
stream = true
No tools or web access enabled

The unified system prompt only asked the model to answer accurately and follow the requested format. It did not add any role framing that favored either model:

Answer the user's task accurately. Follow every requested output format and length constraint exactly. Do not use external tools.

We recorded more than the final text:

HTTP status and finish_reason;
response ID and returned model;
time to first visible token and total latency;
completion tokens and reasoning tokens;
whether the visible answer satisfied task-level acceptance checks;
whether abnormal requests recovered when retried with the same parameters.

This is an end-to-end Crazyrouter gateway test, not an experiment pinned to a single upstream channel. The results therefore reflect model behavior, upstream filtering, gateway routing, and the channel state at that moment. They are useful for answering “what will users actually encounter through this API,” not for constructing a pure offline capability leaderboard for the Claude family.

For more on why model tests must record finish_reason and output budget, see the Claude Fable 5 vs GPT-5.5 max_tokens retest.

Summary Table for the 7 Tasks

Test dimension	Claude Opus 5	Claude Fable 5	Production impact
Exact math: Markov chain	Passed	Passed	Both produced the correct first moment, second moment, and variance
Numerical physics: coupled oscillator	First two attempts returned only a greeting; third attempt passed	Passed on the first run	Opus needs content-level validation and retry
Constraint search	Passed	Passed	Both found the unique solution
Statistical correction	Passed	Passed	Both rejected the false premise and gave the correct upper bound
Python code review	Passed	`content_filter` 3 times in a row	Fable is not currently suitable for unvalidated code-review traffic
Strict JSON incident summary	Passed	`content_filter` 3 times in a row	Fable is not currently suitable for this type of production incident text
Experimental design	Passed	Passed	Both identified the unpaired samples and difficulty confounding

One-shot delivery rate in the main test:

Claude Opus 5: 6 / 7 = 85.7%
Claude Fable 5: 5 / 7 = 71.4%

After retry:

Claude Opus 5: 7 / 7
Claude Fable 5: 5 / 7

Here, “delivery” does not mean the request succeeded. It means the business received a visible answer that satisfied the task requirements. If HTTP 200, the model name, and token usage are present but the body is empty, filtered, or only returns a greeting, the task still counts as failed.

Math, Constraints, and Statistics: Both Models Were Reliable

The math task used a three-state Markov chain and asked for the waiting time until first reaching state 3 from state 1:

E1[τ]
E1[τ²]
Var1(τ)

Both models returned:

E1[τ] = 5
E1[τ²] = 43
Var1(τ) = 18

They also wrote out the transient matrix Q and the equations for the first and second moments. This was not a case where the final numbers were correct but the derivation was inconsistent.

The constraint-search task asked the model to place talks A, B, C, D, and E into five time slots while satisfying adjacency, ordering, gap, and non-adjacency constraints. Both models found the unique sequence:

A, C, E, B, D

The statistical-correction task deliberately supplied a false conclusion: “The mean is 10 and the variance is 4, so P(X≥14)=0.5.” Both models noted that two moments are insufficient to uniquely determine the tail probability, and used the one-sided Chebyshev/Cantelli inequality to obtain:

P(X >= 14) <= 0.2

These three task types show that Fable 5’s speed advantage did not come from sacrificing basic reasoning correctness. On clear, short, verifiable math and logic tasks, it can work well as the lighter first hop.

Earlier tests, including Claude Fable 5 vs Claude Sonnet 5 API testing and the GLM-5.2 vs Fable 5 output-budget test, point to the same lesson: to judge whether a model is production-ready, you have to evaluate correctness, output budget, and delivery shape together.

Physics: Fable Completed on the First Run, Opus Recovered on the Third

The physics task involved a two-degree-of-freedom oscillator with ground damping and coupling damping. The model had to compute the two undamped natural frequencies and the complex frequency response of the two masses at ω=8 rad/s.

The reference values were:

ω1 = 10.0204 rad/s
ω2 = 16.2149 rad/s
|X1| = 0.14929 m, phase = -12.15°
|X2| = 0.07174 m, phase = -13.90°

Fable 5 returned all correct results on the first run. Opus 5, however, showed an anomaly that production teams should pay attention to: the API returned HTTP 200 and finish_reason=stop, but the body contained only:

Hi! How can I help you today?

The prompt token counts for both of those responses were only 10, which clearly did not match the real input. On the third execution of the same request, Opus 5 returned a complete answer after 34.901 seconds, and all six numeric values passed validation.

This should not be classified as “the model got the physics wrong.” It is better understood as “the request context was not processed normally.” The simplest protection is not manual log inspection, but task-level validation at the caller: the answer must contain ω1, ω2, X1, and X2; if any field is missing, retry.

Code and Strict JSON: Fable’s Filtering Was the Biggest Difference in This Round

The code task asked the model to review a Python DFS cycle detector. The bug was ordinary: after completing DFS for a node, the code failed to remove it from the visiting set, so a completed node could still be mistaken for a node on the recursion stack, causing false cycle reports on a DAG.

Opus 5 correctly identified the minimal fix:

visiting.discard(node)
visited.add(node)
return False

Fable 5 did not return code analysis. Instead, it produced finish_reason=content_filter with an empty body. To rule out system-prompt bias and one-off routing effects, we ran three rounds: the original test, a retest with a clean system prompt, and an independent single-task retry. All three ended with content_filter.

The strict JSON task also contained no dangerous content. The input only listed request totals over 15 minutes, failures, channel attribution, retries that recovered, and mitigation actions, and asked for a JSON object. Opus 5 returned JSON that could be parsed directly; Fable 5 was again filtered 3 times in a row.

These two failures underline a production point: safety filtering itself is part of a model API’s production capability. If a model consistently false-filters ordinary code review or incident-review text, it cannot simply take over all business traffic, even if it is faster on math tasks.

The response ID values for the two independent retries were:

Code review: gen-1784915384-vGI1PtuNXZG0IJ2YiaCz
Incident JSON: gen-1784915390-buOWZQSnqjgHeJ6nUogF

Latency and Output Length

To avoid counting short failed requests as a “speed advantage,” this section compares only the four tasks where both models succeeded: math, constraint search, statistical correction, and experimental design.

Metric	Claude Opus 5	Claude Fable 5
P50 total latency	10.729 s	8.147 s
P50 first visible token	8.376 s	6.974 s
Average visible completion tokens	797.5	452.3

In this small sample, Fable 5 had about 24% lower P50 total latency, about 17% lower time to first visible token, and about 43% shorter answers. For chat, batch summarization, and high-frequency structured tasks, those differences directly affect user wait time and downstream processing volume.

But do not turn the median of 4 tasks into an SLA. Upstream load, caching, routing, and rate limiting can all change latency. Before going live, repeat the test 20–50 times with your own business prompts, then calculate P50, P95, P99, and the real cost per accepted result.

Fable 5’s main-test responses provided a cost field, totaling about $0.24596 across 7 calls. Opus 5’s usage did not provide a same-basis cost field, so this article does not declare a dollar-cost winner. A missing field does not mean free usage, and unverified prices should not be used to fill the gap.

Recommended Production Routing Strategy

A single-model call is the easiest to implement, but it exposes every model anomaly directly to the end user. For the two models in this round, a more reasonable division of labor is as follows.

Fable 5 as the First Hop

Suitable for:

Math, constraint reasoning, and short summaries that have passed regression tests;
Interactions sensitive to first-token latency and overall latency;
Tasks where shorter answers reduce downstream processing burden.

The prerequisite is that the task family has already been tested for filtering, and the caller checks for content_filter, empty bodies, and missing required fields.

Opus 5 as the High-Coverage Fallback

Suitable for:

Unpredictable input types;
Scenarios that require broader task coverage, such as code review, strict JSON, and complex physics;
Cases where Fable 5 is filtered and the user request needs to be recovered automatically.

Opus 5 still should not be trusted without validation. The greeting anomaly in this round shows that HTTP 200 plus stop can still fail to produce a business answer.

OpenAI-Compatible Python Example

The example below calls Fable 5 first, falls back to Opus 5 on filtering, empty content, or failed validation, and retries once more if Opus only returns a greeting.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://cn.crazyrouter.com/v1",
)


def valid_answer(text: str, required_terms: tuple[str, ...]) -> bool:
    normalized = (text or "").strip()
    if not normalized:
        return False
    if normalized.lower().startswith("hi! how can i help"):
        return False
    return all(term in normalized for term in required_terms)


def call_model(model: str, prompt: str) -> tuple[str, str | None]:
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        temperature=1,
        max_tokens=3000,
    )
    choice = response.choices[0]
    return choice.message.content or "", choice.finish_reason


def routed_completion(prompt: str, required_terms: tuple[str, ...] = ()) -> str:
    for model, attempts in (("claude-fable-5", 1), ("claude-opus-5", 2)):
        for _ in range(attempts):
            text, finish_reason = call_model(model, prompt)
            if finish_reason == "content_filter":
                break
            if valid_answer(text, required_terms):
                return text
    raise RuntimeError("No model produced a valid business answer")


answer = routed_completion(
    "Return a JSON incident summary with keys total, failed, recovered.",
    required_terms=('"total"', '"failed"', '"recovered"'),
)
print(answer)

A production implementation should also log the model, response ID, finish_reason, total latency, and the reason validation failed. That is how you distinguish calculation errors, output truncation, content filtering, and routing that lost the input, instead of collapsing all of them into a vague “model failure.”

If you are planning multi-model infrastructure, see the differences between an AI API gateway, an aggregator, and direct model APIs, as well as the seven-dimension Kimi K3 vs Opus 4.8 test.

Final Recommendation

The most useful finding in this round is not which model scored higher, but that the two models failed in different ways:

Fable 5’s advantage was that it was faster and shorter on shared successful tasks; its risk was that some ordinary business prompts repeatedly triggered filtering.
Opus 5’s advantage was that it covered all tasks after retry; its risk was occasional greetings unrelated to the real input.

So the recommendation is to put Fable 5 in front of validated high-frequency tasks, use Opus 5 as the broader-coverage fallback, and apply content-level validation on both paths. That is how model-comparison results become real reliability improvements, instead of just another leaderboard.

Create an API Key and reproduce this dual-model routing test

FAQ

Is Claude Opus 5 always stronger than Claude Fable 5?

This small sample does not support the claim that it is stronger on every task. Both models passed math, constraints, statistical correction, and experimental design; Fable 5 was faster and shorter, while Opus 5 had more complete task coverage. The choice should be based on task-specific success rates, not the model name.

Is Claude Fable 5 suitable for production?

It is suitable for tasks that have passed regression testing. In this round, it was correct and relatively fast on several reasoning tasks, but code review and incident JSON repeatedly triggered filtering. Before launch, test the filtering rate with real prompts and configure Opus 5 or another model as fallback.

Why is HTTP 200 still considered a failure?

HTTP 200 only means the interface completed a response. An empty body, finish_reason=content_filter, truncated output, or a greeting-only answer still cannot complete the business task. Production metrics should track the acceptance pass rate, not just the HTTP success rate.

Why is the returned model `anthropic/claude-fable-5`?

The request used claude-fable-5, while the returned model in responses was consistently anthropic/claude-fable-5 with a provider prefix. This can be treated as a normalized alias; the prefix change alone is not enough evidence that a model substitution occurred.

Can we directly compare the dollar cost of the two models?

Not in this round. Fable 5’s responses provided a cost field, while Opus 5 did not provide a same-basis field. A rigorous cost comparison should use unified billing logs and measure “cost per accepted result.”

How many repetitions are needed before launch?

For each core task family, run at least 20–50 repetitions, covering normal inputs, boundary inputs, long inputs, and inputs likely to trigger filtering. At minimum, record task success rate, filtering rate, empty-body rate, truncation rate, P50/P95/P99 latency, and cost.

How do I start testing?

Use https://cn.crazyrouter.com/v1 as the OpenAI-compatible base URL, and call claude-opus-5 and claude-fable-5 separately. Keep prompts and parameters fixed, save the raw responses, and use local assertions or schema validation to determine whether the task was actually completed.

Start your Claude dual-model test

Kimi K3 so với GPT-5.6-SOL: thử sức thực chiến mức khó cao về toán, vật lý và lập trình

Jenny Met — Sat, 18 Jul 2026 01:17:19 +0000

Kimi K3 so với GPT-5.6-SOL: thử sức thực chiến mức khó cao về toán, vật lý và lập trình

Lần này mình không test mấy câu hỏi đáp đơn giản, mà chốt hẳn ba bài cần suy luận nhiều bước: một bài xác suất có mẫu chồng lấp và moment bậc hai, một bài vật lý có mô-men quán tính của ròng rọc và chuyển trạng thái do dây chùng sau khi chạm đất, và một bài Python phụ thuộc vào closure, dung lượng nhiều ngày và tie-break ba tầng. Hai model dùng cùng một interface, cùng prompt và mức output cap gần tương đương, không bật tool và không dùng internet.

Kết luận ngắn gọn trước:

gpt-5.6-sol trả lời trọn vẹn ở cả ba bài, và kết quả tham chiếu cho toán lẫn vật lý đều đúng.
kimi-k3 ở mức trần 6500 token vòng đầu thì cả toán và vật lý đều kết thúc với finish_reason=length, phần nhìn thấy trống rỗng; riêng bài toán, tăng trần lên 10000 vẫn bị cắt cụt. Bài lập trình thì sau khoảng 245 giây bị đọc timeout.
Phần triển khai lập trình của GPT-5.6-SOL vượt qua các kiểm tra bổ sung độc lập về closure phụ thuộc, dung lượng, tie-break, dependency không hợp lệ và vòng lặp phụ thuộc, nhưng chính nó lại kèm một assert mẫu đầu tiên có expected value sai. Điều này cho thấy “thân code đúng” và “mọi test ví dụ đều đúng” là hai việc phải kiểm riêng.

Độ trễ trong bài viết này là giá trị quan sát được của lần request này, không đại diện cho SLA cố định. Ở lượt đồng thời đầu tiên, request toán và vật lý của GPT từng nhận HTTP 408, sau đó mình chuyển sang retry tuần tự; vì vậy tốc độ chỉ dùng để quan sát trải nghiệm gọi API, không dùng để tuyên bố xếp hạng tuyệt đối.

Thiết lập test

Thời điểm test là từ giờ Bắc Kinh 2026-07-17 đến 2026-07-18, interface là:

POST https://cn.crazyrouter.com/v1/chat/completions
model: kimi-k3 / gpt-5.6-sol
temperature: 0.2

Lượt đầu tiên dùng thống nhất: toán và vật lý max_tokens=6500, lập trình max_tokens=7500. Mỗi bài đều yêu cầu model đưa ra suy diễn có thể kiểm tra lại hoặc code có thể chạy, đồng thời ghi lại finish_reason, completion/reasoning token, độ trễ request, độ đúng số học và việc code có chạy độc lập được trong Python 3.11 hay không.

Bảng tổng kết kết quả

Task	kimi-k3	gpt-5.6-sol	Kết luận
Toán: kỳ vọng và phương sai của HHTH	`length`, 186.98 s, 6500 tokens; nội dung nhìn thấy trống	Retry tuần tự `stop`, 236.07 s, 6872 tokens	GPT trả lời đầy đủ; Kimi vòng đầu chưa ra được đáp án
Vật lý: ròng rọc, chạm đất, lò xo	`length`, 202.05 s, 6500 tokens; nội dung nhìn thấy trống	Retry tuần tự `stop`, 156.29 s, 4501 tokens	GPT đầy đủ và đúng số
Lập trình: dependency closure knapsack	Sau 245.54 s `TimeoutError`	`stop`, 87.96 s, 4514 tokens	GPT code chạy được; Kimi chưa trả về code hoàn chỉnh
Kimi test lại môn toán	`length`, 286.99 s, 10000 tokens	—	Tăng budget vẫn chưa xong

Trong các request toán và vật lý của Kimi, reasoning token do API báo cáo lần lượt gần 6497; ở bài toán test lại, reasoning token gần 9997. Điều này không có nghĩa là Kimi không có năng lực suy luận, mà chỉ cho thấy với prompt của bài này và routing hiện tại, budget suy luận rất dễ bị hút cạn, khiến bên gọi không nhận được đáp án cuối.

Bài toán: chồng lấp mẫu không chỉ ảnh hưởng kỳ vọng, mà còn ảnh hưởng cả phương sai

Đề bài là: xác suất mặt ngửa p=3/5, xác suất mặt sấp q=2/5, tung liên tục cho đến khi lần đầu xuất hiện HHTH, cho phép chồng lấp mẫu, hãy tìm E[T] và Var(T).

Automaton tiền tố đúng có các trạng thái S0=tiền tố rỗng, S1=H, S2=HH, S3=HHT, S4=HHTH (trạng thái hấp thụ). Chuyển trạng thái quan trọng là S2 --H--> S2: khi đã có HH mà lại ra H, hậu tố dài nhất vẫn là HH, không được sai mà quay về trạng thái rỗng.

GPT-5.6-SOL lập hệ phương trình moment bậc nhất là:

M0 = 1 + p M1 + q M0
M1 = 1 + p M2 + q M0
M2 = 1 + p M2 + q M3
M3 = 1 + q M0

Tiếp tục lập hệ phương trình moment bậc hai, ta được:

E[T]   = 715/54       ≈ 13.2407407407
E[T²]  = 195335/729   ≈ 267.9492455418
Var(T) = 270115/2916  ≈ 92.6320301783

Kỳ vọng còn có thể kiểm chứng độc lập bằng công thức biên. HHTH có biên thực sự không rỗng duy nhất là một ký tự H, nên E[T] = 1/p + 1/(p³q) = 715/54. Câu trả lời đầy đủ của GPT bao gồm cả chuyển trạng thái, khai triển moment bậc hai và sanity check. Kimi ở cả mức 6500 lẫn 10000 đều không xuất ra phần suy diễn nhìn thấy được, nên lần này không thể chấm độ đúng toán của nó, chỉ có thể ghi nhận là “chưa hoàn thành trong budget”.

Bài vật lý: sau khi chạm đất, ràng buộc bị ngắt, không thể bê nguyên phương trình năng lượng cũ

Đề bài đặt như sau: m_A=4.0 kg nằm trên mặt phẳng nghiêng nhám 25°, μ_k=0.18; m_B=3.0 kg treo; ròng rọc có M_p=1.2 kg, R=0.10 m; B đi xuống 1.50 m rồi chạm đất; dây ngay lập tức chùng; A trượt lên thêm 0.10 m thì chạm lò xo k=250 N/m; g=9.8 m/s².

Trước khi chạm đất, dây căng và không trượt, khối lượng quán tính tương đương của ròng rọc là I/R²=(1/2)M_p=0.60 kg. Ghép phương trình động lực học của hai vật và phương trình quay của ròng rọc, ta được:

a  ≈ 0.847 m/s²
v1 ≈ 1.59 m/s
v2 ≈ 1.18 m/s
x  ≈ 0.0835 m = 8.35 cm

Sau khi chạm đất, vận tốc của B bị thay đổi do va chạm với mặt đất, A vẫn còn vận tốc hướng lên dọc mặt phẳng nghiêng, và ròng rọc cũng có thể tiếp tục quay; hơn nữa đề đã nói rõ dây ngay lập tức chùng, nên không thể tiếp tục dùng v_A=v_B=Rω. Giai đoạn sau chỉ nên phân tích riêng A:

v2² = v1² - 2g(sinθ + μ_k cosθ)d
1/2 m_A v2² = 1/2 kx² + m_A g(sinθ + μ_k cosθ)x

GPT-5.6-SOL còn kiểm tra cả đơn vị, khoảng dừng khi không có lò xo, và sự khớp giữa năng lượng đàn hồi với tổn hao do ma sát/trọng lực, số liệu tự nhất quán. Kimi ở lượt đầu không tạo ra đáp án nhìn thấy được nên không thể so sánh chất lượng mô hình hóa trung gian.

Bài lập trình: thân thuật toán qua kiểm độc lập, nhưng sample test của model có bug

Bài lập trình yêu cầu cài optimize_release_plan(items, capacity_by_day, dependencies), xử lý dung lượng theo ngày, ngày không cấu hình thì dung lượng bằng 0, closure phụ thuộc trực tiếp và gián tiếp, dependency không hợp lệ và phát hiện chu trình, cùng tie-break ba tầng value → risk → danh sách id đã sắp xếp. items <= 18, nên brute-force bằng bitmask là baseline hợp lý.

GPT-5.6-SOL dùng cache closure phụ thuộc và duyệt 2^n tập con. Mình tách code ra và kiểm tra độc lập trong Python 3.11: closure phụ thuộc, ví dụ dung lượng nhiều ngày, tie-break ba tầng value/risk/id, dung lượng ngày chưa cấu hình, dependency không tồn tại và dependency vòng lặp, tổng cộng 6 nhóm kiểm tra đều qua.

Nhưng ở cuối code, model lại kèm theo assert đầu tiên bị fail: nó viết A -> B -> C, đồng thời lại đưa thêm X có giá trị 11. Với dung lượng đã cho, tổng giá trị của B + C + X là 13, cao hơn A + B + C là 12, nên hàm trả về ['B', 'C', 'X'] mới là đúng; assert viết ['A', 'B', 'C'] là sai ở fixture test.

Chi tiết này khá điển hình: làm bài code không thể chỉ nhìn thân hàm, cũng không thể vì “kèm 8 assert” mà mặc nhiên tin bộ test đó. Dữ liệu test do model sinh ra cũng cần được người viết hoặc reference implementation kiểm lại. Request lập trình của Kimi K3 thì sau khoảng 245 giây bị đọc timeout, không lấy được code hoàn chỉnh.

Đánh giá tổng hợp

Khía cạnh	kimi-k3	gpt-5.6-sol
Độ đầy đủ ở bài toán	`6500/10000` token đều bị cắt, không thể nghiệm thu	Kỳ vọng, moment bậc hai, phương sai và sanity check đều đầy đủ
Mô hình hóa vật lý	Bị cắt ở vòng đầu	Xử lý đúng quán tính ròng rọc, dây chùng và giai đoạn lò xo
Bàn giao code	Lượt này timeout	Thân code qua kiểm độc lập, nhưng kèm một assert sai
Độ ổn định đầu ra	Tốn reasoning nhiều, dễ không có phần nhìn thấy	Cả ba bài retry tuần tự đều `stop`
Tốc độ phản hồi	Khoảng 187–246 s, lại còn bị cắt/timeout	Request thành công khoảng 88–236 s; lượt đầu đồng thời có 408

Kết luận chính xác hơn không phải là “model nào chắc chắn thông minh hơn”, mà là:

Với routing và budget của lần test này, GPT-5.6-SOL dễ thu gọn suy luận phức tạp thành đáp án cuối hơn, hợp với workflow cần ngay lời giải hoặc code đọc được.
Vấn đề lớn nhất của Kimi K3 là hiệu quả chuyển từ reasoning budget sang output nhìn thấy; dù tăng toán lên 10000 token, nó vẫn chưa kết thúc.
Code của GPT-5.6-SOL cũng không thể tin mù quáng. Logic hàm đã qua kiểm độc lập, nhưng bộ test đi kèm có lỗi tính giá trị.
Khi chọn cho production, nên ghi đồng thời finish_reason, reasoning token, độ trễ và kết quả test nội bộ; không thể chỉ nhìn câu cuối cùng kiểu “đáp án đúng”.

Cách tái hiện thí nghiệm

Script test và kết quả retry theo thứ tự của lần này được lưu tại (tóm tắt của lượt đồng thời đầu tiên cũng đã được ghi vào output của script):

.tmp/kimi_k3_vs_gpt56sol_test.py
.tmp/kimi-k3-vs-gpt56sol-results.json
.tmp/retry-gpt56sol-math.json
.tmp/retry-gpt56sol-physics.json
.tmp/retry-gpt56sol-programming.json
.tmp/retry-kimi-k3-math.json

Khi chạy lại, nên cố định model ID, prompt, temperature, max_tokens và mức độ đồng thời, rồi lưu riêng từng output thành file độc lập. Tải upstream, cache hit và trạng thái rate limit đều có thể ảnh hưởng đến độ trễ; trong bài này, mình ghi nhận cả HTTP 408, length và đọc timeout như một phần của kết quả test, chứ không giấu chúng đi.

Kimi K3 im Vergleich zu GPT-5.6-SOL: Praxistest bei schweren Aufgaben aus Mathematik, Physik und Programmierung

Jenny Met — Sat, 18 Jul 2026 01:15:52 +0000

Kimi K3 im Vergleich zu GPT-5.6-SOL: Praxistest bei schweren Aufgaben aus Mathematik, Physik und Programmierung

Diesmal geht es nicht um einfache Q&A, sondern um drei fest definierte Aufgaben, die mehrstufiges Schlussfolgern verlangen: eine Wahrscheinlichkeitsaufgabe mit Musterüberlappung und zweitem Moment, eine Physikaufgabe mit Trägheitsmoment der Rolle und Umschalten durch Seilentspannung sowie eine Python-Aufgabe mit Closure, mehrtägigen Kapazitäten und dreistufigem Tie-Break. Beide Modelle liefen über dieselbe Schnittstelle, mit demselben Prompt und vergleichbaren Ausgabelimits, ohne Tools und ohne Internetzugriff.

Vorab das Ergebnis:

gpt-5.6-sol lieferte bei allen drei Aufgaben vollständige sichtbare Antworten; die Referenzwerte in Mathematik und Physik waren korrekt.
kimi-k3 endete unter dem ersten 6500-Token-Limit bei Mathematik und Physik jeweils mit finish_reason=length; die sichtbare Antwort blieb leer. Selbst nach Erhöhung des Limits auf 10000 bei der Matheaufgabe wurde der Output wieder abgeschnitten. Die Programmieraufgabe lief nach rund 245 Sekunden in einen Read-Timeout.
Die Programmierimplementierung von GPT-5.6-SOL bestand unabhängige Zusatzprüfungen zu Dependency-Closure, Kapazität, Tie-Break, ungültigen Abhängigkeiten und Zyklen. Allerdings war die erste mitgelieferte Assertions-Beispielprüfung mit einem falschen Erwartungswert versehen. Das zeigt: „Kernlogik korrekt“ und „alle Beispieltests korrekt“ sind getrennt zu bewerten.

Die hier gemessene Latenz ist der beobachtete Wert dieser Anfrage und kein fester SLA-Wert. In den ersten parallelen Requests erhielt GPT für Mathematik und Physik zunächst HTTP 408; danach wurde sequenziell erneut versucht. Daher dient die Geschwindigkeit hier nur der Beobachtung der Nutzungserfahrung, nicht als absoluter Rangvergleich.

Testaufbau

Getestet wurde vom 2026-07-17 bis 2026-07-18 (Beijing-Zeit), über:

POST https://cn.crazyrouter.com/v1/chat/completions
model: kimi-k3 / gpt-5.6-sol
temperature: 0.2

In der ersten Runde galten einheitlich: Mathematik und Physik max_tokens=6500, Programmierung max_tokens=7500. Jede Aufgabe verlangte entweder eine überprüfbare Herleitung oder ausführbaren Code. Zusätzlich wurden finish_reason, completion/reasoning tokens, Request-Latenz, numerische Korrektheit sowie die eigenständige Ausführbarkeit in Python 3.11 protokolliert.

Gesamtergebnis-Tabelle

Aufgabe	kimi-k3	gpt-5.6-sol	Beurteilung
Mathematik: Erwartungswert und Varianz von HHTH	`length`, 186.98 s, 6500 tokens; sichtbarer Inhalt leer	sequenzieller Retry `stop`, 236.07 s, 6872 tokens	GPT vollständig; Kimi in Runde 1 ohne Antwort
Physik: Rolle, Bodenkontakt, Feder	`length`, 202.05 s, 6500 tokens; sichtbarer Inhalt leer	sequenzieller Retry `stop`, 156.29 s, 4501 tokens	GPT vollständig und numerisch korrekt
Programmierung: Dependency-Closure-Rucksackproblem	nach 245.54 s `TimeoutError`	`stop`, 87.96 s, 4514 tokens	GPT-Code lauffähig; Kimi gab keinen vollständigen Code zurück
Kimi Mathe-Repeat	`length`, 286.99 s, 10000 tokens	—	Auch mit höherem Budget kein Abschluss

Bei Kimi meldete die Schnittstelle für Mathematik und Physik jeweils einen reasoning token-Wert nahe 6497; beim Mathe-Repeat lag er nahe 9997. Das heißt nicht, dass Kimi keine Schlussfolgerungsfähigkeit hat, sondern dass unter diesem Prompt und über diesen Router das Reasoning-Budget sehr leicht aufgebraucht wird und der Auftraggeber am Ende keine finale Antwort erhält.

Mathematikaufgabe: Musterüberlappung beeinflusst nicht nur den Erwartungswert, sondern auch die Varianz

Die Aufgabe lautet: Bei Kopf-Wahrscheinlichkeit p=3/5 und Zahl-Wahrscheinlichkeit q=2/5 wird so lange geworfen, bis erstmals HHTH erscheint, wobei Überlappungen erlaubt sind. Gesucht sind E[T] und Var(T).

Die korrekten Präfix-Automat-Zustände sind S0=leeres Präfix, S1=H, S2=HH, S3=HHT, S4=HHTH (absorbierender Zustand). Der entscheidende Übergang ist S2 --H--> S2: Nach HH bleibt bei erneutem H der längste Suffix weiterhin HH; man darf also nicht fälschlich auf den Leerzustand zurückfallen.

Die von GPT-5.6-SOL aufgestellten Gleichungen für das erste Moment waren:

M0 = 1 + p M1 + q M0
M1 = 1 + p M2 + q M0
M2 = 1 + p M2 + q M3
M3 = 1 + q M0

Nach Aufstellen der Gleichungen für das zweite Moment ergibt sich:

E[T]   = 715/54       ≈ 13.2407407407
E[T²]  = 195335/729   ≈ 267.9492455418
Var(T) = 270115/2916  ≈ 92.6320301783

Der Erwartungswert lässt sich außerdem unabhängig über die Randformel gegenprüfen. Die nichtleeren echten Ränder von HHTH bestehen aus dem Einzelzeichen H, daher gilt E[T] = 1/p + 1/(p³q) = 715/54. Die vollständige GPT-Antwort deckte Zustandsübergänge, die Herleitung des zweiten Moments und den Sanity Check ab. Kimi lieferte weder bei 6500 noch bei 10000 Tokens eine sichtbare Herleitung, daher lässt sich die mathematische Korrektheit in dieser Runde nicht bewerten; es bleibt bei „innerhalb des Budgets nicht abgeschlossen“.

Physikaufgabe: Nach dem Bodenkontakt reißt die Zwangsbedingung, dieselbe Energiebilanz gilt dann nicht mehr

Gegeben sind: m_A=4.0 kg auf einer rauen Ebene mit 25°, μ_k=0.18; m_B=3.0 kg hängt frei; die Rolle hat M_p=1.2 kg, R=0.10 m; nach dem Absenken um 1.50 m trifft B auf den Boden und das Seil wird sofort locker; A gleitet danach noch 0.10 m nach oben und trifft auf eine Feder mit k=250 N/m; g=9.8 m/s².

Vor dem Bodenkontakt ist das Seil gespannt und es gibt kein Schlupfen. Die äquivalente Trägheitsmasse der Rolle ist I/R²=(1/2)M_p=0.60 kg. Aus der gemeinsamen Bewegung von beiden Massen und der Rotationsgleichung der Rolle folgt:

a  ≈ 0.847 m/s²
v1 ≈ 1.59 m/s
v2 ≈ 1.18 m/s
x  ≈ 0.0835 m = 8.35 cm

Nach dem Bodenkontakt ändert sich die Geschwindigkeit von B durch den Aufprall am Boden, A besitzt weiterhin eine Geschwindigkeit entlang der schiefen Ebene nach oben, und auch die Rolle kann sich noch weiterdrehen. Da die Aufgabe ausdrücklich sagt, dass das Seil sofort locker wird, darf man v_A=v_B=Rω nicht einfach weiterverwenden. Danach ist nur noch A separat zu betrachten:

v2² = v1² - 2g(sinθ + μ_k cosθ)d
1/2 m_A v2² = 1/2 kx² + m_A g(sinθ + μ_k cosθ)x

GPT-5.6-SOL prüfte zusätzlich die Dimensionen, die Stoppstrecke ohne Feder sowie die Konsistenz zwischen Federenergie und den Verlusten durch Reibung und Gewichtskraft. Die Zahlen stimmen in sich. Kimi erzeugte in der ersten Runde keine sichtbare Antwort, daher gibt es keinen Vergleich der Zwischenschritte.

Programmieraufgabe: Der Algorithmuskern ist nach unabhängiger Prüfung ok, aber das Modell brachte einen fehlerhaften eigenen Test mit

Die Programmieraufgabe verlangte die Implementierung von optimize_release_plan(items, capacity_by_day, dependencies). Berücksichtigt werden mussten Tageskapazitäten, Kapazität 0 für nicht konfigurierte Tage, transitive Dependency-Closure, ungültige Abhängigkeiten und Zyklenerkennung sowie ein dreistufiger Tie-Break über value → risk → sortierte id-Liste. Da items <= 18 ist, ist eine Bitmasken-Enumeration ein vernünftiger Ausgangspunkt.

GPT-5.6-SOL verwendete gecachte Dependency-Closure und eine 2^n-Teilmenge-Enumeration. Wir haben den Code herausgelöst und in Python 3.11 unabhängig geprüft: Dependency-Closure, Mehrtages-Kapazitätsbeispiele, die dreistufige Tie-Break-Reihenfolge value/risk/id, nicht konfigurierte Tageskapazität, nicht vorhandene Abhängigkeiten und Zyklusabhängigkeiten – alle 6 Prüfungen bestanden.

Allerdings schlug die erste im Code angehängte Assertion fehl: Dort stand A -> B -> C, gleichzeitig war aber noch X mit Wert 11 enthalten. Unter der gegebenen Kapazität beträgt der Gesamtwert von B + C + X 13 und liegt damit über A + B + C mit 12. Daher ist ['B', 'C', 'X'] korrekt; die Assertion mit ['A', 'B', 'C'] war ein Fehler im Test-Setup.

Dieses Detail ist sehr typisch: Bei Codeaufgaben darf man nicht nur auf die Funktionslogik schauen, und man sollte auch nicht allein wegen „8 beigefügten Assertions“ die Tests für vertrauenswürdig halten. Auch vom Modell erzeugte Testdaten brauchen eine manuelle oder referenzbasierte Gegenprüfung. Der Programmier-Request von Kimi K3 lief nach rund 245 Sekunden in einen Read-Timeout, sodass kein vollständiger Code vorlag.

Gesamtbewertung

Dimension	kimi-k3	gpt-5.6-sol
Mathematische Vollständigkeit	bei `6500/10000` Token jeweils abgeschnitten, keine Abnahme möglich	Erwartungswert, zweites Moment, Varianz und Sanity Check vollständig
Physikalisches Modellieren	in Runde 1 abgeschnitten	Rolle mit Trägheit, Seilentspannung und Federphase korrekt behandelt
Code-Lieferung	in dieser Runde Timeout	Kernlogik bestand unabhängige Prüfung, aber eine beigefügte Assertion war falsch
Ausgabe-Stabilität	hoher Reasoning-Verbrauch, sichtbare Antwort oft nicht verfügbar	bei allen drei Aufgaben sequenzieller Retry mit `stop`
Reaktionsgeschwindigkeit	ca. 187–246 s, dazu Abschneiden/Timeout	erfolgreiche Requests ca. 88–236 s; in der ersten parallelen Runde HTTP 408

Die treffendere Schlussfolgerung lautet also nicht „ein Modell ist generell klüger“, sondern:

Unter diesem Router und Budget bringt GPT-5.6-SOL komplexes Reasoning eher bis zu einer finalen Antwort und eignet sich damit besser für Workflows, die sofort lesbare Herleitungen oder Code benötigen.
Das Hauptproblem von Kimi K3 liegt in der Umwandlung von Reasoning-Budget in sichtbare Ausgabe; selbst bei 10000 Tokens in der Matheaufgabe kam kein Abschluss zustande.
Auch GPT-5.6-SOL darf man beim Code nicht blind vertrauen. Die Funktionslogik war unabhängig korrekt, aber das mitgelieferte Test-Setup hatte einen Fehler bei der Wertberechnung.
Für eine belastbare Produktionsentscheidung sollten finish_reason, reasoning tokens, Latenz und lokale Testergebnisse immer gemeinsam erfasst werden. Es reicht nicht, nur den letzten Satz „Antwort ist korrekt“ zu betrachten.

Reproduktion

Die Testskripte und die Ergebnisse der sequenziellen Retries sind hier abgelegt (inklusive des in der ersten parallelen Runde erzeugten Summaries im Skript-Output):

.tmp/kimi_k3_vs_gpt56sol_test.py
.tmp/kimi-k3-vs-gpt56sol-results.json
.tmp/retry-gpt56sol-math.json
.tmp/retry-gpt56sol-physics.json
.tmp/retry-gpt56sol-programming.json
.tmp/retry-kimi-k3-math.json

Für eine erneute Messung empfiehlt es sich, Modell-ID, Prompt, temperature, max_tokens und Parallelitätsgrad zu fixieren und jede Ausgabe separat zu speichern. Last auf dem Upstream-Kanal, Cache-Treffer und Rate-Limiting-Zustand beeinflussen die Latenz; in diesem Artikel wurden HTTP 408, length und Read-Timeout ausdrücklich als Teil des Testergebnisses protokolliert und nicht ausgeblendet.

Kimi K3 と GPT-5.6-SOL の比較：数学・物理・プログラミングの高難度実測

Jenny Met — Sat, 18 Jul 2026 01:14:30 +0000

Kimi K3 と GPT-5.6-SOL の比較：数学・物理・プログラミングの高難度実測

今回は簡単なQ&Aではなく、連続推論が必要な3問に固定しました。具体的には、パターン重なりと二次モーメントを含む確率問題、滑車の回転慣性と糸のたるみへの切り替えが入る物理問題、そして closure、多日容量、3段階の tie-break に依存する Python 問題です。両モデルには同じインターフェース、同じプロンプト、近い出力上限を使い、ツールもネット接続も有効化していません。

先に結論だけまとめます。

gpt-5.6-sol は3問すべてで完全な可視回答を返し、数学と物理の参照結果も正しかったです。
kimi-k3 は初回の 6500 token 上限では、数学と物理のどちらも finish_reason=length で終了し、可視回答は空でした。数学は上限を 10000 に上げてもなお途中で切れました。プログラミング問題は約 245 秒後に read timeout になりました。
GPT-5.6-SOL のプログラミング実装は、依存関係の閉包、多日容量、tie-break、無効な依存、循環依存の独立追加チェックをすべて通過しましたが、自身が添付した最初の assert サンプルには期待値の誤りがありました。つまり、「コード本体が正しい」ことと「サンプルテストも全部正しい」ことは分けて評価する必要があります。

なお、ここでの遅延は今回のリクエストで観測された値であり、固定SLAを意味しません。初回の並列リクエストでは GPT の数学と物理が HTTP 408 を返したため、その後は順次リトライに切り替えました。したがって速度はあくまで呼び出し体験の観測値であり、絶対的な順位づけには使っていません。

テスト設定

テスト日時は北京時間 2026-07-17 から 2026-07-18、インターフェースは以下です。

POST https://cn.crazyrouter.com/v1/chat/completions
model: kimi-k3 / gpt-5.6-sol
temperature: 0.2

初回は共通で、数学と物理は max_tokens=6500、プログラミングは max_tokens=7500 としました。各問題では、検算可能な導出または実行可能コードの提示を求め、finish_reason、completion/reasoning token、リクエスト遅延、数値の正しさ、そしてコードが Python 3.11 で独立実行できるかを記録しました。

結果サマリー

タスク	kimi-k3	gpt-5.6-sol	判定
数学：HHTH の期待値と分散	`length`，186.98 s，6500 tokens；可視内容は空	順次リトライ `stop`，236.07 s，6872 tokens	GPT は完全回答；Kimi は初回で答案形成に至らず
物理：滑車、着地、ばね	`length`，202.05 s，6500 tokens；可視内容は空	順次リトライ `stop`，156.29 s，4501 tokens	GPT は完全で数値も正確
プログラミング：依存閉包バックパック	245.54 s 後に `TimeoutError`	`stop`，87.96 s，4514 tokens	GPT のコードは実行可能；Kimi は完全なコードを返さず
Kimi 数学再測定	`length`，286.99 s，10000 tokens	—	予算を増やしても終了せず

Kimi の数学と物理のリクエストでは、インターフェース上の reasoning token がそれぞれ 6497 前後でした。数学再測定では reasoning token が 9997 前後でした。これは Kimi に推論力がないという意味ではなく、この問題設定と現在のルーティングでは推論予算を使い切りやすく、呼び出し側が最終答案を受け取れないことを示しています。

数学問題：パターン重なりは期待値だけでなく分散にも効く

問題は、正面確率 p=3/5、裏面確率 q=2/5 のコインを投げ続け、HHTH が初めて現れるまでの回数を T としたときの E[T] と Var(T) を求めるものです。パターン重なりは許されます。

正しい前方オートマトンの状態は S0=空前缀、S1=H、S2=HH、S3=HHT、S4=HHTH（吸収状態） です。重要なのは S2 --H--> S2 という遷移で、HH の後にさらに H が出ても、最長接尾辞は依然として HH であり、誤って空状態へ戻してはいけません。

GPT-5.6-SOL が立てた一次モーメント方程式は次のとおりです。

M0 = 1 + p M1 + q M0
M1 = 1 + p M2 + q M0
M2 = 1 + p M2 + q M3
M3 = 1 + q M0

さらに二次モーメント方程式を立てると、次が得られます。

E[T]   = 715/54       ≈ 13.2407407407
E[T²]  = 195335/729   ≈ 267.9492455418
Var(T) = 270115/2916  ≈ 92.6320301783

期待値は境界公式でも独立に検算できます。HHTH の非空真の境界は単一文字 H なので、E[T] = 1/p + 1/(p³q) = 715/54 です。GPT の完全回答は、状態遷移、二次モーメントの展開、sanity check まで一通り含んでいました。Kimi は 6500 と 10000 のどちらの上限でも可視的な導出を出せなかったため、今回は数学の正確性を採点できず、「予算内で未完了」と記録しています。

物理問題：着地後は拘束が切れるので、同じエネルギー方程式をそのまま延長してはいけない

設定は次のとおりです。m_A=4.0 kg は 25° の粗い斜面上、μ_k=0.18。m_B=3.0 kg は吊り下げ。滑車は M_p=1.2 kg、R=0.10 m。B が 1.50 m 下降したあとに地面へ接触し、糸は直ちにたるみます。その後 A はさらに 0.10 m だけ斜面上方へ滑って k=250 N/m のばねに接触します。g=9.8 m/s² です。

着地前は、糸は張っていて滑りなしなので、滑車の等価慣性質量は I/R²=(1/2)M_p=0.60 kg です。2物体と滑車の回転方程式を連立すると、次のようになります。

a  ≈ 0.847 m/s²
v1 ≈ 1.59 m/s
v2 ≈ 1.18 m/s
x  ≈ 0.0835 m = 8.35 cm

着地後は、B の速度は地面との衝突で変化し、A はなお斜面上向きの速度を持ち、滑車も回転を続ける可能性があります。しかし問題文では糸が直ちにたるむと明記されているため、v_A=v_B=Rω はもう使えません。以後は A のみを解析すべきです。

v2² = v1² - 2g(sinθ + μ_k cosθ)d
1/2 m_A v2² = 1/2 kx² + m_A g(sinθ + μ_k cosθ)x

GPT-5.6-SOL は、次元整合性、ばねなしでの停止距離、ばねのエネルギーと摩擦・重力損失の和まで確認しており、数値的にも整合していました。Kimi は初回で可視回答を出せなかったため、中間のモデリング品質は比較できませんでした。

プログラミング問題：アルゴリズム本体は独立検証で通過、ただしモデル付属サンプルにバグあり

この問題は optimize_release_plan(items, capacity_by_day, dependencies) を実装し、日別容量、未設定日の容量は 0、直接・間接依存の閉包、無効な依存と循環検出、さらに value → risk → ソート済み id 列表 の3段階 tie-break を扱う必要があります。items <= 18 なので、bitmask 総当たりは妥当なベースラインです。

GPT-5.6-SOL は依存閉包キャッシュと 2^n の部分集合列挙を使っていました。コードを抽出し、Python 3.11 で独立検査を行ったところ、依存閉包、多日容量サンプル、value/risk/id の3段階 tie-break、未設定日の容量、依存なしケース、循環依存の6組すべてが通過しました。

ただし、モデルがコード末尾に付けた最初の assert は失敗しました。そこでは A -> B -> C を前提にしつつ、価値 11 の X も入れていました。与えられた容量では、B + C + X の総価値は 13 で、A + B + C の 12 より大きいので、関数が ['B', 'C', 'X'] を返すのが正解です。['A', 'B', 'C'] と書かれた assert はテストフィクスチャの誤りです。

この点はかなり示唆的です。コード問題は関数本体だけ見ればよいわけでもなく、逆に「8個のassertが付いているからテストも正しい」とは限りません。モデル生成のテストデータも、人手または参照実装で検証する必要があります。Kimi K3 のプログラミングリクエストは約 245 秒後に read timeout となり、完全なコードは取得できませんでした。

総合評価

観点	kimi-k3	gpt-5.6-sol
数学の完全性	`6500/10000` token ともに途中終了、検収不可	期待値、二次モーメント、分散、sanity check が揃っている
物理モデリング	初回で途中終了	滑車慣性、糸のたるみ、ばね段階を正しく処理
プログラミング納品	今回は timeout	コード本体は独立検査を通過したが、付属の assert に誤りあり
出力安定性	reasoning 消費が大きく、可視回答を得にくい	3問すべて順次リトライで `stop`
応答速度	約 187–246 s で、しかも途中終了/timeout あり	成功したリクエストは約 88–236 s；並列初回は 408 あり

より正確に言うと、結論は「どちらか一方が絶対的に賢い」という話ではありません。

今回のルーティングと予算では、GPT-5.6-SOL のほうが複雑な推論を最終答案までまとめやすく、すぐ読める導出やコードが必要なワークフローに向いています。
Kimi K3 の主な課題は、推論予算を可視出力へ変換する効率です。数学問題で 10000 token に増やしても、なお完了しませんでした。
GPT-5.6-SOL のコードも盲信は禁物です。関数ロジックは独立検査を通っても、付属テストフィクスチャに価値計算ミスがありました。
本番導入の選定では、finish_reason、reasoning token、遅延、ローカルテスト結果を併記して記録すべきで、最後の一文が「答えは正しい」だけでは不十分です。

再現実験

今回のテストスクリプトと順次リトライ結果は以下に保存しています（並列初回の要約もスクリプト出力に書き込んであります）。

.tmp/kimi_k3_vs_gpt56sol_test.py
.tmp/kimi-k3-vs-gpt56sol-results.json
.tmp/retry-gpt56sol-math.json
.tmp/retry-gpt56sol-physics.json
.tmp/retry-gpt56sol-programming.json
.tmp/retry-kimi-k3-math.json

再測定時は、モデル ID、プロンプト、temperature、max_tokens、並列度を固定し、毎回の出力を別ファイルとして保存するのがおすすめです。上流の負荷、キャッシュヒット、レート制限の状態は遅延に影響します。本記事では HTTP 408、length、read timeout をいずれもテスト結果の一部として記録し、意図的に隠していません。

DEV Community: Jenny Met

Claude Opus 5 vs GPT-5.6 Luna：速度順位を使わない18問の正確性ベンチマーク

先に結論

なぜ問題を難しくしたのか

18問をどう採点したか

6分野の結果

アルゴリズム差は「納品物」の差だった

厳密JSONではLunaが優位

出力予算と知能上の誤りを分離

本番ルーティングへの落とし込み

再現方法と生データ

よくある質問

17/18ならOpus 5が総合勝者ですか？

誤った自己テストをアルゴリズム失敗に含める理由は？

なぜ速度を結論に入れないのですか？

最終評価

Claude Opus 5 frente a GPT-5.6 Luna: 18 pruebas verificables, sin ranking de velocidad

Respuesta rápida

Por qué fue necesario subir la dificultad

Cómo se puntuaron las 18 tareas

Resultados en seis dimensiones

La diferencia algorítmica fue una diferencia de entrega

En JSON estricto, la ventaja cambió de lado

El presupuesto de salida se separó de los errores de inteligencia

Cómo convertir los resultados en reglas de routing

Reproducción y evidencia original

Preguntas frecuentes

¿17/18 convierte a Opus 5 en ganador absoluto?

¿Por qué cuentan como fallo unas autopruebas incorrectas?

¿Por qué la latencia no aparece en el veredicto?

Veredicto final

Claude Opus 5 vs GPT-5.6 Luna: 18 Verifiable Tasks, No Speed Leaderboard

Quick answer

Why the benchmark had to become harder

How the 18-task round was scored

Results across six dimensions

The algorithm gap was a delivery gap

The strict-JSON failure points in the other direction

Output budgets were separated from intelligence errors

What this means for production routing

Reproduction and raw evidence

FAQ

Does 17/18 make Opus 5 the overall winner?

Why count faulty self-tests as algorithm failures?

Why is latency absent from the verdict?

Final verdict

Claude Opus 5 vs GPT-5.6-SOL: 프로덕션 QA로 검증한 10개 과제, 핵심 정확도는 동률

Claude Opus 5 vs GPT-5.6-SOL: 프로덕션 QA로 검증한 10개 과제, 핵심 정확도는 동률

빠른 답변

네트워크 지연 시간을 지능 점수에서 제외한 이유

테스트 환경과 채점 기준

10개 지능 과제 결과

가장 어려운 확률 문제: 12.6547은 맞았지만 응답은 완전하지 않았다

실행 가능한 코드 검증: 코드 모양이 아니라 숨은 테스트로 평가

로그 집계 알고리즘

신뢰성 제약이 있는 안정적 라우팅

엄격한 JSON: 계산 정확도와 지시 준수를 분리해서 봐야 한다

같은 API로 재검증하는 방법

프로덕션 도입을 위한 QA 지침

두 모델 모두 후보로 고려할 수 있는 작업

이번 결과에서 GPT-5.6-SOL을 우선 검토할 수 있는 작업

Opus 5를 사용할 때 추가할 보호 장치

프로덕션 체크리스트

FAQ

Claude Opus 5와 GPT-5.6-SOL 중 어느 모델이 더 똑똑한가?

완전한 과제 통과율은 왜 동률이 아닌가?

핵심 정확도와 완전한 과제 납품은 어떻게 다른가?

엄격한 JSON 실패를 지능 오류로 봐야 하나?

Opus 5는 JSON 재시도에서 성공했나?

두 코드 과제는 어떻게 평가했나?

왜 응답 속도 승자를 발표하지 않았나?

finish_reason을 반드시 검사해야 하는 이유는 무엇인가?

10개 과제만으로 장기 모델을 선정해도 되나?

자체 모델 비교는 어떻게 시작해야 하나?

구조화 출력은 prompt만 잘 쓰면 보장할 수 있나?

최종 결론

Claude Opus 5 против GPT-5.6-SOL: проверка на 10 задачах — по точности основных ответов ничья

Claude Opus 5 против GPT-5.6-SOL: проверка на 10 задачах — по точности основных ответов ничья

Краткий ответ

Почему задержка сети не входит в оценку интеллекта

가장 어려운 확률 문제: `12.6547`은 맞았지만 응답은 완전하지 않았다

`finish_reason`을 반드시 검사해야 하는 이유는 무엇인가?

returned model이 왜 `anthropic/claude-fable-5`인가요?