Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Agenti s usudzovaním (GPT-5.6 Sol, vysoké až maximálne úsilie)

Lekcia 16 z 25 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Agenti s usudzovaním (GPT-5.6, vysoké až maximálne úsilie)
  2. Kedy povoliť usudzovanie v agentovi
  3. Sol + vysoké/xvysoké úsilie: hlboké usudzovanie
  4. Terra + stredné úsilie: rýchle usudzovanie
  5. Vzorec: smerovač konfigurácie
  6. Správanie streamovania pri povolenom usudzovaní
  7. Optimalizácia nákladov
  8. Kľúčové poznatky

Aktualizované 2. novembra 2026 — modely. Modely o3, o3-pro a staršie snímky GPT-5 budú z API odstránené 11. decembra 2026 a o4-mini je 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 ultra koordinuje 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