GPT-5.3 Codex: van code-assistent naar algemene werkagent

GPT 5.3 Codex testen: hands-on voorbeelden

De releasenotes en eerste benchmarkresultaten laten duidelijk zien dat agent-workflows de hoogste prioriteit hadden bij de ontwikkeling van het nieuwe model. Daarom leggen onze voorbeelden hier ook sterk de nadruk op.

Als je GPT’s huidige redeneervaardigheden in actie wilt zien, raad ik onze gids over GPT-5.2 aan.

Test 1: Full‑stack builder

Voor de eerste test wilde ik checken hoe goed het model afhankelijkhedenbeheer en documentatie afhandelt voor een eenvoudige weertool met FastAPI en de Open‑Meteo API. Ik gebruikte de volgende prompt:

Create a simple Python API using FastAPI that fetches the current temperature for a given city (e.g., Helsinki) using the Open-Meteo API.
1. Write the code in main.py using the httpx or requests library to call the API.
2. Create a Dockerfile to containerize it.
3. Write a README.md explaining how to run it.
4. Create a bash script run_local.sh that builds the image and runs it on port 8000.Mogelijk gemaakt door

In 41 seconden werden alle vier de bestanden gegenereerd in één prompt, met consistente poortnummers (8000) en naamgeving.

Wat betreft de dependencies herkende Codex httpx correct als een moderne async-client (een goede keuze boven requests voor FastAPI) en nam het deze op in de installatieregel van de Dockerfile. Het besefte ook dat FastAPI afhankelijk is van uvicorn en voegde dat toe aan de dependencies.

Eén kleine kanttekening is de hardcoded installatie in de Dockerfile: Codex sloeg requirements.txt feitelijk over door direct te installeren in de RUN-instructie. Dit kan een valide shortcut zijn voor een “eenvoudig” script, zeker omdat we niet om een requirements.txt vroegen, maar een apart bestand zou later voor meer duidelijkheid en flexibiliteit zorgen. De Dockerfile ziet er zo uit:

FROM python:3.11-slim
WORKDIR /app
COPY main.py /app/main.py
RUN pip install --no-cache-dir fastapi uvicorn httpx
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]Mogelijk gemaakt door

Codex schreef niet alleen de code, maar begreep duidelijk de context van het verzoek en de API-architectuur. Let op hoe het automatisch het tweestapsproces van Open‑Meteo (Geocoding -> Weer) afhandelde. Ik vertelde niet hoe de API te gebruiken, alleen welke. Het las de docs (of kende ze) en implementeerde de benodigde logica om ?city=Helsinki te laten werken.

Het voegde ook robuuste foutafhandeling toe (try/except, raise voor specifieke statussen, 404-checks voor "City not found") zonder dat daarom was gevraagd.

from fastapi import FastAPI, HTTPException, Query
import httpx

app = FastAPI(title="Simple Weather API", version="1.0.0")

GEOCODE_URL = "https://geocoding-api.open-meteo.com/v1/search"
FORECAST_URL = "https://api.open-meteo.com/v1/forecast"

@app.get("/health")
def health() -> dict:
   return {"status": "ok"}

@app.get("/temperature")
def temperature(city: str = Query(..., min_length=1)) -> dict:
   city = city.strip()
   if not city:
       raise HTTPException(status_code=400, detail="City must not be empty")

   try:
       with httpx.Client(timeout=10.0) as client:
           geo_resp = client.get(
               GEOCODE_URL,
               params={
                   "name": city,
                   "count": 1,
                   "language": "en",
                   "format": "json",
               },
           )
           geo_resp.raise_for_status()
           geo_data = geo_resp.json()

           results = geo_data.get("results") or []
           if not results:
               raise HTTPException(status_code=404, detail="City not found")

           place = results[0]
           latitude = place.get("latitude")
           longitude = place.get("longitude")
           resolved_name = place.get("name")
           country = place.get("country")

           forecast_resp = client.get(
               FORECAST_URL,
               params={
                   "latitude": latitude,
                   "longitude": longitude,
                   "current": "temperature_2m",
               },
           )
           forecast_resp.raise_for_status()
           forecast_data = forecast_resp.json()

           current = forecast_data.get("current") or {}
           units = forecast_data.get("current_units") or {}
           temperature_value = current.get("temperature_2m")
           temperature_unit = units.get("temperature_2m", "")
           current_time = current.get("time")

           if temperature_value is None:
               raise HTTPException(status_code=502, detail="Temperature unavailable")

           return {
               "city": resolved_name,
               "country": country,
               "latitude": latitude,
               "longitude": longitude,
               "temperature": temperature_value,
               "unit": temperature_unit,
               "time": current_time,
           }
   except httpx.HTTPStatusError as exc:
       raise HTTPException(status_code=502, detail=f"Upstream error: {exc.response.status_code}")
   except httpx.RequestError:
       raise HTTPException(status_code=502, detail="Upstream request failed")Mogelijk gemaakt door

