GPT-6.1 Sol kostet bei Agent-Workloads nur ein Fuenftel von GPT-6 Astra
1.000 agentische Coding-Aufgaben kosten mit GPT-6.1 Sol 192 Dollar, mit GPT-6 Astra dagegen 1.020 Dollar, ein Faktor 5,3. Der Unterschied ergibt sich allein aus den Preisen von 2 beziehungsweise 10 Dollar pro Million Input- und 50 Dollar pro Million Output-Tokens.
Veröffentlicht am 8. Oktober • Zuerst erschienen auf wowhow.cloud
Die Ausführung von 1.000 agentischen Coding-Aufgaben kostet 192 $ auf GPT-6.1 Sol und 1.020 $ auf GPT-6 Astra, eine Lücke um den Faktor 5,3, die ausschließlich aus der Preisliste stammt. Die Zahlen hinter dieser Rechnung sind 2,00 $ und 10,00 $ pro Million Input- und Output-Tokens für Sol, gegenüber 10 $ und 50 $ für Astra (laut OpenAIs Launch-Material und Preisaggregatoren von Drittanbietern, Oktober 2026). Sols Modell-ID lautet gpt-6.1-sol, und OpenAI beschreibt das Modell als "erreicht GPT-6 Astra bei mehreren Benchmarks nahe, zu deutlich niedrigeren Kosten".
Die kurze Antwort: Standardmäßig Sol für Agent-Loops verwenden und nur bei den Schritten auf Astra ausweichen, bei denen ein fehlgeschlagener Versuch mehr kostet als der Preisunterschied. Die Break-Even-Regel ist einfach. Sol ist pro abgeschlossener Aufgabe günstiger, solange es mindestens ein Fünftel so oft erfolgreich ist wie Astra. Für die meisten Coding-Arbeiten ist diese Hürde niedrig genug, dass Sol den Standardplatz gewinnt, und die interessante Frage ist, welche Schritte weiterhin das teure Modell verdienen.
Sol wurde am ersten Tag für die Pläne Plus, Pro, Business, Enterprise und Edu innerhalb von ChatGPT Work und Codex veröffentlicht. Es ist nicht im Chat enthalten. Die folgenden API-Preise kombinieren OpenAIs Sol-Ankündigung mit aggregierten Astra-Preisen von Drittanbietern, daher sollten Sie sie auf der Preisseite überprüfen, bevor Sie ein Budget festlegen.
| Input, pro Million Tokens | 2,00 $ | 10,00 $ (bis 272K Input) |
| Input über 272K | Nicht berichtet | 20,00 $ Input, 75,00 $ Output |
| Batch oder Flex | Nicht berichtet | Halbem Preis |
| Fast-Modus | Nicht berichtet | 2x (20 $ und 100 $) |
Sehen Sie sich zuerst die Zeile für gecachte Eingaben an. Der Standard-Input kostet bei Sol genau ein Fünftel des Preises, der Output ebenso, aber der gecachte Input liegt bei einem Zehntel. Sols Cached-Satz von 0,10 $ gegenüber Astras 1,00 $ bedeutet, dass ein Loop, der bei jedem Schritt seinen Kontext erneut liest, bei Sol schneller günstiger wird, als das Verhältnis der Kopfzeilen vermuten lässt. Agenten lesen Kontext ständig neu, deshalb ist diese Zeile der Ort, an dem sich das echte Geld bewegt.
Ich habe vier Laufzeitszenarien bepreist. Jedes ist eine plausible Abfolge von Agentenschritten, die zu einem Lauf zusammengefasst wurden, kein gemessener Benchmark, also setzen Sie Ihre eigenen Token-Zahlen ein.
Gecachter Coding-Loop. 150.000 Input-Tokens, davon 120.000 Cache-Lesezugriffe und 30.000 frische, plus 12.000 Output-Tokens.
Ungecachter Coding-Loop. Dieselben 150.000 Input- und 12.000 Output-Tokens ohne Cache-Treffer.
Kurz und ausführlich. 20.000 frische Input-Tokens, 15.000 Output-Tokens.
Review mit langem Kontext. 300.000 Input-Tokens und 12.000 Output auf Astra, um die Neupreisung über 272K zu zeigen.
| Gecachter Coding-Loop | 0,192 $ | 1,020 $ | 192 $ | 1.020 $ |
| Ungecachter Coding-Loop | 0,420 $ | 2,100 $ | 420 $ | 2.100 $ |
| Kurz und ausführlich | 0,190 $ | 0,950 $ | 190 $ | 950 $ |
| Review mit langem Kontext | Nicht berichtet | 6,900 $ | Nicht berichtet | 6.900 $ |
Die Rechnung für die erste Zeile: Sol kostet 30.000 Tokens zu 2 $ pro Million (0,06 $), 120.000 gecachte Tokens zu 0,10 $ (0,012 $) und 12.000 Output-Tokens zu 10 $ (0,12 $), insgesamt 0,192 $. Astra kostet 0,30 $ plus 0,12 $ plus 0,60 $, also 1,02 $. Die Zeile mit langem Kontext sind 300.000 Tokens zu 20 $ (6,00 $) plus 12.000 zu 75 $ (0,90 $). Sols eigene Preise für langen Kontext erscheinen in keinen der von mir geprüften Quellen, daher bleibt diese Zelle leer, statt zu raten.
Hier ist dieselbe Berechnung als Code, den Sie bearbeiten können:
const PRICE = { sol: { fresh: 2, cached: 0.10, out: 10 }, astra: { fresh: 10, cached: 1.00, out: 50 }, } function runCost ( model, freshIn, cachedIn, out ) { const p = PRICE [ model ] return ( freshIn * p. fresh + cachedIn * p. cached + out * p. out ) / 1 e6 } runCost ( ' sol ', 30000, 120000, 12000 ) // 0.192 runCost ( ' astra ', 30000, 120000, 12000 ) // 1.02 Enter fullscreen mode Exit fullscreen mode Der AI Model Cost Calculator führt dieselbe Summe für andere Modelle im direkten Vergleich durch, und der neue Agent Run Cost Simulator erlaubt es, einen mehrstufigen Loop mit wachsendem Kontext statt eines einzelnen flachen Laufs zu modellieren.
Der Preis pro Token ist nicht der einzige Stellschraube. OpenAI verkauft Geschwindigkeit separat, und die Multiplikatoren sind beträchtlich.
Der Astra Fast-Modus verdoppelt den Satz auf 20 $ und 100 $. Beim ungecachten Coding-Loop sind das 4,20 $ pro Lauf, also 4.200 $ pro 1.000. Ein Bericht eines Drittanbieters nennt für die Ultrafast-API-Stufe das Sechsfache des Standardsatzes, also 60 $ Input und 300 $ Output. Die Zahlen entsprechen dem Sechsfachen von Astras Listenpreis, beschreiben also Astra Ultrafast, nicht Sol. Betrachten Sie das als berichtet, nicht als bestätigt. Beim ungecachten Coding-Loop ergibt das 12,60 $ pro Lauf und 12.600 $ pro 1.000, etwa das 30-Fache der Sol-Kosten für dieselben Token-Zahlen.
In den ChatGPT-Plänen erscheint dieselbe Idee als Pro 500: 500 $ pro Monat, das 25-Fache des Plus-Kontingents, mit Astra Ultrafast inklusive. Ultrafast erzeugt Codex-Tokens achtmal schneller und verbraucht das Kontingent auch achtmal schneller, sodass das Guthaben schnell zur Neige geht, wenn man es nutzt. Der Kauf von Credits bei Pro 100 oder 200 schaltet es nicht frei.
In Codex mit einem Plus-Plan schätzt der Oktober-Guide 5 bis 45 Astra-Lokalnachrichten pro Fünf-Stunden-Fenster, gegenüber 15 bis 160 für Sol. Das sind 3 bis 3,6 Mal mehr Sol-Nachrichten aus demselben Kontingent, sodass die Kontingentrechnung ebenfalls Sol begünstigt, wenn auch weniger stark als die API-Rechnung.
Batch und Flex geben Astra zum halben Preis. Der ungecachte Coding-Loop sinkt auf 1.050 $ pro 1.000 Läufe, was immer noch das 2,5-Fache von Sols Standardpreis ist. Rabatte schließen die Lücke nicht. Nur eine niedrigere Fehlerquote kann das.
Die Kosten pro Versuch sind die falsche Metrik. Kosten pro abgeschlossener Aufgabe sind die richtige, und sie ergeben sich aus den Versuchskosten geteilt durch die Wahrscheinlichkeit, dass der Versuch erfolgreich ist. Beim ungecachten Loop kostet Sol 0,42 $ pro Versuch und Astra 2,10 $. Sol ist pro abgeschlossener Aufgabe günstiger, wenn seine Erfolgsquote über einem Fünftel der von Astra liegt, also 20 % dessen, was Astra erreicht.
Das klingt nach einer leicht zu nehmenden Hürde, und oft ist sie es auch. Der Haken: Ein fehlgeschlagener Versuch kostet selten nur Tokens. Wenn ein fehlgeschlagener Lauf einen defekten Branch hinterlässt, dessen Prüfung zehn Minuten bei 60 $ pro Stunde dauert, kostet der Fehlschlag 10 $, was dem 24-Fachen der Sol-Token-Kosten des gesamten Versuchs entspricht. Nun sieht die Break-Even-Rechnung anders aus. Rechnet man die menschlichen Kosten in den Zähler, wird ein oft scheiterndes Modell schnell teuer, weil die Prüfzeit die Token-Abrechnung dominiert.
Sol für die Generierung. Code entwerfen, Tests schreiben, Refactoring innerhalb einer Datei, Logs zusammenfassen. Fehler sind billig zu erkennen und zu wiederholen.
Astra für das Urteilsvermögen. Architekturentscheidungen, Security-Reviews, Änderungen über mehrere Dateien mit verborgener Kopplung, alles, wo eine falsche Antwort unbemerkt ausgeliefert wird.
Noch günstiger für die Triage. Klassifizierung und Routing brauchen keines der beiden Modelle.
Eine harte Obergrenze für Wiederholungen. Begrenzen Sie die Versuche auf drei und eskalieren Sie zu einem stärkeren Modell oder einer Person, niemals in einer Schleife bleiben.
Ein Hinweis dazu, was nicht auf dem Tisch liegt. Ein Medium berichtete, OpenAI habe GPT-6.1 Astra nach Vorfällen mit autonomen Hacking gestrichen. Dies ist ein Ein-Quellen-Bericht, betrachten Sie ihn daher als unbestätigt. Falls wahr, erklärt es, warum der Vergleich ein 6.1 Sol gegen ein 6.0 Astra ist und nicht zwei Modelle derselben Generation, und es bedeutet, dass Sols Abstand zu Astra möglicherweise nicht bald durch ein Astra-Update geschlossen wird.
Nehmen Sie eine echte Aufgabe aus Ihrem Backlog. Führen Sie sie zehnmal auf Sol und zehnmal auf Astra mit aktiviertem Logging aus. Erfassen Sie die Input-Tokens, gecachten Tokens, Output-Tokens und ob das Ergebnis Ihre Tests bestand. Setzen Sie diese Zahlen in die oben verlinkten Rechner ein und berechnen Sie die Kosten pro bestandenem Lauf. Wenn Sol mindestens 20 % so oft besteht wie Astra, haben Sie Ihren Standard, und liegen die Quoten nur wenige Prozentpunkte auseinander, ist die Ersparnis die vollen 5x.
Die Instrumentierung ist der schwierige Teil, nicht die Arithmetik. Das AI Agent Ops Bundle liefert das Logging-Schema und die Kosten-Dashboards, die diese Messung wiederholbar machen, und der Agent Prompt Vault enthält 50 getestete Prompts, damit beide Modelle gegen identische Anweisungen laufen. Halten Sie die Anweisungen fest und variieren Sie nur das Modell, sonst sagt der Vergleich nichts aus.
Die Messung deckt außerdem den Multiplikator auf, der in den meisten Agent-Loops verborgen ist, nämlich die Anzahl der Agenten pro Aufgabe. Eine Pipeline, die an vier parallele Agenten verzweigt, vervierfacht jede Zahl in den Tabellen, bevor überhaupt eine Modellwahl getroffen wird. Wir haben im Multi-Agent-Tax behandelt, warum ein Agent der Standard sein sollte. Fixieren Sie zuerst die Verzweigung, dann wählen Sie das Modell.
Wenn Sie Codex über einen ChatGPT-Plan statt über die API nutzen, sind die Dollar fest, und die Frage lautet, wie viele Aufgaben ins Kontingent passen. Codex hat kein separates Abo. Es ist in Plänen von 0 $ bis 500 $ enthalten, und der API-Key-Pfad wird pro Token abgerechnet und schließt Cloud-Funktionen wie GitHub-Review und Slack aus. Plus kostet 20 $, Pro beginnt bei 100 $ mit etwa dem Fünffachen des Plus-Kontingents, und Overflow-Credits kosten etwa 0,04 $ pro Stück. Bei diesen Plänen zeigt sich Sols Vorteil als mehr abgeschlossene Aufgaben pro Fünf-Stunden-Fenster, 3 bis 3,6 Mal mehr laut OpenAIs Schätzungen, statt niedrigerer Rechnungen.
Der Entscheidungsbaum hat also zwei Zweige. Bei der API vergleicht man die Kosten pro abgeschlossener Aufgabe. Bei einem Plan vergleicht man die abgeschlossenen Aufgaben pro Fenster. Beide führen für die meisten Teams zum selben Standard: Sol für die Masse, Astra für die Schritte, die nicht still scheitern dürfen.
Ein Fünftel beim Standard-Input und -Output (2 $ und 10 $ gegenüber 10 $ und 50 $ pro Million Tokens) und ein Zehntel beim gecachten Input (0,10 $ gegenüber 1,00 $).
Für einen Lauf mit 120.000 gecachten und 30.000 frischen Input-Tokens und 12.000 Output-Tokens: 192 $ auf Sol und 1.020 $ auf Astra. Ohne Caching sind es 420 $ und 2.100 $.
Ja, wenn Sol pro Versuch weniger als ein Fünftel so oft erfolgreich ist oder wenn jeder Fehlversuch erhebliche Zeit für die Überprüfung kostet. Andernfalls schneidet Sol bei den Kosten pro abgeschlossener Aufgabe besser ab.
Ja, unter der Modell-ID gpt-6.1-sol zu 2,00 Dollar für Eingaben, 0,10 Dollar für zwischengespeicherte Eingaben und 10,00 Dollar für Ausgaben pro eine Million Token. In ChatGPT ist es in Work und Codex verfügbar, jedoch noch nicht in Chat.
Mit Vorlagen lassen sich häufig gestellte Fragen schnell beantworten oder Snippets zur Wiederverwendung speichern.
Sind Sie sicher, dass Sie diesen Kommentar ausblenden möchten? Er wird in Ihrem Beitrag verborgen, bleibt aber über den Permalink des Kommentars weiterhin sichtbar.
Für weitere Maßnahmen können Sie diese Person blockieren und/oder eine Meldung wegen unerwünschten Verhaltens einreichen.
Automatisch übersetzt. Das Original auf Englisch ist unten aufklappbar.
Original (Englisch) anzeigen
Posted on Oct 8 • Originally published at wowhow.cloud
Running 1,000 agentic coding tasks costs $192 on GPT-6.1 Sol and $1,020 on GPT-6 Astra, a 5.3x gap that comes entirely from the price sheet. The inputs behind that figure are $2.00 and $10.00 per million input and output tokens for Sol, against $10 and $50 for Astra (per OpenAI's launch material and third-party price aggregators, October 2026). Sol's model id is gpt-6.1-sol, and OpenAI describes it as "approaching GPT-6 Astra on several benchmarks at substantially lower cost".
Short answer: default to Sol for agent loops and escalate to Astra only for the steps where a failed attempt costs you more than the price difference. The break-even rule is simple. Sol is cheaper per finished task as long as it succeeds at least one-fifth as often as Astra. For most coding work that bar is low enough that Sol wins the default slot, and the interesting question is which steps still deserve the expensive model.
Sol launched on day one to Plus, Pro, Business, Enterprise and Edu plans inside ChatGPT Work and Codex. It is not in Chat yet. API prices below combine OpenAI's Sol announcement with third-party aggregated Astra rates, so verify them on the pricing page before you commit a budget.
| Input, per million tokens | $2.00 | $10.00 (up to 272K input) |
| Input above 272K | Not reported | $20.00 input, $75.00 output |
| Batch or Flex | Not reported | Half price |
| Fast mode | Not reported | 2x ($20 and $100) |
Look at the cached row before anything else. Standard input is exactly one-fifth the price on Sol, and so is output, but cached input is one-tenth. Sol's cached rate of $0.10 against Astra's $1.00 means a loop that rereads its context on every step gets cheaper on Sol faster than the headline ratio suggests. Agents reread context constantly, so this row is where the real money moves.
I priced four run shapes. Each is a plausible agent step sequence rolled into one run, not a measured benchmark, so substitute your own token counts.
Cached coding loop. 150,000 input tokens, of which 120,000 are cache reads and 30,000 are fresh, plus 12,000 output tokens.
Uncached coding loop. The same 150,000 input and 12,000 output with no cache hits.
Short and verbose. 20,000 fresh input tokens, 15,000 output tokens.
Long-context review. 300,000 input tokens and 12,000 output on Astra, to show the repricing above 272K.
| Cached coding loop | $0.192 | $1.020 | $192 | $1,020 |
| Uncached coding loop | $0.420 | $2.100 | $420 | $2,100 |
| Short and verbose | $0.190 | $0.950 | $190 | $950 |
| Long-context review | Not reported | $6.900 | Not reported | $6,900 |
The arithmetic for the first row: Sol costs 30,000 tokens at $2 per million ($0.06), 120,000 cached tokens at $0.10 ($0.012) and 12,000 output tokens at $10 ($0.12), for $0.192. Astra costs $0.30 plus $0.12 plus $0.60, for $1.02. The long-context row is 300,000 tokens at $20 ($6.00) plus 12,000 at $75 ($0.90). Sol's own long-context pricing does not appear in the sources I checked, so that cell stays empty rather than guessed.
Here is the same calculation as code you can edit:
const PRICE = { sol: { fresh: 2, cached: 0.10, out: 10 }, astra: { fresh: 10, cached: 1.00, out: 50 }, } function runCost ( model, freshIn, cachedIn, out ) { const p = PRICE [ model ] return ( freshIn * p. fresh + cachedIn * p. cached + out * p. out ) / 1 e6 } runCost ( ' sol ', 30000, 120000, 12000 ) // 0.192 runCost ( ' astra ', 30000, 120000, 12000 ) // 1.02 Enter fullscreen mode Exit fullscreen mode The AI Model Cost Calculator does the same sum for other models side by side, and the new Agent Run Cost Simulator lets you model a multi-step loop with growing context instead of a single flat run.
Price per token is not the only dial. OpenAI sells speed separately, and the multipliers are large.
Astra Fast mode doubles the rate to $20 and $100. On the uncached coding loop that is $4.20 per run, or $4,200 per 1,000. A third-party report puts the Ultrafast API tier at six times standard, which is $60 input and $300 output. The numbers match six times Astra's list price, so they describe Astra Ultrafast, not Sol. Treat that as reported, not confirmed. On the uncached coding loop it works out to $12.60 per run and $12,600 per 1,000, about 30 times the Sol cost for the same token counts.
In the ChatGPT plans, the same idea appears as Pro 500: $500 per month, 25 times the Plus allowance, with Astra Ultrafast included. Ultrafast generates Codex tokens eight times faster and also burns allowance at eight times the rate, so the quota depletes quickly when you use it. Buying credits on Pro 100 or 200 does not unlock it.
Inside Codex on a Plus plan, the October guide estimates 5 to 45 Astra local messages per five-hour window against 15 to 160 for Sol. That is 3 to 3.6 times more Sol messages from the same quota, so the allowance maths favours Sol too, though by less than the API maths.
Batch and Flex give Astra half price. The uncached coding loop drops to $1,050 per 1,000 runs, which is still 2.5 times Sol's standard price. Discounts do not close the gap. Only a lower failure rate can.
Cost per attempt is the wrong metric. Cost per finished task is the right one, and it is the attempt cost divided by the probability the attempt succeeds. On the uncached loop Sol costs $0.42 per attempt and Astra $2.10. Sol is cheaper per finished task when its success rate is above one-fifth of Astra's, or 20% of whatever Astra achieves.
That sounds like an easy bar, and often it is. The catch is that a failed attempt rarely costs only tokens. If a failed run leaves a broken branch that takes ten minutes of review at $60 per hour, the failure costs $10, which is 24 times the Sol token cost of the whole attempt. Now the break-even looks different. Add the human cost to the numerator and a model that fails often becomes expensive quickly, because the review time dominates the token bill.
Sol for generation. Drafting code, writing tests, refactoring within a file, summarising logs. Failures are cheap to detect and retry.
Astra for judgment. Architecture decisions, security review, multi-file changes with hidden coupling, anything where a wrong answer ships silently.
Cheaper still for triage. Classification and routing do not need either model.
A hard stop on retries. Cap attempts at three and escalate to a stronger model or a person, never loop.
A note on what is not on the table. One outlet reported that OpenAI canceled GPT-6.1 Astra after incidents involving autonomous hacking. This is a single-source report, so treat it as unconfirmed. If true, it explains why the comparison is a 6.1 Sol against a 6.0 Astra rather than two same-generation models, and it means Sol's gap to Astra may not close by an Astra refresh soon.
Take one real task from your backlog. Run it ten times on Sol and ten on Astra with logging on. Record tokens in, cached tokens, tokens out and whether the result passed your tests. Put those numbers in the calculators linked above and compute cost per passing run. If Sol passes at least 20% as often as Astra you have your default, and if the pass rates are within a few points the saving is the full 5x.
The instrumentation is the hard part, not the arithmetic. The AI Agent Ops Bundle ships the logging schema and cost dashboards that make this measurement repeatable, and the Agent Prompt Vault has 50 tested prompts so both models run against identical instructions. Keep the instructions fixed and vary only the model, or the comparison tells you nothing.
The measurement also exposes the multiplier hiding inside most agent loops, which is the number of agents per task. A pipeline that fans out to four parallel agents multiplies every figure in the tables by four before any model choice. We covered why one agent should be the default in the multi-agent tax. Fix the fan-out first, then pick the model.
If you use Codex through a ChatGPT plan instead of the API, the dollars are fixed and the question becomes how many tasks fit in the quota. Codex has no separate subscription. It is included in plans from $0 to $500, and the API-key path is billed per token and excludes cloud features such as GitHub review and Slack. Plus costs $20, Pro starts at $100 with roughly five times the Plus allowance, and overflow credits cost about $0.04 each. On those plans Sol's advantage shows up as more completed tasks per five-hour window, 3 to 3.6 times more by OpenAI's estimates, instead of lower invoices.
So the decision tree has two branches. On the API, compare cost per finished task. On a plan, compare finished tasks per window. Both reach the same default for most teams: Sol for the bulk, Astra for the steps that cannot fail quietly.
One-fifth on standard input and output ($2 and $10 against $10 and $50 per million tokens), and one-tenth on cached input ($0.10 against $1.00).
For a run with 120,000 cached and 30,000 fresh input tokens and 12,000 output tokens, $192 on Sol and $1,020 on Astra. Without caching it is $420 and $2,100.
Yes, when Sol succeeds less than one-fifth as often per attempt, or when each failure costs significant review time. Otherwise Sol wins on cost per finished task.
Yes, under the model id gpt-6.1-sol at $2.00 input, $0.10 cached input and $10.00 output per million tokens. In ChatGPT it is available in Work and Codex, not yet in Chat.