Lähe põhisisu juurde
Eesti— Vali keel
Menüü

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

Õppetund 16 / 25 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Reasoning Agents (GPT-5.6, high to max effort)
  2. Millal agentis põhjendamine lubada
  3. Sol + high/xhigh jõupingutus: sügav põhjendamine
  4. Terra + medium jõupingutus: kiire põhjendamine
  5. Muster: konfiguratsiooni ruuter
  6. Voogedastuse käitumine põhjendamise lubamisel
  7. Kulude optimeerimine
  8. Peamised punktid

Uuendatud 2. novembril 2026 — mudelid. o3, o3-pro ja vanad GPT-5 versioonid eemaldatakse API-st 11. detsembril 2026 ning o4-mini on juba ammu asendatud. Uute agentide loomisel alusta GPT-6 perekonnast: tasakaalu jaoks GPT-6.1 Sol ja kõige nõudlikumate ülesannete jaoks GPT-6 Astra.

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

GPT-5.6 perekonnaga (saadaval alates juulist 2026) ei hallata põhjendamist enam eraldi mudelite kaudu nagu eelmises põlvkonnas (o3-pro, o4-mini): see on nüüd päringupõhine säte (none, low, medium, high, xhigh, max), mida saab rakendada igale mudelile. Agent, mis tõesti vajab mõtlemist – enne vastamist mitmete teede uurimist –, kasutab tüüpiliselt GPT-5.6 Sol-i koos high või xhigh jõupingutusega. Sinu agentidesse integreerituna avab see põhjendamisvõime ülesanded, mis nõuavad tõelist kaalumist.

Millal agentis põhjendamine lubada

Sügav põhjendamine hiilgab kindlates olukordades ja kogemus näitab, et kõigil neil on üks ühine joon: võimalike teede võrdlemine enne otsuse tegemist. See kehtib keerulise planeerimise kohta, kus jagad ülesande optimaalseteks sammudeks, ja matemaatilise analüüsi kohta – arvutused, statistika, optimeerimine –, kus üks vale samm muudab ülejäänu kehtetuks. See kehtib ka silumise (debugging) kohta, mis hõlmab sümptomi jälitamist selle algpõhjuseni, ning otsuste tegemise kohta, kus pead hindama mitut varianti ja valima parima. Koodi ülevaatus kuulub samasse kategooriasse: peene vea leidmine nõuab vaimset simulatsiooni täitmistest, mida lineaarne lugemine ei paljasta.

Lihtsate ülesannete jaoks (küsimusele vastamine, teksti vormindamine) on GPT-5.6 Terra või Luna madala jõupingutusega (või isegi none) kiirem ja odavam. Põhjendamise eest maksmine lõigu ümber sõnastamiseks on nagu võidusõiduauto tühikäigul hoidmine ummikus.

Sol + high/xhigh jõupingutus: sügav põhjendamine

GPT-5.6 Sol kõrge põhjendamisjõupingutusega asendab seda, mida o3-pro varem tegi. Agent võtab rohkem aega, kuid toodab sügavamaid analüüse. Allpool olev näide on tüüpiline: strateegiline küsimus kolme variandiga, kus õige vastus sõltub kompromissidest riski, kulude ja ajahorisondi vahel. Pane tähele, et juhised määratlevad sõnaselgelt mõõtmed, mida arvestada – põhjendamine saab alati kasu selgetest piirangutest.

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)

Kõige kriitilisemate analüüside jaoks suurenda taset xhigh või max. Samuti on olemas ultra säte (teatati juulis 2026), mis koordineerib vaikimisi 4 agenti paralleelselt (teatud hindamistel kuni 16) kõige raskemate ülesannete jaoks – võimas, kuid märkimisväärselt suurema tokenite tarbimisega: reserveeri see probleemidele, mis kulud õigustavad.

Terra + medium jõupingutus: kiire põhjendamine

Põhjendamise puudumise ja sügava analüüsi vahel asub magus koht, mida tootmises laialdaselt kasutatakse. GPT-5.6 Terra medium jõupingutusega pakub head kompromissi põhjendamisvõime ja kiiruse vahel – endise o4-mini vaste. Ideaalne agentidele, mis peavad kiiresti mõtlema, nagu see diagnostikaagent, mis loeb serveri meetrikaid ja peab siduma mälu küllastumise 5xx vigade tõusuga sekundite jooksul, samal ajal kui saidil toimub intsident.

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

Muster: konfiguratsiooni ruuter

Sa ei pea igaveseks ühte konfiguratsiooni valima. Kasuta marsruutimiseks kerget konfiguratsiooni ja sobivat täitmiseks: esimene agent loeb ülesande, tagastab tüübitud objekti, mis näitab, millist mudelit ja jõupingutust kasutada, seejärel lood täitmisagendi selle otsusega. Väli reason ei ole dekoratiivne – see võimaldab sul logisid üle vaadates kontrollida, kas ruuter ei ülevarusta süstemaatiliselt ressursse.

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

Voogedastuse käitumine põhjendamise lubamisel

Kui põhjendamine on lubatud, on voogedastusel üks eripära: mudeli sisemist mõtteprotsessi ei edastata voogedastuses lihttekstina. Sinu liides saab seetõttu tokeneid lõpliku vastuse jaoks, kuid mitte midagi põhjendamise faasi ajal.

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)

Arvesta seda latentsust oma kasutajakogemuses (UX): high jõupingutuse või suurema korral võivad esimesed tokenid saabuda pärast märkimisväärset mõtlemisaega. Selge ooteindikaator hoiab ära olukorra, kus kasutajad arvavad, et rakendus on külmunud, ja värskendavad lehte kõige ebasobivamal hetkel.

Kulude optimeerimine

Põhjendamine tarbib lisatokeneid (sisemine mõtlemine on tasuline). Kaks hooba aitavad kulusid piirata: alanda vaikimisi jõupingutust ja suurenda seda vaid vajadusel; eralda seejärel otsus täitmisest – ehk põhjenda otsustamiseks, kuid täida ilma põhjendamiseta. Allpool olev hübriidtöövoog rakendab teist põhimõtet – Terra tasemel medium kehtestab lähenemise, Luna viib selle tööriistadega ellu.

# 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

Peamised punktid

  • Põhjendamine on päringupõhine säte igal GPT-5.6 mudelil (none → max), mitte enam eraldi mudelid nagu o3-pro/o4-mini
  • GPT-5.6 Sol koos high/xhigh jõupingutusega: strateegiline planeerimine, keeruline analüüs, matemaatika
  • GPT-5.6 Terra koos medium jõupingutusega: kiire põhjendamine diagnostikaks ja marsruutimiseks
  • Säde ultra koordineerib mitut agenti paralleelselt kõige raskemate ülesannete jaoks – märkimisväärselt suurem tokenite kulu
  • Ruuteri muster valib dünaamiliselt mudeli ja jõupingutuse kombinatsiooni ning optimeerib kulusid
  • Põhjenda otsustamiseks, täida ilma põhjendamiseta: parim kvaliteedi ja hinna suhe