Przejdź do głównej treści
Polski— Wybierz język
Menu

Agenci rozumujący (GPT-5.6 Sol, wysoki do maksymalnego wysiłku)

Lekcja 16 z 25 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Agenci rozumujący (GPT-5.6, wysoki do maksymalnego wysiłku)
  2. Kiedy włączyć rozumowanie w agencie
  3. Sol + wysoki/bardzo wysoki wysiłek: głębokie rozumowanie
  4. Terra + średni wysiłek: szybkie rozumowanie
  5. Wzorzec: router konfiguracji
  6. Zachowanie strumieniowania przy włączonym rozumowaniu
  7. Optymalizacja kosztów
  8. Kluczowe wnioski

Zaktualizowano 2 listopada 2026 — modele. Modele o3, o3-pro oraz starsze migawki GPT-5 zostaną usunięte z API 11 grudnia 2026 r., a o4-mini jest już od dawna przestarzały. W przypadku nowych agentów zacznij od rodziny GPT-6: GPT-6.1 Sol dla zachowania równowagi, GPT-6 Astra dla najbardziej wymagających zadań.

Agenci rozumujący (GPT-5.6, wysoki do maksymalnego wysiłku)

W rodzinie modeli GPT-5.6 (dostępnej od lipca 2026 r.) rozumowanie nie jest już obsługiwane przez oddzielne modele, jak w poprzedniej generacji (o3-pro, o4-mini): stało się ono teraz ustawieniem dla każdego żądania (none, low, medium, high, xhigh, max), mającym zastosowanie do każdego modelu. Agent, który naprawdę musi „pomyśleć“ – badając wiele ścieżek przed udzieleniem odpowiedzi – będzie zazwyczaj korzystał z modelu GPT-5.6 Sol z ustawionym wysiłkiem na poziomie high lub xhigh. Zintegrowanie tej zdolności rozumowania z Twoimi agentami odblokowuje zadania wymagające prawdziwej deliberacji.

Kiedy włączyć rozumowanie w agencie

Głębokie rozumowanie sprawdza się w specyficznych sytuacjach, a doświadczenie pokazuje, że wszystkie one mają wspólną cechę: porównywanie możliwych ścieżek przed podjęciem decyzji. Dotyczy to złożonego planowania, gdzie dzielisz zadanie na optymalne kroki, oraz analizy matematycznej – obliczeń, statystyki, optymalizacji – gdzie jeden błędny krok unieważnia resztę. Ma to również zastosowanie do debugowania, które polega na prześledzeniu symptomu aż do jego przyczyny źródłowej, oraz do podejmowania decyzji, gdzie musisz ocenić kilka opcji i wybrać najlepszą. Przegląd kodu (code review) również wpada do tej kategorii: znalezienie subtelnych błędów wymaga mentalnej symulacji wykonań, których liniowe czytanie nie ujawni.

W przypadku prostych zadań (odpowiadanie na pytania, formatowanie tekstu) modele GPT-5.6 Terra lub Luna z niskim wysiłkiem (lub nawet none) są szybsze i tańsze. Płacenie za rozumowanie w celu sparafrazowania akapitu jest jak trzymanie silnika wyścigówki na biegu jałowym w korku ulicznym.

Sol + wysoki/bardzo wysoki wysiłek: głębokie rozumowanie

Model GPT-5.6 Sol z wysokim wysiłkiem rozumowania zastępuje to, co kiedyś robił o3-pro. Agent potrzebuje więcej czasu, ale generuje głębsze analizy. Poniższy przykład jest typowy: pytanie strategiczne z trzema opcjami, gdzie prawidłowa odpowiedź zależy od kompromisów między ryzykiem, kosztem a horyzontem czasowym. Zauważ, że instrukcje wyraźnie definiują wymiary, które należy wziąć pod uwagę – rozumowanie zawsze korzysta na jasnych ograniczeniach.

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)