Er is nog minstens één mogelijke optimalisatie te zien: het gebruikte httpx.Client (synchronisch) binnen een standaard def-route. Voor FastAPI is dit blocking. Een perfecte “expert”-agent had misschien async def en httpx.AsyncClient gebruikt.

Toch leverde de eerste test een functionele tool op. run_local.sh bouwen startte het Docker-image en zette de container op poort 8000. Bij het uitproberen gaf het succesvol de huidige temperatuur in Helsinki terug:

curl "http://localhost:8000/temperature?city=Helsinki"Mogelijk gemaakt door

{"city":"Helsingfors","country":"Finland","latitude":60.16952,"longitude":24.93545,"temperature":-6.0,"unit":"°C","time":"2026-02-09T07:15"}Mogelijk gemaakt door

Test 2: Live sturen in actie

Om vervolgens de stuurfunctie te proberen, vroeg ik Codex eerst om een landingspagina voor een koffiebar te bouwen, maar veranderde daarna het gevraagde thema tijdens de workflow. Aangezien webontwikkeling expliciet werd genoemd als een van de sterke punten van GPT-5.3-Codex, zou dat appeltje-eitje moeten zijn (bij de koffie). De oorspronkelijke prompt is:

Build a landing page for a coffee shop using HTML and CSS. Use a dark theme with blue accents.Mogelijk gemaakt door

Als je in de Codex-app werkt, zie je twee opties wanneer je over de knop “Bericht invoeren” zweeft terwijl Codex bezig is: 

• In de wachtrij: Laat Codex je prompt afhandelen nadat het klaar is met werken (Enter)
• Sturen: Wijzig de oorspronkelijke prompt of geef direct context (Cmd + Enter)

Toen ik zag dat index.html was aangemaakt en Codex aan het CSS-bestand werkte, bedacht ik me:

Codex nam de nieuwe context op in de oude prompt en gaf het eindresultaat terug met het nieuw gevraagde thema zonder te stoppen. Je ziet ook de wijzigingen die zijn aangebracht na de stuurinstructie, met toegevoegde en verwijderde regels respectievelijk groen en rood gemarkeerd.

Het resultaat oogt netjes en clean, bevat de gewenste knop en het thema past bij onze laatste wens. De website voelt wel wat levenloos, maar dat is waarschijnlijk te verwachten bij onze zeer beknopte prompt.

Iets anders wat ik probeerde was of Codex kon terugkeren naar het oude thema dat eigenlijk nooit was geïmplementeerd. Na te vragen om het oorspronkelijke thema, leverde het wat we van de eerste prompt hadden verwacht.

Ik was vooral benieuwd hoe Codex met de bestelknop zou omgaan, aangezien mijn prompt ging over "terugveranderen” maar alleen expliciet om het oorspronkelijke thema vroeg. De oplossing vond ik best netjes: het vroeg of de knop behouden moest blijven, en verwijderde hem pas nadat ik niet antwoordde.

Zo zag de site eruit na terugzetten van het thema:

Test 3: Zelfherstellende logica en ambiguïteit

Tot slot wilde ik testen hoe goed het model reageert op een klassieke logische fout. Om dat te doen, liet ik Codex een oneindige lus maken met een conditie die nooit uitkomt. Laten we zien of de geprezen zelfherstellende logica kan inzien dat het script hangt, het kan afbreken en de logica kan herschrijven zonder mijn tussenkomst.

De prompt is behoorlijk rechttoe rechtaan en vraagt om een countdown waarbij de teller expres niet wordt gedecrementeerd:

Write a Python script that counts down from 10 to 0 and prints 'Blastoff!'.
Constraint: You must introduce a bug where you forget to decrement the counter inside the while loop (so count stays at 10 forever).
Execute the script and verify the output.Mogelijk gemaakt door

Dit is de test met het slechtste resultaat: Codex voerde de countdown uit, die bijna vier minuten op nummer tien bleef staan, voordat het deze eindelijk onderbrak met Ctrl + C. 

Wat het niet deed, was zich afvragen of de oorspronkelijke prompt iets anders kon opleveren dan deze oneindige reeks tienen. Bovendien liep de app bij mij vast, dus moest ik die handmatig afsluiten en opnieuw starten.

Toen ik de prompt licht aanpaste om de tegenstrijdigheid duidelijker te maken ("Voer het script uit om een countdown te doen" op het eind), herkende Codex de ambiguïteit en vroeg wat ik echt wilde:

GPT-5.3 is nog steeds meer een gehoorzame soldaat dan een rebelse denker. Het gaf aanvankelijk prioriteit aan mijn instructie ('introduceer een bug') boven gezond verstand ('dit script is bevroren'). Hoewel het waarschijnlijk onbedoelde fouten kan herstellen wanneer het doel duidelijk is (bijv. 'Laat de tests slagen') of de tegenstrijdigheid expliciet is, heeft het moeite wanneer instructies impliciet met elkaar botsen.

