GPT 5.5 Codex im Praxistest: Der große Sprung zu Agenten-Intelligenz

GPT 5.5 Codex im Praxistest: Der große Sprung zu Agenten-Intelligenz

Die OpenAI-Ankündigung kam um 9:04 Uhr am 23. April 2026. Ich hatte gerade ein Terminal geöffnet, um eine Laravel-Migration zu pushen. Zwanzig Minuten später lag die Migration noch immer unberührt in meinem Staging-Branch, weil ich auf die GPT 5.5-Vorstellungsseite starrte und überlegte, ob dies wirklich der Release ist, der seinen eigenen Hype rechtfertigt – oder nur wieder ein sechs Wochen-Update, das als Sprung verkauft wird.

Die Zahl, bei der ich hängenblieb, war diese: 82,7 % bei Terminal-Bench 2.0. Das ist der aktuelle Stand der Technik bei dem Benchmark, der prüft, ob ein Modell wirklich planen, iterieren und Tools in einer Shell koordinieren kann – also exakt das, woran agentisches Coding entweder genial oder peinlich scheitert. Opus 4.7 liegt laut digitalapplied Vergleich auf demselben Benchmark bei 69,4 %. Das sind 13 Prozentpunkte Abstand. Dreizehn Punkte sind der Unterschied zwischen "vielversprechend" und "bitte produktiv einsetzen".

Aber Benchmarks täuschen. Nicht mit Absicht – sie messen eben das, was sie messen, und selten das, was am Ende zählt. Mir geht es darum, ob GPT 5.5 im Codex meine Wochenmitte tatsächlich verkürzt. Also habe ich es zwei Tage lang an drei Projekten getestet, für die ich normalerweise einen Senior-Entwickler engagiert hätte: ein absurderweise detailliertes SVG, ein natives macOS-Retro-Arcadegame mit KI-generierten Sprites und eine First-Person-3D-Dungeon-Arena, gerendert in einem Viertel-Viewport. Echte Aufgaben. Echte Durchläufe. Echte Kosten.

Bleib beim Dungeon-Test dabei. Genau dort ist meine Annahme, "GPT 5.5 ist nur ein schnelleres 5.4", realitätsnah zusammengebrochen – und ich musste mein ganzes Review neu aufrollen.

Warum Dieses Release Wirklich Bedeutet (Und Warum Codex Sich Geändert Hat)

Das Veröffentlichungs­tempo in dieser Branche ist völlig entfesselt. GPT 5.4 kam im Februar heraus. Opus 4.7 erschien Mitte April. GPT 5.5 folgte eine Woche später. Wir bekommen jetzt etwa alle sechs bis acht Wochen ein neues Frontier-Coding-Modell – und jedes einzelne soll "das Modell sein, das alles verändert".

Die meiste Zeit ist das Marketing. Diesmal fühlt sich das Framing aber anders an – und nicht, weil OpenAI das sagt. Es liegt an drei konkreten Veränderungen.

Erstens ist GPT 5.5 das erste vollständig neu trainierte Basismodell seit GPT-4.5. Alles zwischen 4.5 und 5.4 war eine Weiterentwicklung derselben zugrunde­liegenden Basis. GPT 5.5 ist ein neues Fundament. Das ist kein kleiner Unterschied – es bedeutet, dass das Pretraining-Korpus, die Architektur-Entscheidungen und die agentenorientierten Ziele von Grund auf neu entworfen wurden, mit autonomer Arbeit als Ziel, nicht bloßer Qualität von Gesprächs­antworten.

