Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Reasoning-agenter (GPT-5.6 Sol, høj til maksimal indsats)

Lektion 16 af 25 Opdateret 2. november 2026 Udvikler
På denne side
  1. Reasoning-agenter (GPT-5.6, høj til maksimal indsats)
  2. Hvornår skal du aktivere ræsonnement i en agent?
  3. Sol + høj/xhigh indsats: dyb ræsonnement
  4. Terra + medium indsats: hurtig ræsonnement
  5. Mønster: konfigurationsrouter
  6. Streaming-adfærd med aktiveret ræsonnement
  7. Optimering af omkostninger
  8. Vigtige pointer

Opdateret 2. november 2026 — modeller. o3, o3-pro og ældre GPT-5-snapshots fjernes fra API’et den 11. december 2026, og o4-mini er 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