Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Aģenti ar spriešanu (GPT-5.6 Sol, augsts līdz maksimāls piepūles līmenis)

Nodarbība 16 no 25 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Aģenti ar spriešanu (GPT-5.6, augsts līdz maksimāls piepūles līmenis)
  2. Kad aģentā aktivizēt spriešanu
  3. Sol + augsts/xhigh piepūle: dziļa spriešana
  4. Terra + vidējs piepūles līmenis: ātra spriešana
  5. Raksts: konfigurācijas maršrutētājs
  6. Plūsmas uzvedība, kad ir aktivizēta spriešana
  7. Izmaksu optimizēšana
  8. Galvenās atziņas

Atjaunināts 2026. gada 2. novembrī — modeļi. o3, o3-pro un vecie GPT-5 momentuzņēmumi tiks noņemti no API 2026. gada 11. decembrī, un o4-mini jau sen ir aizstāts. Jauniem aģentiem sāc ar GPT-6 saimi: GPT-6.1 Sol līdzsvaram, GPT-6 Astra visprasīgākajiem uzdevumiem.

Aģenti ar spriešanu (GPT-5.6, augsts līdz maksimāls piepūles līmenis)

Ar GPT-5.6 saimi (pieejama kopš 2026. gada jūlija) spriešanu vairs neveic atsevišķi modeļi kā iepriekšējā paaudzē (o3-pro, o4-mini): tā tagad ir katra pieprasījuma iestatījums (none, low, medium, high, xhigh, max), ko var piemērot katram modelim. Aģents, kam patiešām jādomā — pirms atbildes sniegšanas izpētot vairākus ceļus — parasti izmantos GPT-5.6 Sol ar high vai xhigh piepūli. Integrējot šo spriešanas spēju savos aģentos, tu atver durvis uzdevumiem, kas prasa patiesu pārdomu.

Kad aģentā aktivizēt spriešanu

Dziļa spriešana izceļas konkrētās situācijās, un pieredze rāda, ka tām visām ir kopīga iezīme: iespējamo ceļu salīdzināšana pirms lēmuma pieņemšanas. Tas attiecas uz sarežģītu plānošanu, kur uzdevumu sadala optimālos soļos, un matemātisku analīzi — aprēķinus, statistiku, optimizāciju — kur viena kļūda padara visu pārējo nederīgu. Tas attiecas arī uz atkļūdošanu, kas ietver simptoma izsekošanu līdz tā saknes cēlonim, un lēmumu pieņemšanu, kur jāizvērtē vairākas opcijas un jāizvēlas labākā. Koda apskats ietilpst tajā pašā kategorijā: smalkas kļūdas atrašana prasa garīgi simulēt izpildi, ko lineāra lasīšana neatklās.

Vienkāršiem uzdevumiem (atbildes sniegšana uz jautājumu, teksta formatēšana) GPT-5.6 Terra vai Luna ar zemu piepūli (vai pat none) ir ātrāki un lētāki. Maksāt par spriešanu, lai pārrakstītu rindkopu, ir kā ļaut sacīkšu automašīnai dīdēt sastrēgumā.

Sol + augsts/xhigh piepūle: dziļa spriešana

GPT-5.6 Sol ar augstu spriešanas piepūli aizstāj to, ko darīja o3-pro. Aģents pavada vairāk laika, bet rada dziļākas analīzes. Tālāk redzamais piemērs ir tipisks: stratēģisks jautājums ar trim opcijām, kur pareizā atbilde ir atkarīga no kompromisiem starp risku, izmaksām un laika horizontu. Ņem vērā, ka instrukcijas skaidri definē izvērtējamos aspektus — spriešana vienmēr gūst labumu no skaidriem ierobežojumiem.

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)

Viskritiskākajām analīzēm palielini līdz xhigh vai max. Pastāv arī ultra iestatījums (izziņots 2026. gada jūlijā), kas pēc noklusējuma koordinē 4 aģentus paralēli (līdz 16 noteiktos novērtējumos) vissmagākajiem uzdevumiem — jaudīgs, bet ar ievērojami lielāku tokena patēriņu: rezervē to problēmām, kas attaisno izmaksas.

Terra + vidējs piepūles līmenis: ātra spriešana

Starp spriešanas neesamību un dziļu analīzi ir zelta vidusceļš, ko plaši izmanto ražošanā. GPT-5.6 Terra ar medium piepūli piedāvā labu kompromisu starp spriešanas spēju un ātrumu — tas ir ekvivalents bijušajam o4-mini. Ideāli aģentiem, kuriem jāspriež ātri, piemēram, šim diagnostikas aģentam, kas nolasa servera metrikas un sekundēs saista atmiņas piesātinājumu ar 5xx kļūdu pieaugumu, kamēr vietne piedzīvo incidentu.

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

Raksts: konfigurācijas maršrutētājs

Tev nav jāizvēlas viena konfigurācija uz visiem laikiem. Izmanto vieglu konfigurāciju maršrutēšanai un atbilstošo — izpildei: pirmais aģents nolasa uzdevumu, atgriež tipizētu objektu, norādot, kurš modelis un piepūle jāizmanto, tad tu instantē izpildes aģentu ar šo lēmumu. Lauks reason nav tikai dekorācija — tas ļauj tev, pārskatot žurnālus, pārliecināties, ka maršrutētājs sistemātiski nepiešķir pārlieku daudz resursu.

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

Plūsmas uzvedība, kad ir aktivizēta spriešana

Kad spriešana ir aktivizēta, plūsmai ir savdabīga iezīme: modeļa iekšējais domāšanas process netiek plūsmots kā parasts teksts. Tava saskarne tāpēc saņem tokenus galīgajai atbildei, bet neko spriešanas fāzes laikā.

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)

Ņem vērā šo latentumu savā lietotāja pieredzē: ar high piepūli vai augstāku pirmie tokeni var ierasties pēc ievērojama domāšanas laika. Skaidrs gaidīšanas indikators novērš situāciju, kad lietotāji domā, ka lietotne ir iesaldējusies, un sliktākajā brīdī atsvaidzina lapu.

Izmaksu optimizēšana

Spriešana patērē papildu tokenus (iekšējā domāšana tiek tarifēta). Divi sviras palīdz ierobežot izmaksas: pazemini noklusējuma piepūli un palielini to tikai tad, kad nepieciešams, tad atdali lēmumu no izpildes — proti, spried, lai izlemtu, bet izpildi bez spriešanas. Tālāk redzamais hibrīda darbplūsmas piemērs piemēro otro principu — Terra ar medium nosaka pieeju, Luna to izpilda ar rīkiem.

# 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

Galvenās atziņas

  • Spriešana ir katra pieprasījuma iestatījums katram GPT-5.6 modelim (none → max), vairs nav atsevišķi modeļi kā o3-pro/o4-mini
  • GPT-5.6 Sol ar high/xhigh piepūli: stratēģiska plānošana, sarežģīta analīze, matemātika
  • GPT-5.6 Terra ar medium piepūli: ātra spriešana diagnostikai un maršrutēšanai
  • Iestatījums ultra koordinē vairākus aģentus paralēli vissmagākajiem uzdevumiem — ievērojami augstākas tokena izmaksas
  • Maršrutētāja raksts dinamiski izvēlas modeļa un piepūles kombināciju un optimizē izmaksas
  • Spried, lai izlemtu, izpildi bez spriešanas: labākais kvalitātes un cenas attiecība