Zweitens hat das Kontextfenster in der API auf 1 Mio. Tokens zugelegt. Die API von GPT 5.4 endete bei 512.000. Die Verdopplung ist nicht einfach ein größerer Puffer – es ist eine andere Kategorie von Arbeit. Ein 1-Millionen-Kontextfenster bedeutet, dass ein Agent einen kompletten mittelgroßen Codebase, sein Test-Set und die relevante Dokumentation in einer einzigen Session halten kann, ohne Kürzungs-Tricks. Im OpenAI MRCR v2 8-Needle-Retrieval-Benchmark im 512K-1M-Bereich erreicht GPT 5.5 74,0 %, während Opus 4.7 auf 32,2 % kommt. Das ist keine Lücke – das sind zwei grundverschiedene Fähigkeiten.

Drittens, die Codex-Integration hat ein echtes Upgrade bekommen. Sie können jetzt pro Aufgabe zwischen mittlerem, hohem und extra-hohem Reasoning-Aufwand wählen. Mittel ist Standard. Hoch ist für nicht-triviale Refactorings. Extra hoch wählt man, wenn eine Aufgabe tatsächlich erweitertes Reasoning verlangt – große Migrationen, Sicherheits-Audits, Architektur­entscheidungen. Laut Artificial Analysis liegt GPT 5.5 (xhigh) aktuell mit einem Intelligenz-Index von 60 vorne, GPT 5.5 (high) folgt mit 59. Das Einstellen ist wichtig, weil Sie den Compute-Aufwand erstmals flexibel an den Schwierigkeitsgrad der Aufgabe koppeln können.

Bevor ich zu den Tests komme – eines vorneweg zur Preisgestaltung und Positionierung, denn das verändert die Einordnung für alles, was danach kommt.

Die Preisgestaltung und was sie über die Strategie verrät

GPT 5.5 wird mit $5 pro Million Eingabetokens und $30 pro Million Ausgabetokens angeboten. GPT 5.4 lag bei $2,50 bzw. $15. Eine glatte Verdopplung. Wenn du einen hochvolumigen agentischen Stack betreibst, schlägt diese Verdopplung sofort auf deine Kostenrechnung durch.

Das ist das Argument, das die Rechnung aufgehen lässt: GPT 5.5 benötigt signifikant weniger Tokens, um die gleichen Codex-Aufgaben zu erledigen. Laut OpenAIs eigener Aussage entspricht die Token-Latenz der von GPT 5.4, während das Intelligenzniveau materiell steigt. Anders gesagt — das Modell arbeitet effizienter, sodass der reine Preis pro Aufgabe selbst bei verdoppelten Stückkosten in etwa gleich bleibt oder sogar besser ausfällt.

Im Vergleich dazu: Opus 4.7 liegt bei $5 pro Million Eingabetokens und $25 pro Million Ausgabetokens. Auf dem Papier ist Opus 4.7 bei den Ausgabetokens 17% günstiger. In der Praxis kommt Opus 4.7 jedoch mit einer Tokenizer-Änderung, die den Tokenverbrauch bei bestimmten Workloads laut die Axios-Berichterstattung um etwa 35% erhöht. Das angebliche "günstiger pro Token" beginnt also genau dann zu verschwinden, wenn dein Tokenizer für identische Aufgaben deutlich mehr Tokens verbraucht.

Das ist der eigentliche ökonomische Wettstreit zwischen GPT 5.5 und Opus 4.7: Wessen Tokens kosten tatsächlich, was sie kosten sollen? Und derzeit hat niemand mit realen Workloads vollständige Daten. Ich protokolliere nun jeden Codex-Run gegen den jeweiligen Claude-Code-Run, genau weil bislang keine verlässliche Quelle echte Stückkosten veröffentlicht hat. (Falls du den direkten Vergleich sehen willst, den ich für vier Produktiv-Builds durchgeführt habe: Das habe ich separat in GPT 5.5 vs Opus 4.7 getestet auf echten Coding-Builds dokumentiert.)

Jetzt — zu den Tests. Wir starten mit dem einfachsten, weil mich selbst der noch überrascht hat.

Test Eins: Das absurde SVG-Einhorn

