Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Agenti s usuzováním (GPT-5.6 Sol, vysoké až maximální úsilí)

Lekce 16 z 25 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Agenti s usuzováním (GPT-5.6, vysoké až maximální úsilí)
  2. Kdy v agentovi povolit usuzování
  3. Sol + vysoké/xhigh úsilí: hluboké usuzování
  4. Terra + střední úsilí: rychlé usuzování
  5. Vzor: směrovač konfigurace
  6. Chování streamování při povoleném usuzování
  7. Optimalizace nákladů
  8. Klíčové poznatky

Aktualizováno 2. listopadu 2026 — modely. Modely o3, o3-pro a starší snímky GPT-5 budou z API odstraněny 11. prosince 2026 a o4-mini je již dávno překonán. Pro nové agenty začni s rodinou GPT-6: GPT-6.1 Sol pro vyvážený výkon, GPT-6 Astra pro nejnáročnější úlohy.

Agenti s usuzováním (GPT-5.6, vysoké až maximální úsilí)

S rodinou modelů GPT-5.6 (dostupnou od července 2026) se usuzování již neřeší pomocí samostatných modelů jako v předchozí generaci (o3-pro, o4-mini): nyní jde o nastavení pro každý požadavek (none, low, medium, high, xhigh, max), které lze aplikovat na každý model. Agent, který skutečně potřebuje přemýšlet – tedy prozkoumat více cest před odpovědí – bude typicky používat GPT-5.6 Sol s úsilím high nebo xhigh. Integrace této schopnosti usuzování do tvých agentů odemyká úlohy, které vyžadují skutečnou deliberaci.

Kdy v agentovi povolit usuzování

Hluboké usuzování vyniká ve specifických situacích a zkušenosti ukazují, že všechny mají společný rys: porovnávání možných cest před rozhodnutím. To platí pro komplexní plánování, kde úkol rozdělíš na optimální kroky, i pro matematickou analýzu – výpočty, statistiku, optimalizaci – kde jedna chybná krok znehodnotí zbytek. Platí to také pro ladění chyb (debugging), které zahrnuje vysledování symptomu až ke kořenové příčině, a pro rozhodování, kde musíš vyhodnotit několik možností a vybrat tu nejlepší. Do stejné kategorie spadá i revize kódu: nalezení subtilní chyby vyžaduje mentální simulaci provádění, kterou lineární čtení neodhalí.

Pro jednoduché úkoly (odpověď na otázku, formátování textu) je GPT-5.6 Terra nebo Luna s nízkým úsilím (nebo dokonce none) rychlejší a levnější. Platit za usuzování při přeformulování odstavce je jako nechat závodní auto běžet na volnoběh v dopravní zácpě.

Sol + vysoké/xhigh úsilí: hluboké usuzování

GPT-5.6 Sol s vysokým úsilím usuzování nahrazuje to, co dříve dělal o3-pro. Agent sice potřebuje více času, ale produkuje hlubší analýzy. Níže uvedený příklad je typický: strategická otázka se třemi možnostmi, kde správná odpověď závisí na kompromisech mezi rizikem, náklady a časovým horizontem. Všimni si, že instrukce explicitně definují dimenze, které je třeba zvážit – usuzování vždy těží z jasných omezení.

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)

Pro nejkritičtější analýzy zvýš úroveň na xhigh nebo max. Existuje také nastavení ultra (oznámené v červenci 2026), které ve výchozím nastavení koordinuje 4 agenty paralelně (až 16 u určitých evaluací) pro nejtěžší úlohy – je mocné, ale spotřebuje výrazně více tokenů: rezervuj si ho pro problémy, které tyto náklady ospravedlňují.

Terra + střední úsilí: rychlé usuzování

Mezi žádným usuzováním a hlubokou analýzou leží zlatá střední cesta, která je v produkci hojně využívána. GPT-5.6 Terra s úsilím medium nabízí dobrý kompromis mezi schopností usuzovat a rychlostí – ekvivalent bývalého o4-mini. Ideální pro agenty, kteří potřebují rychle usuzovat, jako je tento diagnostický agent, který čte metriky serveru a musí během vteřin propojit nasycení paměti s nárůstem chyb 5xx, zatímco web prochází incidentem.

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

Vzor: směrovač konfigurace

Nemusíš si vybrat jednu konfiguraci navždy. Použij lehkou konfiguraci pro směrování a vhodnou pro exekuci: první agent přečte úkol, vrátí typovaný objekt ukazující, který model a jaké úsilí použít, a ty poté instantiateš exekučního agenta s tímto rozhodnutím. Pole reason není jen ozdobné – umožňuje ti při revizi logů ověřit, že směrovač systematicky nepřiřazuje příliš velké zdroje.

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

Chování streamování při povoleném usuzování

Když je usuzování povoleno, streamování má jedno specifikum: interní myšlenkový proces modelu není streamován jako prostý text. Tvé rozhraní tedy přijímá tokeny pro finální odpověď, ale během fáze usuzování nic.

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)

Započítej tuto latenci do svého UX: při úsilí high nebo vyšším mohou první tokeny dorazit až po významné době přemýšlení. Explicitní indikátor čekání zabrání tomu, aby si uživatelé mysleli, že aplikace zamrzla, a v nejméně vhodnou chvíli stránku neobnovili.

Optimalizace nákladů

Usuzování spotřebovává další tokeny (interní přemýšlení je zpoplatněno). Dvě páky pomáhají udržet náklady pod kontrolou: sniž výchozí úsilí a zvyš ho pouze v případě potřeby, poté odděl rozhodování od exekuce – tedy usuzuj, abys rozhodl, ale execute bez usuzování. Níže uvedený hybridní workflow aplikuje druhý princip – Terra na medium stanoví přístup, Luna jej provede s nástroji.

# 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

Klíčové poznatky

  • Usuzování je nastavení pro každý požadavek na každém modelu GPT-5.6 (none → max), již nejde o samostatné modely jako o3-pro/o4-mini
  • GPT-5.6 Sol s úsilím high/xhigh: strategické plánování, komplexní analýzy, matematika
  • GPT-5.6 Terra s úsilím medium: rychlé usuzování pro diagnostiku a směrování
  • Nastavení ultra koordinuje více agentů paralelně pro nejtěžší úlohy – výrazně vyšší náklady na tokeny
  • Vzor směrovače dynamicky vybírá kombinaci modelu a úsilí a optimalizuje náklady
  • Usuzuj pro rozhodnutí, execute bez usuzování: nejlepší poměr kvality k ceně