Agenter med resonemang (GPT-5.6 Sol, hög till maximal ansträngning)
På denna sida
- Agenter med resonemang (GPT-5.6, hög till maximal ansträngning)
- När du ska aktivera resonemang i en agent
- Sol + hög/xhigh ansträngning: djupt resonemang
- Terra + medelanstrengning: snabbt resonemang
- Mönster: konfigurationsrouter
- Strömningsbeteende med aktiverat resonemang
- Optimering av kostnader
- Viktiga punkter
Uppdaterat 2 november 2026 — modeller.
o3,o3-prooch äldre ögonblicksbilder av GPT-5 tas bort från API:et den 11 december 2026, ocho4-minihar länge ersatts. För nya agenter börjar du med GPT-6-familjen: GPT-6.1 Sol för balans, GPT-6 Astra för de mest krävande uppgifterna.
Agenter med resonemang (GPT-5.6, hög till maximal ansträngning)
Med GPT-5.6-familjen (tillgänglig sedan juli 2026) hanteras resonemang inte längre av separata modeller som i föregående generation (o3-pro, o4-mini): det är nu en inställning per begäran (none, low, medium, high, xhigh, max) som gäller för varje modell. En agent som verkligen behöver tänka – utforska flera vägar innan den svarar – använder vanligtvis GPT-5.6 Sol med ansträngningsnivån high eller xhigh. Integrerad i dina agenter låser denna resonemangskapacitet upp uppgifter som kräver genuint övervägande.
När du ska aktivera resonemang i en agent
Djupt resonemang lyser i specifika situationer, och erfarenheten visar att de alla delar en gemensam nämnare: att jämföra möjliga vägar innan ett beslut fattas. Detta gäller komplex planering, där du bryter ner en uppgift i optimala steg, och matematisk analys – beräkningar, statistik, optimering – där ett enda felaktigt steg ogiltigförklarar resten. Det gäller även felsökning, som innebär att spåra ett symptom tillbaka till dess grundorsak, samt beslutsfattande, där du måste utvärdera flera alternativ och välja det bästa. Kodgranskning hör till samma kategori: att hitta en subtil bugg kräver att man mentalt simulerar exekveringar som linjär läsning inte avslöjar.
För enkla uppgifter (att svara på en fråga, formatera text) är GPT-5.6 Terra eller Luna med låg ansträngning (eller till och med none) snabbare och billigare. Att betala för resonemang för att formulera om ett stycke är som att låta en racerbil gå på tomgång i trafiken.
Sol + hög/xhigh ansträngning: djupt resonemang
GPT-5.6 Sol med hög resonemangsansträngning ersätter det som o3-pro brukade göra. Agenten tar längre tid men producerar djupare analyser. Exemplet nedan är typiskt: en strategisk fråga med tre alternativ, där det rätta svaret beror på avvägningar mellan risk, kostnad och tidshorisont. Notera att instruktionerna uttryckligen definierar de dimensioner som ska beaktas – resonemang drar alltid nytta av tydliga begränsningar.
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)
För de mest kritiska analyserna kan du öka till xhigh eller max. Det finns också en inställning ultra (aviserad i juli 2026) som som standard samordnar 4 agenter parallellt (upp till 16 vid vissa utvärderingar) för de tyngsta uppgifterna – kraftfullt, men med betydligt högre tokenförbrukning: reservera den för problem som motiverar kostnaden.
Terra + medelanstrengning: snabbt resonemang
Mellan inget resonemang och djup analys finns en gyllene medelväg som används flitigt i produktion. GPT-5.6 Terra med ansträngningen medium erbjuder en bra kompromiss mellan resonemangskapacitet och hastighet – motsvarigheten till den tidigare o4-mini. Idealiskt för agenter som behöver resonera snabbt, som denna diagnostiska agent som läser servermätvärden och måste koppla mättnad i minnet till en topp i 5xx-fel inom sekunder, medan webbplatsen upplever ett incidentläge.
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 inte välja en konfiguration för alltid. Använd en lättviktig konfiguration för routning och den lämpliga för exekvering: en första agent läser uppgiften, returnerar ett typat objekt som anger vilken modell och ansträngning som ska användas, sedan instansierar du exekveringsagenten med detta beslut. Fältet reason är inte bara dekorativt – det låter dig, när du granskar dina loggar, verifiera att routern inte systematiskt överdimensionerar resurserna.
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
Strömningsbeteende med aktiverat resonemang
När resonemang är aktiverat har strömning en egenhet: modellens interna tankeprocess strömmas inte som vanlig text. Ditt gränssnitt tar därför emot tokens för det slutgiltiga svaret, men ingenting under resonemangsfasen.
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)
Ta hänsyn till denna latens i din UX: med ansträngningen high eller högre kan de första tokens anlända efter en betydande betänketid. En tydlig väntindikator förhindrar att användare tror att appen har fryst och laddar om sidan vid värsta möjliga ögonblick.
Optimering av kostnader
Resonemang konsumerar ytterligare tokens (internt tänkande debiteras). Två hävstänger hjälper till att hålla kostnaderna nere: sänk standardanstrengningen och öka den endast vid behov, samt separera beslut från exekvering – det vill säga, resonera för att besluta men exekvera utan resonemang. Det hybrida arbetsflödet nedan tillämpar den andra principen – Terra på medium fastställer approachen, Luna genomför den med verktyg.
# 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
Viktiga punkter
- Resonemang är en inställning per begäran på varje GPT-5.6-modell (none → max), inte längre separata modeller som o3-pro/o4-mini
- GPT-5.6 Sol med ansträngningen
high/xhigh: strategisk planering, komplex analys, matematik - GPT-5.6 Terra med ansträngningen
medium: snabbt resonemang för diagnostik och routning - Inställningen
ultrasamordnar flera agenter parallellt för de tyngsta uppgifterna – betydligt högre tokenkostnad - Router-mönstret väljer dynamiskt kombinationen av modell + ansträngning och optimerar kostnader
- Resonera för att besluta, exekvera utan resonemang: bästa kvalitet-i-förhållande-till-pris