Dies ist der Test, den Simon Willison populär gemacht hat — ein Modell soll ein SVG von etwas Bestimmtem erzeugen, ohne externe Tools, nur reine Textgenerierung von Vektorpfaden. Es ist ein brutaler Test, denn SVG verlangt vom Modell, dass es Koordinaten und Kurven mental vorwegnimmt, bevor es diese ausgibt. Es gibt kein DOM als Referenz, kein Bildmodell, an das ausgelagert werden kann. Nur Geometrie, im Kopf, direkt zur Ausgabe.

Ich gab GPT 5.5 einen einzigen Prompt in Codex: „Erzeuge ein detailliertes SVG von einem Einhorn, das sich auf die Hinterbeine stellt, mit wallender Mähne und sichtbarer Muskulatur. Reines SVG, keine externen Referenzen.“

Rechenaufwand: mittel.

Die Ausgabe dauerte 38 Sekunden. Es waren 1.847 SVG-Zeilen. Als ich das Ergebnis in einen Browser einfügte, wurde tatsächlich ein Einhorn angezeigt. Ein steigendes Einhorn. Mit wallender Mähne. Die Muskulatur war anatomisch nicht korrekt – der Knick des Vorderbeins war etwas daneben und die hintere Keule sah eher nach Ziege als nach Pferd aus – aber die Komposition war auf den ersten Blick als Einhorn erkennbar. Ich konnte das Motiv identifizieren, ohne zu wissen, was es darstellen sollte.

Zum Vergleich ließ ich denselben Prompt auf GPT 5.4 laufen. Es dauerte 52 Sekunden, produzierte 2.340 Zeilen, und das Ergebnis sah aus wie ein Einhorn, das von jemandem gezeichnet wurde, der einmal ein Pferd in einem Buch gesehen hat. Die Mähne endete in seltsamen Winkeln. Das Horn war bei bestimmten Zoomstufen vom Schädel getrennt.

Gleicher Prompt, schlechteres Ergebnis, mehr Tokens, längere Laufzeit. Genau das ist das Effizienz-Argument am einfachsten möglichen Test.

Aber überzeugt war ich noch nicht. SVG-Generierung ist eine Aufgabe, bei der das Trainingskorpus eine enorme Rolle spielt – und wenn GPT 5.5 in der Vortrainingsphase mehr SVG-Beispiele gesehen hat, sagt mir dieses Ergebnis mehr über die Daten als über das eigentliche Schlussfolgern. Also ging ich über zu dem Test, der wirklich autonome Zerlegung fordert.

Test Zwei: Native macOS Retro Arcade Game mit KI-Sprites

Der Prompt: "Baue eine native macOS-App — Swift und SpriteKit — die ein Retro-Arcade-Bibliotheksspiel implementiert. Der Spieler steuert einen Bibliothekar, der Bücherregale wieder auffüllt und herabfallenden Büchern ausweicht. Verwende GPT Image 2.0, um alle Sprite-Assets zur Laufzeit zu generieren. Verpacke das Ganze als lauffähiges Xcode-Projekt."

Das ist ein echter Härtetest. Codex muss dazu in der Lage sein:

1. Ein natives macOS-Xcode-Projekt korrekt zu scaffolden
2. Einen Sprite-basierten Game-Loop mit Kollisionserkennung zu designen
3. Über die API GPT Image 2.0 zur Sprite-Generierung anzusteuern
4. Asynchrones Laden der Bilder als SpriteKit-Texturen zu handhaben
5. Das gesamte Projekt so zu packen, dass es beim ersten Build lauffähig ist

Ich stellte die Inferenzintensität auf "hoch", weil "mittel" bei dieser Aufgabe schon fast fahrlässig optimistisch gewesen wäre.

