Leerpad
Associate AI Engineer voor ontwikkelaars
26 Hr
Wat is de GPT-6 Astra API?
De GPT-6 Astra API is hoe je toegang krijgt tot OpenAI’s nieuwe vlaggenschipmodel, uitgebracht op 3 september 2026, via de Responses API. Voor deze tutorial telt vooral het oppervlak: gpt-6-astra accepteert tekst- en beeldinvoer via OpenAI’s Responses API. De reasoning effort varieert van low tot max, zonder optie none.
De voorbeelden in deze tutorial gebruiken client.responses.create in plaats van client.chat.completions.create, maar migratie vereist ook wijzigingen in formaten voor verzoek, output en toolresultaten. Verwijder ook de aangepaste temperature-, top_p- en log-probability-instellingen, want Astra ondersteunt die niet. Voor we de eerste call doen, kijken we naar de prijs.
Hoeveel kost GPT-6 Astra?
Voor aanvragen met maximaal 272.000 inputtokens is de standaardprijs $10 per miljoen gewone inputtokens en $50 per miljoen outputtokens. Gecachte input kost $1 per miljoen en cachewrites kosten $12,50 per miljoen.
Zodra een verzoek die drempel overschrijdt, past OpenAI een 2x-multiplier toe op de input- en cacheratio’s en een 1,5x-multiplier op het outputtarief. De hogere tarieven gelden voor het volledige verzoek, niet alleen voor de tokens boven de drempel. Geen van de runs in deze tutorial kwam in de buurt van de drempel.
Wat gaan we bouwen met de GPT-6 Astra API?
De staging-app is een klein Flask-taakbord: een homepagina, een formulier om een taak toe te voegen, een knop om er een af te vinken en een /health endpoint. De complete code, inclusief staging-app, staat in deze GitHub-repository.
Drie vooraf ingevulde taken verschijnen vóór het testen. Afbeelding door de auteur.
De app heeft één opzettelijke fout. De agent heeft drie checks, maar alleen de testset is bedoeld om ze te vangen.
Waarom accepteert de app lege taaktitels?
De endpoint voor het aanmaken van taken wijst een lege titel niet af. Ik liet dat gedrag staan zodat de agent een bekende fout kan vinden zonder die in de prompt te onthullen.
Welke releasechecks kan de agent uitvoeren?
De agent kan drie tools aanroepen:
-
run_test_suitedraait pytest, inclusief een bulkimporttest met zo’n 250 HTTP-aanvragen. -
check_ui_flowgebruikt Playwright om een taak toe te voegen en te bevestigen dat die verschijnt. -
check_staging_healthverstuurt een GET-verzoek naar/health.
Alle drie draaien tegen staging, zonder mocks. De browsercheck gebruikt vaste code; de demo met modelgeschreven computergebruik komt later.
Hoe stel je de GPT-6 Astra API in Python in
Je hebt een OpenAI API-sleutel nodig met toegang tot gpt-6-astra. Maak een sleutel aan op platform.openai.com/api-keys en controleer dat je project gpt-6-astra heeft ingeschakeld. Enterprise-werkruimtes hebben Astra bij lancering standaard uit.
De onderstaande commando’s gebruiken Windows PowerShell en installeren alle pakketten die voor deze tutorial nodig zijn, inclusief OpenAI’s realtime voor de steering-demo.
python -m venv .venv
.venv\Scripts\Activate.ps1
Copy-Item .env.example .env
pip install "openai[realtime]" flask pytest playwright pydantic matplotlib python-dotenv streamlit
playwright install chromiumOp macOS of Linux vervang je het activatiecommando door source .venv/bin/activate en het kopieercommando door cp .env.example .env.
Voeg vervolgens de API-sleutel toe aan het nieuwe .env-bestand: open het .env-bestand dat je zojuist hebt gekopieerd en voeg OPENAI_API_KEY=sk-... toe, dat door python-dotenv wordt geladen en automatisch door de SDK wordt opgepikt, zodat je de sleutel nooit in code hoeft mee te geven.
Als projectspecifieke dependencies of .env-bestanden nieuw voor je zijn, onze virtual environment- en environment variables-gidsen leggen ze uit. Controleer of de sleutel werkt voordat je erop verder bouwt.
Als je API-sleutel al werkt met de Responses API, sla de volgende subsectie over en begin met de synchrone tool-lus. Het eerste verzoek verifieert alleen de setup.
Doe je eerste GPT-6 Astra API-call
Zodra de sleutel is ingesteld, moet hij worden geladen met dotenv. Daarna kun je een OpenAI-client maken en je eerste verzoek sturen met de functie client.responses.create(). De kleinst mogelijke aanvraag ziet er zo uit:
from dotenv import load_dotenv
from openai import OpenAI
load_dotenv()
client = OpenAI()
response = client.responses.create(
model="gpt-6-astra",
reasoning={"effort": "low"},
input="In one sentence, what is a staging environment used for?",
)
print(response.output_text)Het veld usage van de response geeft de aantallen tokens die nodig zijn voor de latere kostenberekening.
Bouw een synchrone GPT-6 Astra-tool-lus
De fragmenten hieronder zijn uittreksels; de uitvoerbare versies staan in de bijbehorende GitHub-repository.
Voor ik iets asyncs aanraakte, bouwde ik de gewone versie:
-
Roep het model aan
-
Controleer op een
function_call-item -
Voer de bijbehorende tool uit
-
Stuur het resultaat terug met
previous_response_id -
Herhaal tot het model stopt met tools vragen.
Deze blokkerende lus is de basislijn voor de async-vergelijking.
for turn in range(max_turns):
response = client.responses.create(
model="gpt-6-astra",
reasoning={"effort": "low"},
tools=TOOLS,
input=next_input,
previous_response_id=previous_response_id,
)
calls = [item for item in response.output if item.type == "function_call"]
if not calls:
final_text = response.output_text
break
outputs = [
{"type": "function_call_output", "call_id": call.call_id, "output": run_tool(call)}
for call in calls
]
next_input, previous_response_id = outputs, response.idWat de basislijn-run vond
In de basislijn-run riep het model elke tool om de beurt aan. Het vond de bekende validatiefout en gaf een no-go-beslissing terug. Over drie runs bedroeg de gemiddelde wall-clocktijd 23,40 seconden. Dat gemiddelde dekt de hele run, niet de individuele tooltijden.
Hoe werkt GPT-6 Astra async tool calling?
Markeer een tool met "async": true in het schema en je app kan dat resultaat uitstellen terwijl het model ofwel doorgaat met werken of wacht. Je applicatie draait de tool nog steeds en beheert de achtergrondjob.
Hoe voer je onafhankelijke checks gelijktijdig uit
Ik markeerde run_test_suite en check_ui_flow als async en voegde een app-gedefinieerde wait_for_tasks-tool zonder argumenten toe, omdat deze demo slechts één batch openstaand werk tegelijk heeft. Die argumentloze wacht houdt het voorbeeld klein.
In een production runner identificeer je jobs met taakhandles, koppel je elke handle aan de oorspronkelijke call_id en wacht je alleen wanneer de volgende stap afhankelijk is van een openstaand resultaat.
Retourneer elk voltooid resultaat op de oorspronkelijke call_id, en retourneer vervolgens de wachtstatus op de eigen call_id van de wacht-tool.
TOOLS = [
{"type": "function", "name": "run_test_suite", "async": True, ...},
{"type": "function", "name": "check_ui_flow", "async": True, ...},
{"type": "function", "name": "check_staging_health", ...},
{"type": "function", "name": "wait_for_tasks", ...},
]Voor deze run diende de app elke gemarkeerde call in bij een threadpool. Terwijl de achtergrondchecks draaiden, voerde hij de snelle synchrone healthcheck uit. Vervolgens blokkeerde hij bij wait_for_tasks totdat de openstaande checks waren voltooid.
Vermindert async tool calling de wall-clocktijd?
Over drie runs verlaagde async de gemiddelde wall-clocktijd met 19,1%, van 23,40 seconden naar 18,94 seconden. Het gemiddelde leek eenvoudig tot de individuele runs binnenkwamen; de grafiek hieronder laat zien hoe sterk ze varieerden. Drie runs zijn genoeg om te laten zien wat hier gebeurde, niet om productielatentie te voorspellen.
Looptijden varieerden in beide modi. Afbeelding door de auteur.
Waarom veroorzaakten gelijktijdige checks een race condition?
Het tegelijk draaien van de browsercheck en de bulkimporttest zorgde er soms voor dat de bulkimportassertie faalde omdat beide checks dezelfde in-memory takenlijst wijzigden. Dat brak de aanname van exclusieve toegang in de test. Het isoleren van data in de runner of in de tests zou de race vermijden.
Begrensd GPT-6 Astra computergebruik voor UI-tests
Voor computer use raden de docs van GPT-6 Astra code-executie aan, terwijl de gestructureerde computer-tool als alternatief ondersteund blijft. Met code-executie kan één call meerdere acties, lussen en conditionele logica combineren, terwijl de computer-tool één gestructureerde muis- of toetsenbordactie per keer terugstuurt voor je applicatie om te vertalen en af te spelen.
Hoe beperk je de computer-use-runner
Ik noemde de klasse BrowserSandbox, maar die naam overdrijft de bescherming. Het geeft door het model geschreven code een Playwright-page, een log()-functie en een expect_text() helper. Python kan nog steeds built-ins injecteren in exec(), en de pagina kan naar een andere origin navigeren.
sandbox_globals = {"page": self.page, "log": log, "expect_text": expect_text}
exec(code, sandbox_globals)Behandel dit als een demo-runner, niet als een beveiligingsgrens. Door het model geschreven code heeft een geïsoleerd proces of container nodig met beperkingen op filesystem, processen, netwerk en origin.
Wat gebeurde er in de UI-check?
Ik zette de lus op acht beurten, omdat een begrensde check een harde stop nodig heeft. Het model inspecteerde de pagina, vond de formulierinvoer, creëerde de titel "UI flow check, cobalt otter 73921", diende de taak in en bevestigde dat de titel verscheen, wat 13 seconden duurde. Onze GPT-5.4-computeruse-tutorial behandelt een gedetailleerd voorbeeld met een voorgangermodel van Astra.
Hoe werkt GPT-6 Astra steering midden in een beurt?
Steering midden in een beurt is alleen beschikbaar voor gpt-6-astra via een WebSocket-verbinding.
Open een verbinding en maak een response, stuur dan een response.steer-event met nieuwe instructies terwijl de response wordt gegenereerd. Een response.steer.accepted-event betekent dat de update in de wachtrij staat, niet dat die is toegepast. Voor het creëren van de automatische voortzetting voltooit de server het huidige outputitem en eventueel al draaiend hosted tool-werk.
Als nog een clienttoolresultaat of -goedkeuring nodig is, geeft response.steer.pending de ontbrekende input aan.
async with client.responses.connect() as connection:
await connection.response.create(model="gpt-6-astra", input=TASK)
async for event in connection:
if event.type == "response.created" and initial_response_id is None:
initial_response_id = event.response.id
await asyncio.sleep(1.0)
await connection.response.steer(
previous_response_id=initial_response_id,
input="Also add a rollback plan, but skip mobile.",
)De vertraging van één seconde komt overeen met de experimentcode en geeft de eerste response tijd om te starten. Zonder die vertraging zou dit een ander punt in de levenscyclus van de response testen.
Wat laat steering midden in een beurt ongewijzigd?
Steering herschrijft de oorspronkelijke response niet. Als de update die onderbreekt, eindigt die response met status: "incomplete" en incomplete_details.reason: "steered". Een opvolgende response gaat dan verder met de nieuwe instructie.
Als de eerste response klaar is vóór de update, blijft die afgerond. Steering draait geen client-side acties terug die al gestart zijn; dat gedrag valt nog steeds onder je applicatie. In de wachtrij geplaatste steering bestaat alleen op de huidige WebSocket-verbinding, dus leg de update vast vóór je een reconnect probeert.
Het vergelijkingstraject laat de eerste response afronden en stuurt dan een nieuw verzoek met de gecombineerde instructies. Over twee runs was steering gemiddeld 26,91 seconden tegenover 50,02 seconden voor dat finish-then-restart-traject. Deze vergelijking dekt geen cancel-and-restart-beleid en beoordeelt de uiteindelijke tekst niet op juistheid.
Gemiddelden over twee runs voor tijd en kosten. Afbeelding door de auteur.
Het herstartpad genereert twee volledige responses die deels dezelfde verzoeken dekken. Die opzet verklaart een deel van het tijdsverschil, dus ik zou deze twee runs niet zien als een algemene benchmark voor steering.
Hoe verander je GPT-6 Astra reasoning effort midden in een gesprek
gpt-6-astra ondersteunt reasoning effort van low tot en met max. Hogere effort kan het gebruik van reasoning-tokens verhogen, maar garandeert geen ander antwoord. Een configuration_update wijzigt de volgende en latere responses totdat een volgende update deze overschrijft, terwijl de instelling op requestniveau ongewijzigd blijft.
In deze pijplijn eindigt het rapport het gesprek, dus de update beïnvloedt alleen die laatste stap.
response = client.responses.create(
model="gpt-6-astra",
previous_response_id=previous_id,
reasoning={"effort": "low"}, # default remains low
input=[
{"type": "configuration_update", "reasoning": {"effort": "high"}},
{"role": "user", "content": "Diagnose the root cause and recommend a fix."},
],
)Ik gebruikte dezelfde failure-trace op beide effortniveaus en vergeleek de diagnose en het tokengebruik.
Eén nuance: het veld reasoning.effort van de response rapporteert nog steeds de instelling op requestniveau, niet de effort die is geselecteerd door configuration_update. Gebruik dat veld niet om te controleren of de update effect had.
Veranderde hoge reasoning effort de diagnose?
In de volledige gecombineerde run gebruikte de opgeschaalde stap 108 reasoning-tokens. Elke andere stap op low gebruikte nul. In een eerdere geïsoleerde test met een langere failure-trace gebruikte low effort nul reasoning-tokens, en high effort 318. Beide versies identificeerden de validatiebug, dus een hogere-effortwijziging veranderde het tokengebruik maar niet de diagnose.
Configuratie-updates werken alleen in standaardaanvragen met één agent. De API weigert aaneengesloten updates, en ze kunnen niet worden gecombineerd met automatische compactie of automatische truncatie.
Hoe gebruik je GPT-6 Astra Structured Outputs
De laatste stap van de pijplijn roept client.responses.parse aan om vrije tekst te vervangen door een gevalideerd Pydantic-model.
class GoNoGoReport(BaseModel):
decision: str
summary: str
checks_completed: list[str]
failures: list[str]
risks: list[str]
follow_up_actions: list[str]
confidence: float
response = client.responses.parse(
model="gpt-6-astra",
previous_response_id=previous_id,
text_format=GoNoGoReport,
input=[...],
)Pydantic controleert de hier gedeclareerde veldtypen. Het bewijst niet dat het rapport overeenkomt met het bewijs, en deze versie beperkt decision niet tot twee waarden of confidence tot een bereik.
Wat ving het go/no-go-rapport op?
Het rapport gaf decision: "no_go" terug. Het classificeerde de eerder genoemde validatiefout onder failures en het concurrencyprobleem onder risks. Voor dat laatste schreef het: "mogelijke interferentie door gelijktijdige UI-checks tegen gedeelde stagingdata." De prompt noemde dat risico niet.
Houd latentie en kosten buiten dit schema en bereken ze in code. Het model vult de rapportvelden op basis van het toolevidence.
De Streamlit-interface verbruikt dezelfde generator als de commandline-runner. Hij rendert elk toolevent zodra het binnenkomt en toont daarna het geparsede rapport in de tabs Report en JSON.
