GPT-6.2 Astra und Sol sind nicht zwei Größen desselben Einkaufs. Astra ist OpenAIs Modell für die schwierigsten Projekte; Sol ist sein Modell für alltägliche Arbeit und hochvolumige Agenten. Zu den Standard-Listenpreisen für kurzen Kontext kostet Astra viermal so viel pro Input- und Output-Token. Die praktische Frage ist daher nicht, welches Modell stärker klingt, sondern welches Ihre Akzeptanzschwelle zu den niedrigsten Kosten pro tatsächlich nutzbarer Aufgabe besteht — und wann ein besseres Ergebnis den Aufpreis wert ist.
Umfang und Evidenz. OpenAI hat den Start von GPT-6.2 Astra und Sol am 17. November 2026 veröffentlicht. Spezifikationen und Listenpreise unten stammen aus OpenAIs Launch-Beitrag und den offiziellen Modellseiten, geprüft am 18. November 2026. Dies ist ein Planungsleitfaden, kein Benchmark-Bericht: Wir haben kein Modell ausgeführt, keine Latenz gemessen und keine Ausgaben bewertet. Das Kostenbeispiel ist Arithmetik aus den offiziellen Sätzen plus den genannten Annahmen. Der internationale ToAPIs-Katalog listet Astra und Sol; nutzen Sie den Live-Katalog für die Varianten, Sätze und Routing-Optionen, die Ihrem Konto zur Verfügung stehen. Dieser Artikel behauptet keine plattformspezifischen Sätze, Endpunktpfade oder regionale Abdeckung.
1. Die offiziellen Fakten, die die Entscheidung verankern
OpenAIs Launch-Beitrag positioniert Astra für komplexe professionelle Arbeit — Präsentationen, Tabellen, Dokumente, Programmierung, Computer-Use und visuelles Reasoning — und Sol für alltägliche technische und nicht-technische Aufgaben, einschließlich mehrstufiger agentischer Workflows. Beide akzeptieren Text und Bilder und geben Text zurück. Die offiziellen Modellseiten listen für beide dieselben Kontext- und Output-Limits:
| Spezifikation | GPT-6.2 Astra | GPT-6.2 Sol |
|---|---|---|
| API-Modell-ID | gpt-6.2-astra | gpt-6.2-sol |
| OpenAI-Positionierung | Schwierigste Projekte, von Anfang bis Ende | Alltägliche Arbeit und Agenten im Maßstab |
| Eingabemodalitäten | Text, Bild | Text, Bild |
| Ausgabe | Text | Text |
| Kontextfenster | 1.050.000 Tokens | 1.050.000 Tokens |
| Maximaler Input | 922.000 Tokens | 922.000 Tokens |
| Maximaler Output | 128.000 Tokens | 128.000 Tokens |
| Wissensstichtag | 18. Mai 2026 | 1. Juni 2026 |
| Reasoning-Einstellung | Höchste; none wird abgelehnt | Höchste; none wird abgelehnt |
| Fine-Tuning | Nicht unterstützt | Nicht unterstützt |
Der wichtigste wirtschaftliche Unterschied ist der Preis, nicht ein anderes Kontextlimit:
| Offizieller Standard-Satz für kurzen Kontext | Astra | Sol | Astra / Sol |
|---|---|---|---|
| Input, pro 1 Mio. Tokens | $8.00 | $2.00 | 4x |
| Gecachter Input, pro 1 Mio. Tokens | $0.40 | $0.10 | 4x |
| Output, pro 1 Mio. Tokens | $40.00 | $10.00 | 4x |
| 30-minütige Cache-Schreibung, pro 1 Mio. Tokens | $10.00 | $2.50 | 4x |
Quelle: OpenAI API-Preisseite und Modellseiten, geprüft am 18. November 2026. Die Sätze sind USD pro Million Tokens, vor Steuern und etwaigen Plattformgebühren. Es sind Referenz-Listenpreise, kein ToAPIs-Angebot.
OpenAI macht außerdem vom Anbieter berichtete Leistungsaussagen. Es heißt, Sol liege bei Cognition's FrontierCode 2.0 etwa zu einem Fünftel der Kosten 0,5 Punkte hinter Astra (beide mit maximalem Reasoning), und Astra erreiche 1.318 Elo gegenüber 1.259 für Sol in der AA-3D-Menschenpräferenz-Evaluation von Artificial Analysis. Das sind vom Anbieter berichtete Ergebnisse unter Konfigurationen, die wir nicht geprüft haben. Behandeln Sie sie als Hypothesen; Ihre Prompts, Tools und Akzeptanzregeln können eine andere Reihenfolge ergeben.
2. Die 4x-Preislücke: Was wahr sein muss, damit Astra gewinnt
Bei den Standard-Listenpreisen für kurzen Kontext haben Astra und Sol dasselbe 4:1-Verhältnis für Input, Output und gecachten Input. Wenn beide Modelle dieselbe Anzahl abrechenbarer Tokens verbrauchen und dieselbe Anzahl von Versuchen brauchen, kann Astra keine niedrigeren Kosten pro akzeptierter Aufgabe haben, es sei denn, seine Akzeptanzrate ist mehr als viermal so hoch wie die von Sol. Da Akzeptanz bei 100% gedeckelt ist, wird das unmöglich, sobald Sols Akzeptanzrate 25% übersteigt.
Diese Aussage hat einen engen Geltungsbereich: gleiches Token-Volumen, gleiche Versuche, gleiche abrechenbare Einheiten. Sie ist trotzdem ein nützlicher Ausgangspunkt, weil sie zeigt, wie groß die Qualitätslücke sein muss, bevor Astra allein über Kosten gewinnt. Die Break-even-Sensitivität sieht so aus:
| Sol-Akzeptanzrate | Benötigte Astra-Akzeptanz, um Sols Kosten pro akzeptierter Aufgabe zu erreichen |
|---|---|
| 10% | 40% |
| 15% | 60% |
| 20% | 80% |
| 25% | 100% |
| 30% | 120% (nicht erreichbar) |
| 50% | 200% (nicht erreichbar) |
Nimmt identische Token-Zahlen und Versuche pro Aufgabe an und dass jeder Versuch abgerechnet wird. Ein anderes Token-Profil verschiebt den Break-even-Punkt.
Die Break-even-Betrachtung ist kein Argument dafür, dass Astra überteuert ist. Sie ist ein Argument dagegen, das Label „bestes Modell" als Routing-Richtlinie zu behandeln. Astra kann rational sein, wenn Sols Ausgabe unbrauchbar ist, eine falsche Antwort teuer ist oder menschliche Reparatur mehr kostet als der Token-Aufpreis. Es ist selten der Standard für routinemäßige Klassifikation, Extraktion oder kurze Support-Antworten.
Drei Einschränkungen sind wichtig:
- Token-Effizienz kann das Verhältnis verschieben. Wenn Astra mit deutlich weniger Output-Tokens oder Versuchen Akzeptanz erreicht, liegt sein effektiver Aufpreis unter 4x. Wir haben keine gepaarten Messungen, daher behaupten wir keine Zahl.
- Das Verhältnis ist nicht die Rechnung. Oberhalb von 272.000 Input-Tokens verdoppeln sich Input- und Cache-Sätze, und der Output kostet das 1,5-fache für die gesamte Anfrage. Die 4:1-Listenpreisbeziehung bleibt, aber die absoluten Kosten steigen; verwenden Sie keine Kurzkontext-Beispiele für Langkontext-Arbeit.
- Andere abrechenbare Einheiten können das Verhältnis brechen. Tool-Aufrufe, Container, Dateisuche, Batch- oder Fast-Modi, Ultrafast, Hintergrundfenster, regionale Zuschläge, Steuern und Plattformgebühren liegen außerhalb dieser Arithmetik. Prüfen Sie die offizielle Preisseite und Ihren Kontosatz.
3. Szenariokarte: Wo jedes Modell seinen Platz verdient
Die Entscheidung wird klarer, wenn Sie die Arbeitslast, die Fehlerkosten und das Volumen benennen. Die folgende Tabelle ist eine Ausgangsrichtlinie, keine Behauptung über gemessene Qualität.
| Arbeitslast | Beginnen mit | Zu Astra eskalieren, wenn | Hauptkostentreiber |
|---|---|---|---|
| Hochvolumiger Support, Klassifikation, Extraktion | Sol | Mehrdeutige oder hochwertige Fälle die Rubrik nicht bestehen, oder eine falsche Antwort eine teure manuelle Prüfung auslöst | Versuche pro Aufgabe und Akzeptanzrate |
| Abgegrenzte Coding-Aufgaben, Testgenerierung, PR-Review | Sol | Die Änderung mehrere Dateien umfasst, Designurteil erfordert oder eine Regression später teuer zu erkennen ist | Kosten pro akzeptierter Aufgabe plus Review-Zeit |
| Präsentationen, Tabellen, Memos, Kundenlieferungen | Sol für Entwürfe | Template-Treue, faktische Synthese und Erstnutzbarkeit entscheiden, ob das Ergebnis brauchbar ist | Nacharbeit und Review-Zeit |
| Langhorizont-Agenten und Tool-Workflows | Sol für die Ausführung | Planung oder mehrdeutige Schritte wiederholt scheitern, oder der Agent stärkeres visuelles bzw. Computer-Use-Urteil braucht | Kumulierte Tokens und Wiederholungen |
| Visuelle, 3D-, CAD- und interaktive Frontends | Sol für einfache Seiten | Räumliche Präzision, visuelle Qualität oder detaillierte Computer-Use bestimmen das Nutzerergebnis | Wiederholungen und menschliche Prüfung |
| Offline-Batch-Verarbeitung | Sol | Ein Qualitätsfilter weist zu viele Sol-Ausgaben zurück, oder die Aufgabe ist inhärent Frontier-Level | Batch-Rabatte und Ablehnungsrate |
Hochvolumiger Support und Extraktion: Sol ist der wirtschaftliche Standard
Eine Support-Triage- oder Rechnungsextraktionspipeline kann pro Tag Tausende kurzer Anfragen verarbeiten, mit einigen Tausend Input-Tokens und einer kurzen Kennzeichnung oder JSON-Ausgabe. Sols $2/$10-Satz ist ein großer Vorteil, und sein 1,05M-Kontext entspricht dem von Astra, sodass Kontextkapazität kein Aufrüstungsgrund ist. Eskalieren Sie nur konkrete Fehlschläge: ein Schemafehler bei einem hochwertigen Konto, widersprüchliche Quelldokumente oder ein Fehler, der eine Erstattungs- oder Compliance-Prüfung auslöst. Messen Sie diese Kohorte; verschieben Sie nicht die ganze Warteschlange, weil eine Demo besser aussah.
Repository-weite Codeänderungen: Qualität zeigt sich als Review-Zeit
Für einen Ein-Zeilen-Fix ist Sol der sinnvolle erste Versuch. Für ein Multi-Datei-Refactoring mit unklarem Design umfassen die echten Kosten das Lesen durch Senior-Ingenieure, das Finden übersehener Aufrufstellen und die Reparatur von Tests. Wenn Sol mehrere Runden braucht, während Astra eine mergebare Änderung in ein oder zwei Runden produziert, kann Astra trotz des 4x-Token-Preises pro akzeptierter Änderung günstiger sein. Akzeptanz muss Ausführung sein: Patch anwenden und Tests in einer Wegwerfumgebung laufen lassen; ein plausibler Diff reicht nicht.
Professionelle Lieferungen: Astra' Aufpreis ist leichter zu rechtfertigen
Präsentationen, Bewertungsmodelle, juristische Zusammenfassungen und Kundenmemos haben hohe Nacharbeitskosten. Ein Deck, das das Template ignoriert, oder ein Memo, das eine Pflichtklausel auslässt, kann mehr menschliche Zeit verbrauchen als die Modellgebühr. OpenAI positioniert Astra für professionelle Konventionen und Template-Treue. Führen Sie trotzdem eine Blindprüfung mit dem echten Template durch: Wenn Sols Entwurf brauchbar ist, zahlen Sie Sol; wenn er umstrukturiert werden muss, vergleichen Sie die Review-Zeit mit Astra' Aufpreis.
Agenten und visuelle Workflows: Planer vom Executor trennen
Agentische Workflows akkumulieren Kontext, sodass sich die Preislücke verstärkt. Ein verbreitetes Muster ist Sol für Routine-Tool-Aufrufe, Extraktion und kurze Antworten, mit Astra reserviert für Planung, mehrdeutige Entscheidungen oder visuelle bzw. Computer-Use-Schritte, die die Trajektorie bestimmen. Setzen Sie Token- und Versuchsbudgets pro Aufgabe. Erfassen Sie den vollständigen Trace und bewerten Sie die abgeschlossene Aufgabe, nicht die beste Zwischennachricht.
4. Ein einfaches Kostenbeispiel
Nehmen Sie eine Aufgabe mit 10.000 Input-Tokens und 2.000 Output-Tokens pro Aufruf, zu OpenAIs Standard-Listenpreisen für kurzen Kontext. Jeder Aufruf ist ein Versuch, und jeder Aufruf wird abgerechnet:
- Sol: $0.02 für Input plus $0.02 für Output = $0.04 pro Aufruf.
- Astra: $0.08 für Input plus $0.08 für Output = $0.16 pro Aufruf.
Wenn Sol im zweiten Versuch erfolgreich ist, kostet die Aufgabe $0.08. Wenn Astra im ersten Versuch erfolgreich ist, kostet sie $0.16. Wenn Sol fünf Versuche braucht, kostet sie $0.20 — mehr als Astra' einzelner erfolgreicher Aufruf. Der Aufpreis lohnt sich daher nur, wenn Astra genug Wiederholungen oder Bearbeitungen vermeidet, um diese Lücke zu schließen. Die Versuchszahlen sind Annahmen zur Illustration, keine Messungen; verwenden Sie Ihre eigenen Logs.
Das ist die praktische Version der Kosten pro akzeptierter Aufgabe: jeden abgerechneten Aufruf zählen und dann die Dollarsumme gegen die Zeit abwägen, die Sie für die Nutzbarkeit des Ergebnisses aufwenden.
Diese Zahlen sind eine Planungsschätzung aus OpenAIs veröffentlichten Standard-Kurzkontext-Preisen, unter der Annahme von Input unter 272.000 Tokens pro Anfrage. Sie schließen Cache-Treffer und Cache-Schreibvorgänge, Tool-Gebühren, Batch-, Fast-, Ultrafast- oder Hintergrundfenster-Preise (einschließlich Rabatten), regionale Zuschläge, Steuern, Plattformgebühren und menschliche Review- oder Bearbeitungszeit aus. Sie sind kein ToAPIs-Angebot; prüfen Sie den Modellkatalog und die Preisseite für die Live-Sätze Ihres Kontos.
5. Wie Sie in drei Schritten wählen
- Beginnen Sie mit Sol. Führen Sie die echte Aufgabe, oder eine kleine Stichprobe davon, mit Sol und Ihrem Produktions-Prompt und Ihren Ausgaberegeln aus. Erfassen Sie, ob jedes Ergebnis besteht, wie viele Aufrufe es brauchte und wie lange Sie mit der Reparatur verbracht haben.
- Testen Sie Astra bei den konkreten Fehlschlägen. Wenn Sol aus einem Grund scheitert, den ein stärkeres Modell beheben könnte — mehrdeutige Anweisungen, schwaches Designurteil, ein schwieriger visueller Schritt — führen Sie dieselben Eingaben mit Astra aus. Verschieben Sie nicht die gesamte Arbeitslast, weil eine Demo besser aussah.
- Vergleichen Sie Gesamtaufrufkosten und Bearbeitungszeit. Summieren Sie jeden abgerechneten Aufruf zum Pro-Aufruf-Preis jedes Modells und stellen Sie dann die Zeit daneben, die Sie mit Review oder Reparatur der Ausgabe verbringen. Wählen Sie Astra nur, wenn seine zusätzlichen Aufrufkosten durch weniger Wiederholungen, weniger Bearbeitung oder niedrigere Fehlerkosten gedeckt sind.
Für die API-Integration nutzen Sie den Modellkatalog, die Preisseite und die API-Dokumentation. Für Modell-IDs und eine erste Anfrage sehen Sie den begleitenden GPT-6.2 API-Leitfaden. Prüfen Sie den Live-Katalog für die Varianten, Sätze und Regionen, die Ihrem Konto zur Verfügung stehen; dieser Artikel behauptet keine plattformspezifischen Sätze, Endpunktpfade oder regionale Abdeckung.
6. Häufig gestellte Fragen
Ist Astra den 4x-Preis wert?
Nur wenn die inkrementelle Qualität das Ergebnis genug verändert, um den Aufpreis zu rechtfertigen. Für routinemäßige, klar spezifizierte Arbeit ist Sol schwer zu schlagen. Für hochwertige Lieferungen, teure Codeänderungen oder wiederholte Sol-Fehlschläge kann Astra pro tatsächlich nutzbarer Aufgabe trotz des höheren Token-Satzes günstiger sein.
Bedeutet Sols niedrigerer Preis schlechtere Qualität beim Coding?
OpenAI berichtet Sol 0,5 Punkte hinter Astra bei FrontierCode 2.0, zu etwa einem Fünftel der Kosten (beide auf Maximum). Das ist eine Anbieteraussage, kein Ergebnis für Ihr Repository. Testen Sie Patch-Anwendbarkeit, Testbestehensrate, Review-Aufwand und Regressionsrisiko.
Wie sollte ich gecachten Input verbuchen?
Gecachter Input kostet $0.40 pro Million bei Astra gegenüber $8.00 ohne Cache; Sol liegt bei $0.10 gegenüber $2.00. Cache-Schreibvorgänge sind separat. Wenn Sie lange Prompts oder Dokumente wiederverwenden, messen Sie die Cache-Trefferrate, statt Preise ohne Cache anzunehmen. Das Beispiel nimmt keinen Cache-Vorteil an.
Was ist mit langen Prompts über 272K Tokens?
Separat kalkulieren. Oberhalb von 272.000 Input-Tokens verdoppeln sich Input- und Cache-Sätze, und der Output kostet das 1,5-fache des Kurzkontext-Satzes für die gesamte Anfrage. Die 4:1-Listenpreisbeziehung bleibt, aber die absoluten Kosten steigen; halten Sie Langkontext-Arbeit aus Kurzkontext-Schätzungen heraus.
Kann ich ToAPIs nutzen, um diesen Vergleich auszuführen?
Der internationale ToAPIs-Katalog listet Astra und Sol, aber dieser Artikel behauptet keine plattformspezifischen Sätze, Endpunkte oder regionale Abdeckung. Prüfen Sie den Live-Katalog und die Preisseite. Das Vergleichs-Harness im Entwickleranhang zielt standardmäßig auf die offizielle OpenAI-API; wenn Sie einen anderen OpenAI-kompatiblen Endpunkt verwenden, bestätigen Sie Modell-IDs, Felder und Abrechnungseinheiten.
7. Quellen und Methode
- OpenAI: Introducing GPT-6.2 Astra and Sol, veröffentlicht am 17. November 2026 — Launch-Positionierung, Verfügbarkeit und vom Anbieter berichtete Ergebnisse.
- OpenAI-Modellseite: GPT-6.2 Astra — Modell-ID, Kontextlimits, Modalitäten, Tools und Preise, geprüft am 18. November 2026.
- OpenAI-Modellseite: GPT-6.2 Sol — Modell-ID, Kontextlimits, Modalitäten, Tools und Preise, geprüft am 18. November 2026.
- OpenAI API-Preise — Standard-, Cache-, Langkontext-, Batch-, Fast- und Ultrafast-Bedingungen, geprüft am 18. November 2026.
- ToAPIs: GPT-6.2 API-Leitfaden — plattformspezifisches Setup und Preise; Begleitartikel.
Methodenhinweis. Die Dollarzahlen sind deterministische Arithmetik aus den veröffentlichten Listensätzen und den Token- und Versuchsannahmen im Beispiel. Sie sind keine Rechnungen, Angebote oder gemessenen Ergebnisse. Für diesen Artikel wurden keine Modellinferenz, Latenzmessung, Qualitätsbewertung oder Blindprüfung durchgeführt, und das Vergleichs-Harness im Entwickleranhang wurde nicht ausgeführt. Ersetzen Sie Sätze, Token-Zahlen und Versuchszahlen durch Ihre eigenen Pilotdaten, bevor Sie eine Produktionsentscheidung treffen.
Entwickleranhang: Führen Sie Ihren eigenen Vergleich aus
Das folgende Protokoll ist darauf ausgelegt, Evidenz für Ihre eigene Arbeitslast zu erzeugen. Es ist bewusst keine Rangliste. Der Vergleich wurde für diesen Artikel nicht ausgeführt, und es werden hier keine Modellausgaben oder Latenzzahlen berichtet.
Testdesign
- Frieren Sie das Aufgabenset ein. Verwenden Sie 20–50 repräsentative Fälle, darunter einfache Fälle, die bestehendes Verhalten schützen, und schwierige Fälle, die die Modelle unterscheiden. Entfernen Sie vertrauliche Daten oder ersetzen Sie sie durch synthetische Äquivalente.
- Frieren Sie die Anfrage ein. Verwenden Sie denselben System-Prompt, dieselbe Nutzereingabe, dieselben Tools, dasselbe Ausgabeschema und dasselbe Token-Budget für beide Modelle, wo immer es die Verträge erlauben. Erfassen Sie unvermeidbare Unterschiede.
- Wiederholen Sie nichtdeterministische Aufgaben. Behalten Sie die Verteilung und die Fehlschläge, nicht nur die beste Ausgabe.
- Bewerten Sie blind. Entfernen Sie das Modelllabel vor der Prüfung. Eine Aufgabe besteht nur, wenn sie jede erforderliche Prüfung besteht; eine polierte Antwort, die ein Feld auslässt, einen Identifier erfindet oder einen Test nicht besteht, ist ein Fehlschlag.
- Zählen Sie abgerechnete Versuche und trennen Sie die Latenz. Fehlgeschlagene Versuche gehören in den Kostenzähler, wenn sie abgerechnet werden. Berichten Sie Zeit bis zum ersten Token, Abschlusszeit und Zeit bis zu einem akzeptierten Ergebnis separat, und geben Sie an, was der Timer umfasst.
Ein minimales Fallset kann so aussehen:
| Fall | Aufgabe | Akzeptanzprüfungen |
|---|---|---|
extract-01 | Artikel und Menge aus einer kurzen Bestellnachricht extrahieren | Gültiges JSON; exakte Schlüssel; Menge ist eine Ganzzahl; keine erfundenen Werte |
code-01 | Eine Funktion mit Randbedingungen implementieren | Patch wird angewendet; Tests bestehen; ungültige Eingabe abgelehnt; keine unbezogenen Änderungen |
clarify-01 | Auf eine Bestellstatus-Anfrage ohne Bestell-ID antworten | Fragt nach der ID; erfindet keine; keine Schreibaktion |
memo-01 | Ein geliefertes Quellenpaket in ein einseitiges Memo verwandeln | Jeder Pflichtabschnitt vorhanden; Zahlen auf die Quelle zurückführbar; keine unbelegte Aussage |
Das Harness ruft den offiziellen OpenAI-Chat-Completions-Endpunkt mit beiden Modell-IDs auf, erfasst Usage, Latenz, angeforderte und zurückgegebene Modell-Identifier sowie Zeitstempel und überlässt accepted einem menschlichen Reviewer. Es erfordert einen API-Schlüssel und macht nur mit --execute abrechenbare Aufrufe. estimate_cost ignoriert Cache-Treffer, Rabatte für Abrechnungsmodi und Plattformgebühren, also gleichen Sie es mit der abgerechneten Usage ab. Verwenden Sie keine Produktionsdaten; nehmen Sie nicht an, dass ein Aggregator Modell-IDs oder Sätze beibehält.
#!/usr/bin/env python3
"""Reusable GPT-6.2 Astra vs Sol comparison harness.
The comparison was not executed for the accompanying article. Requires OPENAI_API_KEY and
explicit --execute consent because calls are billable. Acceptance is manual.
"""
from __future__ import annotations
import argparse
import json
import os
import time
import urllib.request
from datetime import datetime, timezone
from pathlib import Path
API_URL = os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1").rstrip("/") + "/chat/completions"
MODELS = ("gpt-6.2-astra", "gpt-6.2-sol")
RATES = {
"gpt-6.2-astra": {"input": 8.00, "output": 40.00},
"gpt-6.2-sol": {"input": 2.00, "output": 10.00},
}
CASES = [
{
"id": "extract-01",
"system": "Return only valid JSON with exactly the keys item and quantity.",
"user": "Please order 3 blue mugs.",
"rubric": ["valid JSON", "item is blue mugs", "quantity is the integer 3"],
},
{
"id": "code-01",
"system": "Return a unified diff only. Do not include commentary.",
"user": (
"Implement merge_intervals(intervals) so overlapping or adjacent "
"intervals are merged. Reject invalid ranges. Include tests."
),
"rubric": ["patch applies", "tests pass", "invalid ranges rejected"],
},
{
"id": "clarify-01",
"system": "You are an order-support agent. Never invent identifiers.",
"user": "Where is my order?",
"rubric": ["asks for order ID", "does not invent an ID", "no write action"],
},
]
def estimate_cost(model: str, prompt_tokens: int, completion_tokens: int) -> float:
rate = RATES[model]
return (
prompt_tokens * rate["input"] + completion_tokens * rate["output"]
) / 1_000_000
def call_model(model: str, case: dict) -> dict:
body = json.dumps(
{
"model": model,
"messages": [
{"role": "system", "content": case["system"]},
{"role": "user", "content": case["user"]},
],
"max_completion_tokens": 8000, # fixed cap for this comparison
}
).encode("utf-8")
request = urllib.request.Request(
API_URL,
data=body,
headers={
"Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}",
"Content-Type": "application/json",
},
)
started = time.perf_counter()
with urllib.request.urlopen(request, timeout=180) as response:
payload = json.load(response)
elapsed = time.perf_counter() - started
usage = payload.get("usage", {})
prompt_tokens = usage.get("prompt_tokens", 0)
completion_tokens = usage.get("completion_tokens", 0)
return {
"requested_model": model,
"returned_model": payload.get("model"),
"api_url": API_URL,
"timestamp_utc": datetime.now(timezone.utc).isoformat(),
"case_id": case["id"],
"run": None,
"latency_seconds": round(elapsed, 3),
"prompt_tokens": prompt_tokens,
"completion_tokens": completion_tokens,
"cost_usd": round(estimate_cost(model, prompt_tokens, completion_tokens), 6),
"output": payload["choices"][0]["message"]["content"],
"rubric": case["rubric"],
"accepted": None,
"reviewer": None,
"review_notes": None,
}
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--execute", action="store_true", help="make billable API calls")
parser.add_argument("--repeats", type=int, default=1)
parser.add_argument("--out", default="gpt-6-2-runs.jsonl")
args = parser.parse_args()
if not args.execute:
print("Dry plan only. Re-run with --execute after checking access, budget and data rules.")
for case in CASES:
print(json.dumps({"case": case["id"], "models": MODELS, "repeats": args.repeats}))
return
if not os.environ.get("OPENAI_API_KEY"):
raise SystemExit("Set OPENAI_API_KEY first.")
output = Path(args.out)
with output.open("a", encoding="utf-8") as handle:
for case in CASES:
for model in MODELS:
for run in range(args.repeats):
record = call_model(model, case)
record["run"] = run + 1
handle.write(json.dumps(record, ensure_ascii=False) + "\n")
print(json.dumps({
"case_id": record["case_id"],
"model": record["requested_model"],
"latency_seconds": record["latency_seconds"],
"cost_usd": record["cost_usd"],
}))
print(f"Wrote {output}. Fill 'accepted' manually against each rubric before comparing costs.")
if __name__ == "__main__":
main()
Berechnen Sie nach der Prüfung die Kernzahl für die Routing-Entscheidung:
import json
from pathlib import Path
rows = [json.loads(line) for line in Path("gpt-6-2-runs.jsonl").read_text().splitlines()]
if not rows or any(type(row["accepted"]) is not bool for row in rows):
raise SystemExit("Review every row before comparing costs.")
for model in sorted({row["requested_model"] for row in rows}):
model_rows = [row for row in rows if row["requested_model"] == model]
accepted = sum(row["accepted"] is True for row in model_rows)
estimated = sum(row["cost_usd"] for row in model_rows)
per_accepted = estimated / accepted if accepted else None
print(model, {"accepted": accepted, "estimated_usd": round(estimated, 4),
"cost_per_accepted": round(per_accepted, 4) if per_accepted is not None else None})
Das Harness testet die Tool-Ausführung nicht, weil das Ausführen von modellgeneriertem Code oder Shell-Befehlen Sicherheits- und Reproduzierbarkeitsprobleme mit sich bringt. Wenn Ihr Workflow Tools nutzt, bewerten Sie den Tool-Trace separat: gültige Argumente, Autorisierung, Seiteneffekte, Wiederholungen und ob eine Klärungsfrage die richtige Aktion war. Ein Modell, das eine perfekte Antwort schreibt, aber ein destruktives Tool falsch aufruft, hat die Aufgabe nicht bestanden.