Codex lief autonom etwa 11 Minuten. Das erste, was mir auffiel – und das war wirklich neues Verhalten – war, dass Codex eigene Testzyklen durchführte. Es baute das Projekt, versuchte das Spiel zu starten, traf auf einen SpriteKit-Initialisierungsfehler, diagnostizierte das Problem, indem es den eigenen Build-Output inspizierte, modifizierte den Initialisierungscode, baute erneut und startete wieder. Das tat es dreimal hintereinander, ganz ohne Eingriff. Bei GPT 5.4 hätte ich für dieselbe Aufgabe mindestens zweimal beim Fehlermeldungs-Pingpong eingreifen müssen. Bei GPT 5.5 saß ich da, schaute dem Scrollen im Terminal zu und trank Kaffee.

Der finale Build startete. Der Bibliothekar-Sprite ließ sich mit den Pfeiltasten bewegen. Bücher fielen vom oberen Rand des Bildschirms. Die Kollisionserkennung funktionierte. Der Game-Loop lief mit ca. 30 Frames pro Sekunde — nicht, weil das das Ziel war, sondern weil das Laden der Sprites über GPT Image 2.0 die gesamte Pipeline ausbremste.

Und genau dort zeigte sich das erste echte Limit. Jeder Sprite-Generierungs-Aufruf traf die Image-API und dauerte zwischen 8 und 14 Sekunden pro Sprite. Bis das Spiel alle Assets geladen hatte, hatte ich mehr Zeit mit dem Warten auf Texturen als auf Code verbracht. Die generierten Sprites wirkten dunkel und ein wenig chaotisch – das Gesicht des Bibliothekars wurde bei jedem Ladevorgang anders dargestellt, weil die Sprite-Generierung zur Laufzeit ohne Seed erfolgte. Es funktionierte. Es war aber nicht auslieferbar. Irgendwo zwischen Tech-Demo und Prototyp.

Interessant ist hier nicht, dass das Spiel holprig war. Sondern, dass Codex den gesamten Zyklus übernommen hat – Scaffolding, Implementierung, API-Integration, autonome Debug-Loops – ohne dass ich die Aufgabe in Teilschritte aufbrechen musste. Genau das meinen die Release-Notes mit "agentic coding". Es geht nicht darum, dass das Modell besseren Code schreibt. Sondern darum, dass das Modell seine Arbeit selbstständig durchführt.

Profi-Tipp: Wenn du die agentische Fähigkeit eines Modells testen willst, nimm eine Aufgabe, die Werkzeug-Autonomie in einer Umgebung erfordert, die das Modell tatsächlich beobachten kann. Eine reine Code-Generierung misst nicht das Verhalten als Agent – sie misst nur Übersetzung. Gib dem Modell Build-Fehler, die es lesen und lösen muss, und du siehst, ob die Autonomie echt ist oder reine Show.

Jetzt – der Test, bei dem meine Annahmen öffentlich blamiert wurden.

Test Drei: First-Person-3D-Dungeon-Arena

Der Prompt: „Baue einen First-Person-3D-Dungeon-Arena-Prototypen. Three.js, TypeScript. Render die 3D-Szene nur im oberen linken Viertel des Viewports. Die übrigen drei Quadranten zeigen ein HUD: Minimap, Gesundheit, Inventar. Kämpfe gegen einfache Gegner. Liefere es als lauffähigen Web-Prototyp aus.“

Das Rendering im Viertel-Viewport ist bewusst gewählt. Die meisten 3D-Game-Tutorials gehen von einer Vollbilddarstellung aus. Die Beschränkung auf ein Viertel zwingt das Modell dazu, die Three.js-APIs für Kamera, Viewport und „scissor“ zu durchdringen – Copy-Paste von Tutorial-Grundgerüsten reicht nicht mehr.

Schwierigkeitsgrad beim Inference: besonders hoch. Ich wollte sogar die Decke sehen.

Codex lief 23 Minuten. In dieser Zeit hat es:

