Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Reasoning Agents (GPT-5.6 Sol, high to max effort)

Les 16 van 25 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Reasoning Agents (GPT-5.6, high tot max effort)
  2. Wanneer u redeneren inschakelt in een agent
  3. Sol + high/xhigh effort: diep redeneren
  4. Terra + medium effort: snel redeneren
  5. Patroon: configuratierouter
  6. Streaminggedrag bij ingeschakeld redeneren
  7. Kosten optimaliseren
  8. Belangrijkste punten

Bijgewerkt op 2 november 2026 — modellen. o3, o3-pro en legacy GPT-5-snapshots worden op 11 december 2026 uit de API verwijderd; o4-mini is al lang vervangen. Begin voor nieuwe agents met de GPT-6-familie: GPT-6.1 Sol voor balans, GPT-6 Astra voor de meest veeleisende taken.

Reasoning Agents (GPT-5.6, high tot max effort)

Met de GPT-5.6-familie (beschikbaar sinds juli 2026) wordt redeneren niet langer afgehandeld door aparte modellen zoals bij de vorige generatie (o3-pro, o4-mini): het is nu een instelling per verzoek (none, low, medium, high, xhigh, max) die op elk model van toepassing is. Een agent die echt moet nadenken—meerdere paden verkennen voordat hij antwoordt—gebruikt doorgaans GPT-5.6 Sol met high of xhigh effort. Geïntegreerd in uw agents ontsluit deze redeneercapaciteit taken die echte overweging vereisen.

Wanneer u redeneren inschakelt in een agent

Diep redeneren blinkt uit in specifieke situaties, en ervaring leert dat ze allemaal één gemeenschappelijk kenmerk delen: mogelijke paden vergelijken voordat u een beslissing neemt. Dit geldt voor complexe planning, waarbij u een taak opbreekt in optimale stappen, en voor wiskundige analyse—berekeningen, statistiek, optimalisatie—waarbij één verkeerde stap de rest ongeldig maakt. Het geldt ook voor debugging, waarbij u een symptoom terugvoert naar de oorzaak, en voor besluitvorming, waarbij u meerdere opties moet evalueren en de beste moet kiezen. Code-review valt in dezelfde categorie: het vinden van een subtiele bug vereist het mentaal simuleren van uitvoeringen die lineair lezen niet blootlegt.

Voor eenvoudige taken (een vraag beantwoorden, tekst opmaken) zijn GPT-5.6 Terra of Luna met lage effort (of zelfs none) sneller en goedkoper. Betalen voor redeneren om een alinea te herformuleren is als een racestationair laten draaien in het verkeer.

Sol + high/xhigh effort: diep redeneren

GPT-5.6 Sol met hoge redeneer-effort vervangt wat o3-pro vroeger deed. De agent neemt meer tijd, maar levert diepere analyses. Het onderstaande voorbeeld is typisch: een strategische vraag met drie opties, waarbij het juiste antwoord afhangt van afwegingen tussen risico, kosten en tijdshorizon. Merk op dat de instructies expliciet de dimensies definiëren om te overwegen—redeneren profiteert altijd van duidelijke beperkingen.

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)

Voor de meest kritieke analyses schakelt u over op xhigh of max. Er is ook een ultra-instelling (aangekondigd in juli 2026) die standaard 4 agents parallel coördineert (tot 16 bij bepaalde evaluaties) voor de zwaarste taken—krachtig, maar met aanzienlijk hoger tokenverbruik: reserveer dit voor problemen die de kosten rechtvaardigen.

Terra + medium effort: snel redeneren

Tussen geen redeneren en diepe analyse ligt een sweet spot die veel wordt gebruikt in productie. GPT-5.6 Terra met medium effort biedt een goed compromis tussen redeneervermogen en snelheid—het equivalent van de voormalige o4-mini. Ideaal voor agents die snel moeten redeneren, zoals deze diagnosticerende agent die servermetrics leest en binnen seconden geheugenverzadiging moet koppelen aan een piek in 5xx-fouten, terwijl de site een incident doormaakt.

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."
)

Patroon: configuratierouter

U hoeft niet voor altijd één configuratie te kiezen. Gebruik een lichtgewicht configuratie voor routering en de juiste voor uitvoering: een eerste agent leest de taak, retourneert een getypeerd object dat aangeeft welk model en welke effort te gebruiken, waarna u de uitvoeringsagent met die beslissing instantiateert. Het veld reason is niet decoratief—het stelt u in staat, bij het reviewen van uw logs, te verifiëren dat de router niet systematisch overprovisioneert.

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

Streaminggedrag bij ingeschakeld redeneren

Wanneer redeneren is ingeschakeld, heeft streaming een eigenaardigheid: het interne denkproces van het model wordt niet als platte tekst gestreamd. Uw interface ontvangt daarom tokens voor het eindantwoord, maar niets tijdens de redeneerfase.

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)

Houd rekening met deze latentie in uw UX: bij high effort of hoger kunnen de eerste tokens pas na een aanzienlijke denktijd arriveren. Een expliciete wachtindicator voorkomt dat gebruikers denken dat de app is vastgelopen en op het verkeerde moment de pagina verversen.

Kosten optimaliseren

Redeneren verbruikt extra tokens (intern denken wordt gefactureerd). Twee hefbomen helpen de kosten te beperken: verlaag de standaard effort en schaal alleen op wanneer nodig, en scheid vervolgens beslissing van uitvoering—dat wil zeggen, redeneer om te beslissen maar voer uit zonder redeneren. De onderstaande hybride workflow past het tweede principe toe—Terra op medium bepaalt de aanpak, Luna voert deze uit met tools.

# 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

Belangrijkste punten

  • Redeneren is een instelling per verzoek op elk GPT-5.6-model (none → max), geen aparte modellen meer zoals o3-pro/o4-mini
  • GPT-5.6 Sol met high/xhigh effort: strategische planning, complexe analyse, wiskunde
  • GPT-5.6 Terra met medium effort: snel redeneren voor diagnostiek en routering
  • De ultra-instelling coördineert meerdere agents parallel voor de zwaarste taken—aanzienlijk hogere tokenkosten
  • Het routerpatroon selecteert dynamisch de combinatie van model + effort en optimaliseert kosten
  • Redeneer om te beslissen, voer uit zonder redeneren: de beste kwaliteit-prijsverhouding