
GPT-6.2 API er OpenAIs nåværende anbefaling for agentarbeid: API-changelogen anbefaler gpt-6.2-sol "til daglig koding og agentarbeidsflyter" og gpt-6.2-astra til "krevende resonnerings- og kodeoppgaver." Denne guiden kobler hvilken som helst av modellene inn i en kodeagent via PoYos Responses-endepunkt, med funksjonsverktøy, en begrenset løkke, strømmet fremdrift, stor kodelagerkontekst og caching som holder lange økter rimelige. Start på modellsiden for GPT-6.2 Sol, og hold GPT-6.2 Astra i reserve for eskalering.
Har du ikke sendt en første forespørsel ennå, start med GPT-6.2 API-guiden.
Hva API-et gir en kodeagent
| Punkt | GPT-6.2 på PoYo |
|---|---|
| Modell-ID-er | gpt-6.2-sol (standard), gpt-6.2-astra (eskalering) |
| Agentendepunkt | POST https://api.poyo.ai/v1/responses (OpenAI SDK, base_url="https://api.poyo.ai/v1") |
| Verktøykall | Bare Responses; OpenAI: "verktøykall krever Responses" |
| Kontekst / maks. input / maks. output | 1,050,000 / 922,000 / 128,000 tokens |
| Strømming | "stream": true; response.completed inneholder endelig output og usage |
| Resonnering | reasoning.effort; none avvises, start på medium |
| Pris per 1M (Sol) | $1.60 input / $8 output / $0.08 cache-lesing / $2 cache-skriving |
| Pris per 1M (Astra) | $6.40 input / $32 output / $0.32 cache-lesing / $8 cache-skriving |
| Feil | 400 ugyldige felt, 401 feil nøkkel, 402 ikke nok kreditter, 404 ukjent modell; prøv 429 / 5xx på nytt med backoff |
PoYos Responses-referanse dokumenterer tools, tool_choice, parallel_tool_calls, reasoning, include, store, previous_response_id og truncation, og sier at verktøystøtte avhenger av modellen. OpenAIs modellsider lister funksjonskall og et sett med hostede verktøy for GPT-6.2. PoYos dokumentasjon viser bare web_search_preview som eksempel på et hostet verktøy, så denne agenten bruker dine egne funksjonsverktøy, som du kontrollerer fra ende til ende.
Definer funksjonsverktøy
Hold verktøysettet lite og trygt. Modellen kan bare be om handlinger du har implementert:
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}"
Kjør agenten mot en checkout eller container du kan kaste, aldri mot arbeidstreet ditt.
En begrenset agentløkke
Løkken sender samtalen, utfører hvert function_call-element, legger til en function_call_output med samme call_id og gjentar til modellen svarer uten verktøykall. Den stopper ved en rundegrense og et budsjett i dollar.
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")
Hvorfor løkken er bygget slik:
- Output-elementene sendes tilbake i rekkefølge, inkludert resonneringselementer. For forespørsler der
storeer false, som under Zero Data Retention, sier OpenAIs GPT-6.2-guide at du skal "sende de tidligere output-elementene tilbake i rekkefølge, inkludert krypterte resonneringselementer."include=["reasoning.encrypted_content"]ber om dem. Alternativet erprevious_response_idmed lagrede svar, som PoYo også dokumenterer. - Historikken bare utvides. OpenAI advarer om at endringer midt i en samtale kan få Responses API til å droppe resonneringselementer, noe som "kan redusere svarkvaliteten og øke tokenbruken," og en endring bryter også det cachede prefikset.
- Budsjettet sjekkes hver runde, med den samme pristabellen som fakturaen.
Vi har ikke kjørt akkurat denne løkken fra ende til ende på PoYo for dette innlegget. Kjør den på en liten oppgave først, og bekreft at verktøykallene og usage ser ut som forventet.
Strøm fremdriften til brukeren
Lange agentrunder føles trege uten tilbakemelding. Strøm hver runde, vis tekst-deltaene og hent den endelige outputen fra response.completed. Dette er hendelsestypene PoYo dokumenterer:
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
Bytt inn stream_turn i løkken i stedet for responses.create. Verktøykallene leses fra final.output akkurat som før.
Lang kontekst: 922K inn, 128K ut
GPT-6.2 tar imot opptil 922,000 input-tokens per forespørsel. En agent kan laste inn en stor del av et kodelager på forhånd i stedet for å lese filer én etter én. Tre begrensninger påvirker det valget:
- Hver runde sender historikken på nytt. Et øyeblikksbilde på 200K tokens over 20 runder er minst 4M input-tokens. Med Sols $1.60 blir det $6.40 uten cache. Med én cache-skriving av øyeblikksbildet ($0.40) og 19 cache-lesinger til $0.08 ($0.30) blir det omtrent $0.70.
- OpenAIs langkontekstnivå starter over 272K input-tokens. OpenAIs prisside dobler input- og cache-satsene og tar 1.5× for output for hele forespørselen over den grensen. Hold agentforespørsler under 272K med mindre oppgaven krever mer, og sjekk modellsiden for hvilken PoYo-sats som gjelder.
- Resonnering deler output-budsjettet.
max_output_tokensbegrenser synlig tekst pluss resonnering. Be om én fil perwrite_file-kall i stedet for å skrive om hele kodelageret.
Kort ned verktøyoutput før du legger det til: returner de siste 200 linjene av en testkjøring, ikke 20,000. Da holder du veksten per runde, og fakturaen, lineær og liten.
Prompt-caching for agentøkter
OpenAIs caching-guide setter disse reglene for GPT-6.2:
| Regel | Verdi |
|---|---|
| Pris for cache-lesing | 0.05× input ($0.08 per 1M på Sol, $0.32 på Astra, på PoYo) |
| Pris for cache-skriving | 1.25× input for standard oppbevaring på 30 minutter ($2 / $8 per 1M på PoYo) |
| Minste prefiks som kan caches | 1,024 synlige input-tokens |
| Implisitt bruddpunkt | Slutten av den siste kvalifiserte meldingen |
| Forbruksfelt | usage.input_tokens_details.cached_tokens (lesinger), cache_write_tokens (skrivinger) |
Slik gjør du cache-treff sannsynlige:
- Legg stabilt innhold først. Developer-melding, så verktøydefinisjoner, så øyeblikksbildet av kodelageret, så oppgaven.
- Bruk en
developer-melding, ikke toppnivå-instructions. GPT-6.2 leggerinstructionsetterinput, så de ville havnet utenfor prefikset. - Rediger aldri tidligere elementer. Legg til verktøyoutput; ikke skriv om historikken.
- Hold innstillingene stabile innenfor en økt. OpenAIs guide sier at prefikset skal holdes uendret når du endrer innstillinger mellom svar.
OpenAI dokumenterer også prompt_cache_options (eksplisitte bruddpunkter og 12 timers oppbevaring). PoYos Responses-skjema lister ikke det feltet og er erklært lukket for ekstra felt (additionalProperties: false), så utelat det og stol på implisitt caching. En agentøkt på 25 runder på Sol går i beste fall fra $3.82 uten cache til omtrent $0.74; utregningen står i GPT-6.2 API-priser.
Når du bør gi kjøringen til Astra
Start hver kjøring på gpt-6.2-sol. Hvis den stopper ved rundegrensen med feilende tester, start oppgaven på nytt på gpt-6.2-astra med en ny elementliste. Ikke bytt modell i den samme samtalen, fordi OpenAI sier at modellbytter kan droppe resonneringselementer. Rutingregnestykket og en ruter finner du i GPT-6.2 Sol API vs GPT-6.2 Astra API. For en annen leverandørs variant av den samme løkken, sammenlign med Gemini 4 Carbon API for kodeagenter.
Ofte stilte spørsmål
Støtter GPT-6.2 API funksjonskall?
Ja, på /v1/responses. Definer verktøy med type: "function", les function_call-elementer fra output og send resultatene tilbake som function_call_output-elementer med samme call_id.
Kan jeg bruke GPT-6.2 API-verktøy med Chat Completions?
Nei. OpenAI sier at GPT-6.2 støtter Chat Completions, men at verktøykall krever Responses.
Hvordan strømmer jeg en agentrunde i GPT-6.2 API?
Sett stream: true på Responses, skriv ut response.output_text.delta-hendelser, og les verktøykall og usage fra hendelsen response.completed.
Hvordan senker jeg kostnadene for GPT-6.2 API i lange agentøkter?
Hold et stabilt prefiks (developer-melding, verktøy, øyeblikksbilde) i starten, legg til i stedet for å redigere, kort ned verktøyoutput, og hold deg under 272K input-tokens per forespørsel når du kan.
Hvilken GPT-6.2-modell bør kjøre kodeagenten min?
Start med gpt-6.2-sol, som koster en fjerdedel av Astra per token, og start en mislykket kjøring på nytt på gpt-6.2-astra.