• Ein Vite- + TypeScript- + Three.js-Projekt korrekt scaffoldet
• Pointer-Lock-Controls für First-Person-Bewegung implementiert
• Die Scissor-/Viewport-Logik für das Rendering im Viertel-Viewport eingerichtet
• Gegnerische Meshes und eine einfache Pathfinding-Schleife gebaut
• Eine Minimap verkabelt, die die Spielerposition im Canvas rendert
• Ein Kampfsystem mit Raycasting zur Treffererkennung umgesetzt
• Drei verschiedene TypeScript-Fehler eigenständig behoben

Als es fertig war, öffnete ich localhost. Die 3D-Szene wurde im oberen linken Quadranten gerendert. Bewegung mit WASD funktionierte. Die Minimap zeigte die Position korrekt an. Es gab Gegner, und sie reagierten, wenn ich mich näherte. Das Kampfraycasting registrierte Treffer. Das HUD war ... rudimentär. Die Gesundheitsleiste war ein graues Rechteck. Das Inventar eine leere Platzhalter-Textfläche. Die Gegner-Meshes waren Würfel mit nicht ganz passenden Face-Texturen.

Es funktionierte. Es war im buchstäblichen Sinne spielbar. Im sinnvollen Sinne war es nicht releasefähig. Zwischen „spielbarer Prototyp“ und „echtem Spiel“ klafft exakt die Lücke, die Menschen typischerweise über Wochen schließen.

Hier kommt der Punkt, der meine Sichtweise verändert hat: Im Verlauf des Durchlaufs entschied Codex eigenständig, ein Debug-Overlay einzubauen, das die Scissor-Rechtecke anzeigt. Ich habe das nicht angefordert. Es implementierte das Overlay, nutzte es, um das eigene Rendering zu überprüfen, und ließ es im finalen Output drin. Das ist keine herkömmliche Codegenerierung. Das ist eine Tool-Use-Entscheidung, die darauf hindeutet, dass das Modell ein internes Modell des eigenen Workflows besitzt – ein diagnostisches Feature wird dann eingebaut, wenn es für die eigene Korrektheitsprüfung gebraucht wird.

Ob das für dich substanzielle Bedeutung oder nur Marketingsprache hat, hängt davon ab, wie viel Zeit du mit agentischen Stacks verbracht hast. Für mich ist es eindeutig: Die Modelle, die sich wirklich agentisch anfühlen, sind nicht die, die einfach mehr Code schreiben. Es sind die, die von sich aus diagnostische Zwischenschritte in den Workflow einbauen, ohne dazu aufgefordert zu werden.

Wenn du möchtest, dass jemand genau diesen Codex-basierten, autonomen Workflow von Grund auf in die Dev-Pipeline deines Teams integriert, biete ich genau solche Engagements an – meine Arbeiten findest du unter fiverr.com/s/EgxYmWD.

Was GPT 5.5 tatsächlich richtig macht

Drei Dinge aus zwei Tagen echter Arbeit.

Der autonome Debug-Zyklus ist real. Das ist der mit Abstand größte Wandel. GPT 5.4 in Codex generierte Code, scheiterte und reichte mir den Fehler weiter. GPT 5.5 in Codex generiert Code, scheitert, liest den Fehler, behebt ihn und macht weiter. Bei iterativen Aufgaben — alles, was mit Builds, Tests oder Laufzeitfehlern zu tun hat — potenziert sich das erheblich. Eine Aufgabe, die früher „fünf Runden Prompt/Fehler/neuer Prompt” bedeutete, wird jetzt zu einem unterbrechungsfreien Durchlauf.

Token-Effizienz ist kein Marketing-Slogan. Ich habe die Anzahl der ausgegebenen Tokens in beiden Modellen bei vier vergleichbaren Aufgaben verfolgt. GPT 5.5 brauchte im Schnitt 34 % weniger Output-Tokens bei funktional identischen Ergebnissen. Der Code war nicht kürzer — aber weniger erklärend geschrieben. Weniger Inline-Kommentare. Strengere Whitespaces. Weniger „So, das werde ich jetzt machen” im Vorspann. Ob das stilistisch ein Gewinn oder Verlust ist, hängt davon ab, ob man den Code liest oder einfach nur produktiv ausliefert.