W przypadku najbardziej krytycznych analiz zwiększ wysiłek do xhigh lub max. Istnieje również ustawienie ultra (ogłoszone w lipcu 2026 r.), które domyślnie koordynuje 4 agentów działających równolegle (do 16 w przypadku niektórych ewaluacji) dla najcięższych zadań – jest potężne, ale wiąże się ze znacznie wyższym zużyciem tokenów: zarezerwuj je dla problemów, które uzasadniają ten koszt.

Terra + średni wysiłek: szybkie rozumowanie

Pomiędzy brakiem rozumowania a głęboką analizą istnieje „złoty środek“ szeroko stosowany w środowisku produkcyjnym. Model GPT-5.6 Terra z wysiłkiem medium oferuje dobry kompromis między możliwościami rozumowania a szybkością – jest odpowiednikiem dawnego o4-mini. Idealny dla agentów, które muszą szybko rozumować, takich jak ten agent diagnostyczny, który odczytuje metryki serwera i musi powiązać nasycenie pamięci ze skokiem błędów 5xx w ciągu kilku sekund, gdy strona doświadcza incydentu.

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

Wzorzec: router konfiguracji

Nie musisz wybierać jednej konfiguracji na zawsze. Użyj lekkiej konfiguracji do routingu, a odpowiedniej do wykonania: pierwszy agent odczytuje zadanie i zwraca typowany obiekt wskazujący, którego modelu i jakiego wysiłku użyć, a następnie instancjonujesz agenta wykonawczego z tą decyzją. Pole reason nie jest tylko ozdobnikiem – pozwala Ci, podczas przeglądania logów, zweryfikować, czy router nie przydziela systematycznie zbyt dużych zasobów.

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

Zachowanie strumieniowania przy włączonym rozumowaniu

Gdy rozumowanie jest włączone, strumieniowanie ma pewną osobliwość: wewnętrzny proces myślowy modelu nie jest strumieniowany jako zwykły tekst. Twój interfejs otrzymuje więc tokeny dla ostatecznej odpowiedzi, ale nic podczas fazy rozumowania.

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)

Uwzględnij to opóźnienie w swoim UX: przy wysiłku high lub wyższym, pierwsze tokeny mogą pojawić się po znacznym czasie myślenia. Wyraźny wskaźnik oczekiwania zapobiega sytuacji, w której użytkownicy myślą, że aplikacja się zawiesiła, i odświeżają stronę w najgorszym momencie.

Optymalizacja kosztów

Rozumowanie zużywa dodatkowe tokeny (wewnętrzne myślenie jest płatne). Dwa mechanizmy pomagają ograniczyć koszty: obniż domyślny wysiłek i zwiększaj go tylko w razie potrzeby, a następnie oddziel decyzję od wykonania – czyli rozumuj, aby podjąć decyzję, ale wykonuj zadanie bez rozumowania. Poniższy hybrydowy przepływ pracy stosuje drugą zasadę – Terra na poziomie medium ustala podejście, a Luna realizuje je przy użyciu narzędzi.

# 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

Kluczowe wnioski

  • Rozumowanie to ustawienie dla każdego żądania w każdym modelu GPT-5.6 (od none do max), a nie już oddzielne modele jak o3-pro/o4-mini.
  • GPT-5.6 Sol z wysiłkiem high/xhigh: planowanie strategiczne, złożone analizy, matematyka.
  • GPT-5.6 Terra z wysiłkiem medium: szybkie rozumowanie do diagnostyki i routingu.
  • Ustawienie ultra koordynuje wielu agentów działających równolegle dla najcięższych zadań – znacznie wyższy koszt tokenów.
  • Wzorzec routera dynamicznie wybiera kombinację modelu i wysiłku, optymalizując koszty.
  • Rozumuj, aby podjąć decyzję, wykonuj bez rozumowania: najlepszy stosunek jakości do ceny.