Agenti s usuzováním (GPT-5.6 Sol, vysoké až maximální úsilí)
Na této stránce
Aktualizováno 2. listopadu 2026 — modely. Modely
o3,o3-proa starší snímky GPT-5 budou z API odstraněny 11. prosince 2026 ao4-minije 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í
ultrakoordinuje 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ě