Das 1M-Kontextfenster verändert die Aufgabenstellung. Ich habe den vollständigen Source-Code einer Laravel-Anwendung — 240 Dateien, ungefähr 680.000 Tokens — in Codex eingespeist und ihn gebeten, den Authentifizierungs-Flow zu prüfen. Das Modell las alles und erstellte ein Audit, das sich auf spezifische Methodensignaturen in 14 verschiedenen Dateien bezog. Opus 4.7 stieß bei derselben Aufgabe an sein Kontextlimit und produzierte ein vageres Audit an einem Teilbestand. Hier geht es nicht um rohe Fähigkeiten — sondern darum, welche Aufgaben ohne Vorverarbeitung direkt adressiert werden können.

Was GPT 5.5 immer noch falsch macht

Drei ehrliche Grenzen.

Komplexe kreative Aufgaben benötigen weiterhin Aufsicht. Der Dungeon-Prototyp funktionierte insofern, als er lief. Er funktionierte jedoch nicht in dem Sinne, dass jemand ihn hätte spielen können. Die Lücke zwischen „technisch ausführbar“ und „marktreif“ ist immer noch vollständig menschlich, wenn es um Geschmack oder das Gespür für Gameplay geht.

Extra-hohe Inferenz ist teuer und langsam. Die Dungeon-Aufgabe auf xhigh verbrannte erhebliche Rechenleistung und dauerte 23 Minuten. Wenn du eine enge Feedbackschleife aufbaust, ist xhigh nicht dein Alltags-Setup. Medium ist aus gutem Grund der Standard. Ich würde xhigh für Migrationen, Security Audits und Architekturentscheidungen heranziehen – nicht für die Feature-Entwicklung.

Bildgenerierung-Integration hat Latenzprobleme. Der macOS-Spieltest wurde durch die 8-14 Sekunden lange Sprite-Generierung von GPT Image 2.0 ausgebremst. Wenn dein Workflow zur Laufzeit auf Bildgenerierung angewiesen ist, bist du dem Image-API ausgeliefert – nicht dem Sprachmodell. Das ist kein GPT 5.5-Problem, aber definitiv ein Codex-Workflow-Problem, auf das du sofort stoßen wirst.

Was das für Anthropic, Claude und das größere Spiel bedeutet

Hier ist Vorsicht geboten, denn Spekulationen über die Rechenzuteilung an den Frontlinien-Laboren sind meist Unsinn, und die wohlwollende Auslegung ist in der Regel zutreffend. Doch das Muster ist schwer zu übersehen.

Opus 4.7 wurde mit Rückschritten ausgeliefert, die ein lauter Teil der Power-User sofort meldete – eine Tokenizer-Änderung, die die Nutzung aufbläht, verringerte Standard-Tiefgründigkeit beim Schlussfolgern und Verschiebungen im Befolgen von Anweisungen. Mythos, das leistungsfähigere, bislang unveröffentlichte Modell von Anthropic, ist durch einen restriktiven Zugang abgeschottet – Banken- und Regierungspiloten. Anthropic hat öffentlich verneint, dass eine Umverteilung von Compute diese Entscheidungen antreibt. Ich habe keinen Grund, das anzuzweifeln.

Aber das lässt sich beobachten: GPT 5.5 wurde breit für zahlende Nutzer mit einem 1M-Kontextfenster ausgeliefert, dazu ein aggressiver, von NVIDIA gestützter Inferenz-Stack, der auf GB200 NVL72-Systemen läuft und 50-mal höhere Token-Durchsätze pro Megawatt als frühere Generationen ermöglicht. Das ist eine echte Compute-Ansage. Wenn man sich im Kapazitätswettlauf befindet und der Wettbewerber ein Modell ausrollt, das breit verfügbar, nach Tokenizer-Effekten günstiger pro Ausgabetoken und bei gleichwertigen Aufgaben schneller ist – dann ist der Druck real, ob man das nun öffentlich eingesteht oder nicht.

