
De GPT-6.2 API is de huidige keuze van OpenAI voor agentwerk: de API-changelog raadt gpt-6.2-sol aan "voor dagelijkse coding- en agentworkflows" en gpt-6.2-astra voor "veeleisende reasoning- en codingtaken." Deze gids koppelt een van beide modellen via het Responses-endpoint van PoYo aan een coding agent, met function tools, een begrensde lus, gestreamde voortgang, een grote repositorycontext en caching die lange sessies betaalbaar houdt. Begin op de GPT-6.2 Sol-modelpagina en houd GPT-6.2 Astra achter de hand voor escalatie.
Heb je nog geen eerste verzoek verstuurd? Begin dan met de GPT-6.2 API-gids.
Wat de API een coding agent biedt
| Onderdeel | GPT-6.2 op PoYo |
|---|---|
| Model-ID's | gpt-6.2-sol (standaard), gpt-6.2-astra (escalatie) |
| Agent-endpoint | POST https://api.poyo.ai/v1/responses (OpenAI SDK, base_url="https://api.poyo.ai/v1") |
| Tool calling | Alleen Responses; OpenAI: "tool calling vereist Responses" |
| Context / max. input / max. output | 1,050,000 / 922,000 / 128,000 tokens |
| Streaming | "stream": true; response.completed bevat de definitieve output en usage |
| Reasoning | reasoning.effort; none geweigerd, begin met medium |
| Prijs per 1M (Sol) | $1.60 input / $8 output / $0.08 cache read / $2 cache write |
| Prijs per 1M (Astra) | $6.40 input / $32 output / $0.32 cache read / $8 cache write |
| Fouten | 400 ongeldige velden, 401 foute sleutel, 402 onvoldoende credits, 404 onbekend model; probeer 429 / 5xx opnieuw met backoff |
De Responses-referentie van PoYo documenteert tools, tool_choice, parallel_tool_calls, reasoning, include, store, previous_response_id en truncation, en zegt dat toolondersteuning per model verschilt. De modelpagina's van OpenAI vermelden function calling en een set gehoste tools voor GPT-6.2. De documentatie van PoYo toont alleen web_search_preview als voorbeeld van een gehoste tool, dus deze agent gebruikt je eigen function tools, die je van begin tot eind zelf in de hand hebt.
Function tools definiëren
Houd de set tools klein en veilig. Het model kan alleen acties aanvragen die jij implementeert:
import json, os, subprocess
from pathlib import Path
from openai import OpenAI
client = OpenAI(base_url="https://api.poyo.ai/v1", api_key=os.environ["POYO_API_KEY"])
REPO = Path("/srv/checkout").resolve()
TOOLS = [
{"type": "function", "name": "read_file",
"description": "Read a UTF-8 text file from the repository.",
"parameters": {"type": "object", "properties": {"path": {"type": "string"}},
"required": ["path"], "additionalProperties": False}},
{"type": "function", "name": "write_file",
"description": "Replace a file in the repository with new content.",
"parameters": {"type": "object",
"properties": {"path": {"type": "string"}, "content": {"type": "string"}},
"required": ["path", "content"], "additionalProperties": False}},
{"type": "function", "name": "run_tests",
"description": "Run the test suite and return the last 200 lines of output.",
"parameters": {"type": "object", "properties": {}, "additionalProperties": False}},
]
def safe_path(p: str) -> Path:
full = (REPO / p).resolve()
if not full.is_relative_to(REPO):
raise ValueError("path escapes the repository")
return full
def call_tool(name: str, args: dict) -> str:
try:
if name == "read_file":
return safe_path(args["path"]).read_text(encoding="utf-8")[:200_000]
if name == "write_file":
safe_path(args["path"]).write_text(args["content"], encoding="utf-8")
return "ok"
if name == "run_tests":
r = subprocess.run(["pytest", "-q"], cwd=REPO, capture_output=True, text=True, timeout=600)
return "\n".join((r.stdout + r.stderr).splitlines()[-200:])
return f"unknown tool {name}"
except Exception as e: # return errors to the model instead of crashing the loop
return f"error: {e}"
Laat de agent draaien op een wegwerp-checkout of een container, nooit op je eigen werkmap.
Een begrensde agentlus
De lus stuurt het gesprek, voert elk function_call-item uit, voegt een function_call_output met dezelfde call_id toe en herhaalt dat tot het model antwoordt zonder tool call. Hij stopt bij een beurtlimiet en een budget in dollars.
PRICES = {"gpt-6.2-sol": (1.60, 8.00, 0.08, 2.00), "gpt-6.2-astra": (6.40, 32.00, 0.32, 8.00)}
def cost(model, u) -> float:
p_in, p_out, p_read, p_write = PRICES[model]
d = getattr(u, "input_tokens_details", None)
read = getattr(d, "cached_tokens", 0) or 0
write = getattr(d, "cache_write_tokens", 0) or 0
return ((u.input_tokens - read - write) * p_in + read * p_read
+ write * p_write + u.output_tokens * p_out) / 1e6
DEVELOPER = ("You are a coding agent working in a Python repository. "
"Read files before editing. Run the tests after every change. "
"When the tests pass, reply with a short summary and no tool call.")
def run_agent(task: str, model="gpt-6.2-sol", max_turns=30, budget_usd=3.00):
items = [{"role": "developer", "content": DEVELOPER},
{"role": "user", "content": task}]
spent = 0.0
for turn in range(max_turns):
resp = client.responses.create(
model=model, input=items, tools=TOOLS,
reasoning={"effort": "medium"}, max_output_tokens=16000,
store=False, include=["reasoning.encrypted_content"],
)
spent += cost(model, resp.usage)
items += [o.model_dump(exclude_none=True) for o in resp.output]
calls = [o for o in resp.output if o.type == "function_call"]
if not calls:
return resp.output_text, spent, turn + 1
for c in calls:
items.append({"type": "function_call_output", "call_id": c.call_id,
"output": call_tool(c.name, json.loads(c.arguments))})
if spent >= budget_usd:
break
raise RuntimeError(f"stopped after {turn + 1} turns, ${spent:.3f} spent")
Waarom de lus zo is opgebouwd:
- Output-items gaan op volgorde terug, inclusief reasoning-items. Voor verzoeken waarbij
storefalse is, zoals onder Zero Data Retention, zegt de GPT-6.2-gids van OpenAI: "geef de eerdere output-items op volgorde terug, inclusief versleutelde reasoning-items."include=["reasoning.encrypted_content"]vraagt ze op. Het alternatief isprevious_response_idmet opgeslagen responses, wat PoYo ook documenteert. - De geschiedenis wordt alleen aangevuld. OpenAI waarschuwt dat wijzigingen midden in een gesprek ertoe kunnen leiden dat de Responses API reasoning-items laat vallen, wat "de kwaliteit van antwoorden kan verlagen en het tokengebruik kan verhogen," en een wijziging breekt ook de gecachete prefix.
- Het budget wordt elke beurt gecontroleerd, met dezelfde prijstabel als de factuur.
We hebben precies deze lus voor dit artikel niet van begin tot eind op PoYo gedraaid. Draai hem eerst op een kleine taak en controleer of de tool calls en usage eruitzien zoals verwacht.
Voortgang naar de gebruiker streamen
Lange agentbeurten voelen traag zonder feedback. Stream elke beurt, toon de tekstdelta's en haal de definitieve output uit response.completed. Dit zijn de eventtypes die PoYo documenteert:
def stream_turn(model, items):
final = None
with client.responses.create(model=model, input=items, tools=TOOLS,
reasoning={"effort": "medium"}, max_output_tokens=16000,
store=False, include=["reasoning.encrypted_content"],
stream=True) as stream:
for event in stream:
if event.type == "response.output_text.delta":
print(event.delta, end="", flush=True)
elif event.type == "response.completed":
final = event.response
elif event.type == "response.failed":
raise RuntimeError(event.response)
return final # same object as the non-streaming call: .output, .usage
Zet stream_turn in de lus in plaats van responses.create. Tool calls worden precies zoals eerder uit final.output gelezen.
Lange context: 922K in, 128K uit
GPT-6.2 accepteert tot 922,000 input-tokens per verzoek. Een agent kan een groot deel van een repository vooraf laden in plaats van bestanden één voor één te lezen. Drie grenzen bepalen die keuze:
- Elke beurt stuurt de geschiedenis opnieuw. Een snapshot van 200K tokens over 20 beurten is minstens 4M input-tokens. Tegen de $1.60 van Sol is dat $6.40 zonder cache. Met één cache write van de snapshot ($0.40) en 19 cache reads tegen $0.08 ($0.30) is het ongeveer $0.70.
- De long-context-tier van OpenAI begint boven 272K input-tokens. De prijspagina van OpenAI verdubbelt boven die grens de input- en cachetarieven en rekent 1.5× output voor het hele verzoek. Houd agentverzoeken onder 272K tenzij de taak meer nodig heeft, en controleer op de modelpagina welk PoYo-tarief geldt.
- Reasoning deelt het outputbudget.
max_output_tokensbegrenst zichtbare tekst plus reasoning. Vraag om één bestand perwrite_file-aanroep in plaats van het hele repository te herschrijven.
Kort tooloutput in voordat je hem toevoegt: geef de laatste 200 regels van een testrun terug, niet 20,000. Zo blijft de groei per beurt, en daarmee de rekening, lineair en klein.
Prompt caching voor agentsessies
De caching-gids van OpenAI legt voor GPT-6.2 deze regels vast:
| Regel | Waarde |
|---|---|
| Cache-read-prijs | 0.05× input ($0.08 per 1M op Sol, $0.32 op Astra, op PoYo) |
| Cache-write-prijs | 1.25× input voor de standaardbewaartijd van 30 minuten ($2 / $8 per 1M op PoYo) |
| Minimale cachebare prefix | 1,024 zichtbare input-tokens |
| Impliciet breakpoint | Einde van het laatste geschikte bericht |
| Usage-velden | usage.input_tokens_details.cached_tokens (reads), cache_write_tokens (writes) |
Zo maak je cache-hits waarschijnlijk:
- Zet stabiele content vooraan. Eerst het developer-bericht, dan de tooldefinities, dan de repositorysnapshot, dan de taak.
- Gebruik een
developer-bericht, geen top-levelinstructions. GPT-6.2 voegtinstructionstoe nainput, dus die zouden buiten de prefix vallen. - Bewerk nooit eerdere items. Voeg tooloutputs toe; herschrijf de geschiedenis niet.
- Houd instellingen stabiel binnen een sessie. Volgens de gids van OpenAI moet de prefix ongewijzigd blijven wanneer je instellingen tussen responses wijzigt.
OpenAI documenteert ook prompt_cache_options (expliciete breakpoints en een bewaartijd van 12 uur). Het Responses-schema van PoYo vermeldt dat veld niet en staat geen extra velden toe (additionalProperties: false), dus laat het weg en vertrouw op impliciete caching. Een sessie van 25 beurten op Sol daalt in het beste geval van $3.82 zonder cache naar ongeveer $0.74; de berekening staat in GPT-6.2 API-prijzen.
Wanneer je de run aan Astra overdraagt
Start elke run op gpt-6.2-sol. Als hij stopt bij de beurtlimiet met falende tests, start de taak dan opnieuw op gpt-6.2-astra met een nieuwe itemlijst. Wissel niet van model binnen hetzelfde gesprek, want volgens OpenAI kunnen modelwissels reasoning-items laten vallen. De routingberekening en een router staan in GPT-6.2 Sol API vs. GPT-6.2 Astra API. Voor de aanpak van een andere aanbieder voor dezelfde lus, vergelijk met Gemini 4 Carbon API voor coding agents.
Veelgestelde vragen
Ondersteunt de GPT-6.2 API function calling?
Ja, op /v1/responses. Definieer tools met type: "function", lees function_call-items uit output en stuur de resultaten terug als function_call_output-items met dezelfde call_id.
Kan ik tools van de GPT-6.2 API gebruiken met Chat Completions?
Nee. Volgens OpenAI ondersteunt GPT-6.2 Chat Completions, maar tool calling vereist Responses.
Hoe stream ik een agentbeurt van de GPT-6.2 API?
Stel stream: true in op Responses, print de response.output_text.delta-events en lees tool calls en usage uit het event response.completed.
Hoe verlaag ik de kosten van de GPT-6.2 API in lange agentsessies?
Houd een stabiele prefix (developer-bericht, tools, snapshot) vooraan, voeg toe in plaats van te bewerken, kort tooloutput in en blijf waar mogelijk onder 272K input-tokens per verzoek.
Welk GPT-6.2-model moet mijn coding agent draaien?
Begin met gpt-6.2-sol, dat per token een kwart van Astra kost, en start een mislukte run opnieuw op gpt-6.2-astra.