Agenti s usudzovaním (GPT-5.6 Sol, vysoké až maximálne úsilie)
Na tejto strane
Aktualizované 2. novembra 2026 — modely. Modely
o3,o3-proa staršie snímky GPT-5 budú z API odstránené 11. decembra 2026 ao4-minije už dávno prekonaný. Pre nových agentov začni s rodinou GPT-6: GPT-6.1 Sol pre vyváženosť, GPT-6 Astra pre najnáročnejšie úlohy.
Agenti s usudzovaním (GPT-5.6, vysoké až maximálne úsilie)
S rodinou modelov GPT-5.6 (dostupnou od júla 2026) sa usudzovanie už nerieši pomocou samostatných modelov ako v predchádzajúcej generácii (o3-pro, o4-mini): teraz ide o nastavenie pre jednotlivú požiadavku (none, low, medium, high, xhigh, max), ktoré platí pre každý model. Agent, ktorý skutočne potrebuje premýšľať – teda preskúmať viacero ciest pred odpoveďou – bude typicky používať GPT-5.6 Sol s úsilím high alebo xhigh. Integrácia tejto schopnosti usudzovania do tvojich agentov odomkne úlohy vyžadujúce skutočné hlbšie uvažovanie.
Kedy povoliť usudzovanie v agentovi
Hlboké usudzovanie vyniká v špecifických situáciách a skúsenosti ukazujú, že všetky majú spoločný znak: porovnávanie možných ciest pred rozhodnutím. Týka sa to komplexného plánovania, kde rozdelíš úlohu na optimálne kroky, a matematickej analýzy – výpočty, štatistiky, optimalizácia – kde jedna chybná krok znehodnotí zvyšok. Vzťahuje sa to aj na ladenie (debugging), ktoré zahŕňa vystopovanie symptómu až k jeho príčine, a na rozhodovanie, kde musíš vyhodnotiť niekoľko možností a vybrať tú najlepšiu. Do tejto kategórie patrí aj recenzia kódu: nájdenie jemnej chyby si vyžaduje mentálnu simuláciu vykonávania, ktorú lineárne čítanie neodhalí.
Pre jednoduché úlohy (odpovedanie na otázku, formátovanie textu) je GPT-5.6 Terra alebo Luna s nízkym úsilím (alebo dokonca none) rýchlejšia a lacnejšia. Platiť za usudzovanie pri preformulovaní odseku je ako nechať pretekárske auto bežať na voľnobeh v zápche.
Sol + vysoké/xvysoké úsilie: hlboké usudzovanie
GPT-5.6 Sol s vysokým úsilím pri usudzovaní nahrádza to, čo robil o3-pro. Agent potrebuje viac času, ale produkuje hlbšie analýzy. Nižšie uvedený príklad je typický: strategická otázka s tromi možnosťami, kde správna odpoveď závisí od kompromisov medzi rizikom, nákladmi a časovým horizontom. Všimni si, že inštrukcie explicitne definujú dimenzie, ktoré treba zvážiť – usudzovanie vždy profituje z jasných obmedzení.
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)
Pre najkritickejšie analýzy zvýš úsilie na xhigh alebo max. Existuje aj nastavenie ultra (oznámené v júli 2026), ktoré štandardne koordinuje 4 agentov paralelne (až 16 pri určitých vyhodnoteniach) pre najťažšie úlohy – je mocné, ale spotrebuje výrazne viac tokenov: vyhradź ho pre problémy, ktoré tieto náklady ospravedlňujú.
Terra + stredné úsilie: rýchle usudzovanie
Medzi žiadnym usudzovaním a hlbokou analýzou existuje zlatá stredná cesta, ktorá sa vo výrobe hojne využíva. GPT-5.6 Terra s úsilím medium ponúka dobrý kompromis medzi schopnosťou usudzovania a rýchlosťou – ekvivalent bývalého o4-mini. Ideálne pre agentov, ktorí potrebujú rýchlo usudzovať, ako je tento diagnostický agent, ktorý číta metriky servera a musí počas incidentu na stránke počas niekoľkých sekúnd prepojiť saturáciu pamäte s nárastom chýb 5xx.
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."
)
Vzorec: smerovač konfigurácie
Nemusíš si navždy vybrať jednu konfiguráciu. Použi ľahkú konfiguráciu na smerovanie a vhodnú na vykonanie: prvý agent prečíta úlohu, vráti typizovaný objekt označujúci, ktorý model a úsilie použiť, a následne vytvoríš vykonávacieho agenta s týmto rozhodnutím. Pole reason nie je len ozdobné – umožňuje ti pri kontrole logov overiť, či smerovač systematicky neprideľuje príliš veľké 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
Správanie streamovania pri povolenom usudzovaní
Keď je povolené usudzovanie, streamovanie má jedno špecifikum: vnútorný myšlienkový proces modelu sa nestreamuje ako plain text. Tvoje rozhranie preto dostáva tokeny pre konečnú odpoveď, ale počas fázy usudzovania nič.
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čítaj túto latenciu do svojho UX: pri úsilí high alebo vyššom môžu prvé tokeny doraziť až po významnom čase premýšľania. Explicitný indikátor čakania zabráni tomu, aby si používatelia mysleli, že aplikácia zamrzla, a neobnovovali stránku v najnevhodnejší moment.
Optimalizácia nákladov
Usudzovanie spotrebúva dodatočné tokeny (vnútorné myslenie sa fakturuje). Dve páky pomáhajú udržať náklady pod kontrolou: zníž predvolené úsilie a zvyšuj ho len v prípade potreby, následne oddeľ rozhodovanie od vykonávania – teda usudzuj pri rozhodovaní, ale vykonávaj bez usudzovania. Nižšie uvedený hybridný workflow aplikuje druhý princíp – Terra s medium stanoví prístup a Luna ho vykoná pomocou nástrojov.
# 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
Kľúčové poznatky
- Usudzovanie je nastavenie pre jednotlivú požiadavku na každom modeli GPT-5.6 (none → max), už nie sú to samostatné modely ako o3-pro/o4-mini
- GPT-5.6 Sol s úsilím
high/xhigh: strategické plánovanie, komplexná analýza, matematika - GPT-5.6 Terra s úsilím
medium: rýchle usudzovanie pre diagnostiku a smerovanie - Nastavenie
ultrakoordinuje viacerých agentov paralelne pre najťažšie úlohy – výrazne vyššie náklady na tokeny - Vzorec smerovača dynamicky vyberá kombináciu modelu a úsilia a optimalizuje náklady
- Usudzuj pri rozhodovaní, vykonávaj bez usudzovania: najlepší pomer kvality a ceny