Für mich als Builder ergibt sich daraus ganz praktisch: Setze auf das Modell, das heute tatsächlich in der Produktion bei Nutzern ankommt, nicht auf das Modell mit der stärksten hypothetischen Fähigkeit. Für die meisten Coding-Agent-Anwendungen ist das derzeit GPT 5.5. Opus 4.7 bleibt meine Wahl für Longform-Writing, subtilen Code-Review und Architekturgespräche. Mythos ist für meinen Workflow irrelevant, da ich es nicht nutzen kann. Das Modell, das ich nicht laufen lassen kann, hilft mir auch nicht beim Ausliefern.

Ist GPT 5.5 Codex das Abonnement wert?

Das hängt von deinem Arbeitsaufkommen ab. Wenn du Codex täglich einsetzt, rechtfertigen die gesteigerte Token-Effizienz und die autonomen Debug-Schleifen die Preisverdopplung in der ersten Woche. Für Gelegenheitsnutzer wird der Sprung von 5.4 auf 5.5 bei einzelnen Prompts nicht spektakulär wirken – die wirklichen Stärken zeigt das Upgrade bei mehrstufigen, autonomen Aufgaben. Betreibst du einen Agenten-Stack im großen Maßstab, eröffnen der 1M-Kontext und die Einstellung „xhoche Reasoning“ Arbeitsfelder, die bisher unmöglich waren – und oft handelt es sich dabei um die besonders wertschöpfenden Kategorien.

Die eigentliche Frage beim Abonnement lautet für mich: Wie hoch sind die Grenzkosten für die Aufgabe, die du das Modell gerade erledigen lässt? Ist die Antwort „Senior-Entwickler-Zeit zu 150 $/Stunde“, ist das Abonnement ein No-Brainer. Ist die Antwort „Ich lerne im Free Tier“, sieht die Rechnung ganz anders aus. Für mich selbst hat sich das Codex-Abo bereits in der ersten Woche amortisiert – bei Builds, die ich sonst ausgelagert hätte.

Häufig gestellte Fragen

Wann wurde GPT 5.5 veröffentlicht und wer kann es nutzen?

GPT 5.5 wurde am 23. April 2026 für zahlende ChatGPT-Nutzer auf den Plus-, Pro-, Business- und Enterprise-Tarifen veröffentlicht, mit API-Verfügbarkeit zu $5 pro eine Million Eingabe-Tokens und $30 pro eine Million Ausgabe-Tokens. Es wird mit Codex, OpenAIs agentischer Coding-Umgebung, ausgeliefert. Siehe oben im Abschnitt zur Release-Übersicht für das vollständige Kontextfenster und die Preisaufstellung.

Was ist der Unterschied zwischen mittlerer, hoher und extra hoher Inferenz bei GPT 5.5?

Medium ist die Standard-Einstellung in Codex und für die meisten Aufgaben geeignet. High aktiviert tiefere Reasoning-Chains für komplexe Refactorings und Multi-File-Arbeiten. Extra-high (xhigh) liefert die qualitativ hochwertigsten Ergebnisse bei Problemen, die tatsächlich ausgedehnte Begründungen erfordern — große Migrationen, Sicherheitsanalysen, Architekturentscheidungen — allerdings bei deutlich höherer Latenz und Kosten. Laut Artificial Analysis führt GPT 5.5 xhigh ihren Intelligenz-Index mit 60 gegenüber 59 für high an. Im Dungeon-Arena-Test oben sehen Sie, wie sich xhigh in der Praxis bewährt.

Wie schneidet GPT 5.5 beim Coden im Vergleich zu Claude Opus 4.7 ab?

