Reasoning-agenter (GPT-5.6 Sol, høj til maksimal indsats)
På denne side
Opdateret 2. november 2026 — modeller.
o3,o3-proog ældre GPT-5-snapshots fjernes fra API’et den 11. december 2026, ogo4-minier længe blevet overgået. Til nye agenter skal du starte med GPT-6-familien: GPT-6.1 Sol til balance og GPT-6 Astra til de mest krævende opgaver.
Reasoning-agenter (GPT-5.6, høj til maksimal indsats)
Med GPT-5.6-familien (tilgængelig siden juli 2026) håndteres ræsonnement ikke længere af separate modeller som i den tidligere generation (o3-pro, o4-mini): det er nu en indstilling pr. anmodning (none, low, medium, high, xhigh, max), der gælder for hver model. En agent, der virkelig har brug for at tænke – altså udforske flere veje, før den svarer – vil typisk bruge GPT-5.6 Sol med high- eller xhigh-indsats. Integreret i dine agenter låser denne ræsonnementsevne opgaver op, der kræver ægte overvejelse.
Hvornår skal du aktivere ræsonnement i en agent?
Dyb ræsonnement skinner i specifikke situationer, og erfaringen viser, at de alle deler et fælles træk: sammenligning af mulige veje, før der træffes en beslutning. Dette gælder kompleks planlægning, hvor du opdeler en opgave i optimale trin, og matematisk analyse – beregninger, statistik, optimering – hvor ét forkert trin invaliderer resten. Det gælder også fejlfinding, som indebærer at spore et symptom tilbage til årsagen, og beslutningstagning, hvor du skal evaluere flere muligheder og vælge den bedste. Kodegennemgang hører til i samme kategori: at finde en subtil fejl kræver mentalt at simulere eksekveringer, som lineær læsning ikke vil afsløre.
Til enkle opgaver (besvarelse af et spørgsmål, formatering af tekst) er GPT-5.6 Terra eller Luna med lav indsats (eller endda none) hurtigere og billigere. At betale for ræsonnement for at omformulere et afsnit svarer til at lade en racerbil gå tomgang i trafikken.
Sol + høj/xhigh indsats: dyb ræsonnement
GPT-5.6 Sol med høj ræsonnementsindsats erstatter det, som o3-pro plejede at gøre. Agenten bruger mere tid, men producerer dybere analyser. Eksemplet nedenfor er typisk: et strategisk spørgsmål med tre muligheder, hvor det rigtige svar afhænger af afvejninger mellem risiko, omkostninger og tidshorisont. Bemærk, at instruktionerne eksplicit definerer de dimensioner, der skal overvejes – ræsonnement drager altid fordel af klare begrænsninger.
from agents import Agent, Runner, ModelSettings
from openai.types.shared import Reasoning
strategic_advisor = Agent(
name="Strategic Advisor",
instructions="""You are a business strategy consultant.
Analyze deeply before recommending.
Always consider: risks, opportunities,
costs, and alternatives.""",
model="gpt-5.6-sol",
model_settings=ModelSettings(reasoning=Reasoning(effort="high")),
)
result = Runner.run_sync(
strategic_advisor,
"""Our SaaS startup has 500 clients, €2M MRR, and is growing 15% per month.
We are debating:
A) Raise a Series B (€20M) and accelerate in the US
B) Stay bootstrapped and consolidate in Europe
C) Seek a strategic acquirer
Which strategy do you recommend and why?"""
)
print(result.final_output)
Til de mest kritiske analyser kan du skrue op til xhigh eller max. Der findes også en ultra-indstilling (annonceret i juli 2026), der som standard koordinerer 4 agenter parallelt (op til 16 ved visse evalueringer) til de tungeste opgaver – kraftfuldt, men med betydeligt højere token-forbrug: reserver den til problemer, der berettiger omkostningerne.
Terra + medium indsats: hurtig ræsonnement
Mellem ingen ræsonnement og dyb analyse ligger et „sweet spot”, der er meget brugt i produktion. GPT-5.6 Terra med medium-indsats tilbyder et godt kompromis mellem ræsonnementsevne og hastighed – svarende til den tidligere o4-mini. Ideel til agenter, der skal ræsonnere hurtigt, som denne diagnosticeringsagent, der læser server-metrics og skal koble mætning af hukommelse til en top i 5xx-fejl inden for få sekunder, mens siden oplever en hændelse.
from agents import Agent, Runner, ModelSettings, function_tool
from openai.types.shared import Reasoning
@function_tool
def get_server_metrics(server: str) -> str:
"""Retrieves metrics for a server."""
import json
metrics = {
"cpu": 87.5,
"ram": 92.1,
"disk": 65.3,
"requests_per_second": 1250,
"response_time_p99": 450,
"errors_5xx": 23,
}
return json.dumps(metrics)
diagnostic_agent = Agent(
name="Diagnostic Agent",
instructions="""You diagnose infrastructure problems.
Analyze the metrics and identify the probable cause.
Propose immediate and long-term corrective actions.""",
model="gpt-5.6-terra",
model_settings=ModelSettings(reasoning=Reasoning(effort="medium")),
tools=[get_server_metrics],
)
result = Runner.run_sync(
diagnostic_agent,
"The site has been slow for 30 minutes. Diagnose server web-prod-01."
)
Mønster: konfigurationsrouter
Du behøver ikke vælge én konfiguration for altid. Brug en letvægtskonfiguration til routing og den passende til eksekvering: en første agent læser opgaven, returnerer et typet objekt, der angiver, hvilken model og indsats der skal bruges, hvorefter du instantierer eksekveringsagenten med denne beslutning. Feltet reason er ikke bare pynt – det giver dig mulighed for, når du gennemgår dine logs, at verificere, at routeren ikke systematisk overallokerer ressourcer.
from pydantic import BaseModel
from typing import Literal
class ConfigDecision(BaseModel):
model: Literal["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"]
effort: Literal["none", "low", "medium", "high", "xhigh"]
reason: str
router_agent = Agent(
name="Smart Router",
instructions="""Analyze the task and decide which configuration to use:
- gpt-5.6-luna, effort none/low: simple tasks (summaries, rephrasing, factual answers)
- gpt-5.6-terra, effort medium: fast reasoning (classification, diagnostics)
- gpt-5.6-sol, effort high/xhigh: complex tasks (strategic planning, deep analysis, math)""",
model="gpt-5.6-terra",
model_settings=ModelSettings(reasoning=Reasoning(effort="medium")),
output_type=ConfigDecision,
)
async def process_with_optimal_config(task: str):
# Step 1: choose the configuration
decision = await Runner.run(router_agent, task)
config = decision.final_output
print(f"Configuration: {config.model} / effort {config.effort} ({config.reason})")
# Step 2: execute with the right configuration
execution_agent = Agent(
name="Execution Agent",
instructions="Accomplish the requested task with precision.",
model=config.model,
model_settings=ModelSettings(reasoning=Reasoning(effort=config.effort)),
)
result = await Runner.run(execution_agent, task)
return result.final_output
Streaming-adfærd med aktiveret ræsonnement
Når ræsonnement er aktiveret, har streaming en ejendommelighed: modellens interne tankeproces streames ikke som almindelig tekst. Din grænseflade modtager derfor tokens til det endelige svar, men intet under ræsonnementsfasen.
agent = Agent(
name="Analyst",
instructions="Analyze the data deeply.",
model="gpt-5.6-sol",
model_settings=ModelSettings(reasoning=Reasoning(effort="high")),
)
# Streaming delivers the final answer, not the intermediate reasoning
result = Runner.run_streamed(agent, "Analyze this complex problem.")
async for event in result.stream_events():
if event.type == "raw_response_event":
if hasattr(event.data, "delta") and event.data.delta:
print(event.data.delta, end="", flush=True)
Tag højde for denne latens i din UX: med high-indsats eller højere kan de første tokens ankomme efter en betydelig tænketid. En eksplicit vent indikator forhindrer brugere i at tro, at appen er frosset, og genindlæse siden på det værste tidspunkt.
Optimering af omkostninger
Ræsonnement forbruger ekstra tokens (intern tænkning faktureres). To løftestænger hjælper med at holde omkostningerne nede: sænk standardindsatsen og skru kun op, når det er nødvendigt, og adskil derefter beslutning fra eksekvering – det vil sige, ræsonner for at beslutte, men eksekver uden ræsonnement. Det hybride workflow nedenfor anvender det andet princip – Terra på medium fastlægger tilgangen, Luna udfører den med værktøjer.
# Pattern: hybrid reasoning
# Terra + medium for decision, Luna without reasoning for execution
decision_agent = Agent(
name="Decider",
instructions="Decide on the optimal approach.",
model="gpt-5.6-terra",
model_settings=ModelSettings(reasoning=Reasoning(effort="medium")),
)
executor_agent = Agent(
name="Executor",
instructions="Execute the decided plan.",
model="gpt-5.6-luna", # Cheaper for execution
tools=[search_crm, generate_report],
)
async def hybrid_workflow(task: str):
plan = await Runner.run(decision_agent, f"How to handle: {task}")
result = await Runner.run(executor_agent, plan.final_output)
return result.final_output
Vigtige pointer
- Ræsonnement er en indstilling pr. anmodning på hver GPT-5.6-model (none → max), ikke længere separate modeller som o3-pro/o4-mini
- GPT-5.6 Sol med
high/xhigh-indsats: strategisk planlægning, kompleks analyse, matematik - GPT-5.6 Terra med
medium-indsats: hurtig ræsonnement til diagnosticering og routing ultra-indstillingen koordinerer flere agenter parallelt til de tungeste opgaver – betydeligt højere token-omkostninger- Router-mønsteret vælger dynamisk kombinationen af model + indsats og optimerer omkostningerne
- Ræsonner for at beslutte, eksekver uden ræsonnement: det bedste forhold mellem kvalitet og pris