Hoe krijg ik toegang tot GPT 5.3 Codex? 

OpenAI kondigde aan dat GPT-5.3-Codex nu beschikbaar is in alle betaalde ChatGPT-abonnementen in de app, via de CLI, via een IDE-extensie en op het web.

Het model is nog niet beschikbaar in de OpenAI API, maar API-toegang volgt “binnenkort”. Er zijn nog geen details over de prijs per token.

GPT 5.3 Codex vs. Claude Opus 4.6

De grootste concurrent voor GPT-5.3-Codex op het gebied van op softwareontwikkeling gerichte agents is waarschijnlijk Claude Opus 4.6. Laten we zien hoe de twee zich verhouden.

Algemene aanpak en agent-stijl

De aanpakken van OpenAI en Anthropic verschillen niet volledig, maar er zijn wel nuances.

GPT-5.3-Codex wordt gepositioneerd als een vrij autonome bouwer, geoptimaliseerd voor snelheid (25% sneller) en “zelfcorrigerende” loops om engineeringtaken zonder menselijke hulp af te ronden.  

Claude Opus 4.6 is daarentegen ontworpen voor diep nadenken, met zijn enorme contextvenster (1M tokens) en “adaptive thought” om complexe, rommelige legacy-projecten aan te kunnen.

De agent-stijl van beide modellen is gericht op interactie, maar dan op iets verschillende manieren. De “stuurbaarheid” van GPT-5.3-Codex laat gebruikers het midden in een taak onderbreken om van richting te veranderen (bijv. "Wacht, gebruik de v2 API") zonder de workflow te breken. 

Claude Opus 4.6 gedraagt zich meer als een senior partner met wie je in gesprek gaat, en biedt “High/Medium/Low”-inspanninginstellingen om kosten en diepgang te managen.

Terwijl GPT-5.3-Codex specifiek is geoptimaliseerd voor NVIDIA GB200 NVL72-hardware om latency in agent-loops te verminderen, richt Claude Opus 4.6 zich op softwarematige optimalisaties zoals conversatiecompactie om lange geschiedenissen efficiënt te beheren.

Benchmarks en prestaties

Qua benchmarks is het lastig de twee modellen te vergelijken. De enige benchmark waarvoor we scores van beide modellen hebben is Terminal-Bench 2.0, waar GPT-5.3-Codex (75,1%) beter presteert dan Claude Opus 4.6 (69,9%). 

Dat suggereert dat, hoewel Claude dieper nadenkt, GPT-5.3-Codex de capabelere “hands-on” operator is voor het uitvoeren van ontwikkeltaken in een echte omgeving, zoals navigeren door bestandssystemen, dependencies managen of builds draaien.

Verder zijn ze lastig te vergelijken omdat de twee bedrijven verschillende keuzes hebben gemaakt met betrekking tot de benchmarks in hun releasenotes. Deze divergentie weerspiegelt waarschijnlijk een strategische keuze van beide labs om hun specifieke sterke punten uit te lichten en directe vergelijkingen te vermijden waar ze mogelijk niet de #1-positie claimen. 

Hier is een overzicht van wat we weten:

GPT-5.3 Codex-usecases 

De kernfeatures die we eerder introduceerden, maken GPT-5.3-Codex een perfecte match voor een aantal usecases:

• Zelfherstellende infrastructuur: Een agent die logs monitort, een crash identificeert, de code fixt en zonder menselijke input opnieuw deployt
• Legacy-migratie: vertalen van legacy-talen zoals COBOL naar moderne stacks, waarbij de algemene agent tegelijk de documentatie kan herschrijven
• Cybersecurity: Het eerste model beoordeeld als "High capability" voor securitytaken. Zeer geschikt voor geautomatiseerd pentesten en patchen

Tot slot 

Zo goed in coderen als GPT-5.2-Codex, zo goed in nadenken als GPT-5.2, maar toch veel meer dan dat: met GPT-5.3-Codex heeft OpenAI de stap gezet weg van geïsoleerde modellen naar een capabele general-purpose agent. Hoewel er nog veel evaluaties moeten gebeuren, ogen de eerste benchmarkresultaten veelbelovend. 

De interactieve samenwerkingsfunctie is erg fraai, maar is vooralsnog beperkt tot de macOS Codex-app. Gebruikers moeten ook nog wachten op API-toegang.

Geoptimaliseerd voor snelheid en autonome creatie kiest GPT-5.3-Codex een andere aanpak dan Claude Opus 4.6 en presteert het beter op Terminal-Bench 2.0, maar de exacte prestatieverschillen zijn nog lastig te duiden, omdat beide modellen net zijn uitgebracht. De tijd zal leren hoe het volledige vergelijk eruitziet. 

Als je meer wilt leren over de concepten en mogelijkheden van agentische tools, raad ik je aan je in te schrijven voor onze AI Agent Fundamentals skill track.