GPT 5.5 führt bei agentischen Coding-Benchmarks (82,7 % auf Terminal-Bench 2.0 vs. 69,4 % für Opus 4.7) und bei der Arbeit mit langen Kontexten. Opus 4.7 liegt bei SWE-Bench Pro (64,3 % vs. 58,6 %) und MCP-Atlas vorne. Die praktische Aufteilung: GPT 5.5 für autonome Workflows und Ausführung, Opus 4.7 für sorgfältiges Refactoring und Code-Review. Einen vollständigen Direktvergleich auf vier echten Builds finden Sie im GPT 5.5 vs. Opus 4.7 Vergleich.

Lohnt sich das GPT 5.5 Codex-Abo?

Für tägliche Codex-Nutzer ja — die Token-Effizienz und autonomen Debug-Loops amortisieren das Abo im ersten Arbeitsweek bei nicht-trivialer Arbeit. Für Gelegenheitsnutzer ist das Upgrade weniger gravierend. Das Modell glänzt bei mehrstufigen agentischen Aufgaben, bei denen es eigenständig Build-/Test-/Fix-Zyklen ohne Ihr Eingreifen durchlaufen kann. Einen vollständigen Kosten-Nutzen-Vergleich finden Sie im Worth-It-Abschnitt oben.

Kann GPT 5.5 tatsächlich Spiele bauen oder nur Prototypen?

Laut eigenen Tests erstellt GPT 5.5 spielbare Prototypen, die fehlerfrei laufen, aber die Lücke zwischen „technisch ausführbar“ und „lieferbar“ bleibt bei kreativen Aufgaben, die Urteilskraft und ein Gefühl für Gameplay erfordern, weiterhin menschlich. Der Dungeon-Arena-Test ergab bei xhigh reasoning innerhalb von 23 Minuten einen funktionierenden 3D-Prototypen — doch HUD, Texturen und das Gesamt-Finishing erforderten Iteration und Feinschliff, wie ihn nur ein menschlicher Game Designer liefern kann.

Die eine Sache, die du heute tun kannst

Vergiss die Benchmarks für einen Moment. Das ist der Test, den ich wirklich machen würde, wenn du herausfinden willst, ob GPT 5.5 Codex in deinen Stack gehört.

Wähle eine Aufgabe, vor der du dich schon länger drückst. Etwas mit mehreren Schritten. Etwas, das normalerweise einen konzentrierten Nachmittag kostet. Eine Migration, ein Refactoring, ein Feature, das drei Module berührt. Öffne Codex. Stelle das Reasoning auf hoch. Formuliere die Aufgabe als einzigen Prompt. Geh für fünfzehn Minuten weg.

Wenn du zurückkommst, weißt du genau das, was ich weiß: ob die autonome Schleife für deinen Workflow Realität ist – oder doch nur Hype. Das ist keine Benchmark-Frage. Das ist eine Dienstagnachmittag-Frage. Und an Dienstagnachmittagen werden Karrieren gebaut.

Das aufbäumende Einhorn-SVG, das ich am ersten Tag generiert habe, liegt immer noch in einem Ordner auf meinem Laptop. Ich bewahre es als Erinnerung auf. Noch vor sechs Wochen wäre diese Qualität von One-Shot-Output ein viraler Tweet gewesen. Heute ist das der neue Maßstab nach unten. Wo die Grenze nach oben liegt, habe ich noch nicht ausgelotet – und der einzige Weg, es herauszufinden, ist, die Loop mit immer schwierigeren Prompts zu fordern, bis sie bricht.

Also geh und bring etwas zum Absturz. Und sag mir dann, was du herausgefunden hast.

Lassen Sie uns zusammenarbeiten

Möchten Sie KI-Systeme entwickeln, Workflows automatisieren oder Ihre Tech-Infrastruktur skalieren? Ich unterstütze Sie gerne.

• Fiverr (individuelle Builds & Integrationen): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (Enterprise-Lösungen): ramlit.com
• ColorPark (Design & Branding): colorpark.io
• xCyberSecurity (Security Services): xcybersecurity.io