Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Agenti di ragionamento (GPT-5.6 Sol, sforzo da alto a massimo)

Lezione 16 di 25 Aggiornata il 2 novembre 2026 Sviluppatore
In questa pagina
  1. Agenti di ragionamento (GPT-5.6, sforzo da alto a massimo)
  2. Quando abilitare il ragionamento in un agente
  3. Sol + sforzo alto/xhigh: ragionamento profondo
  4. Terra + sforzo medio: ragionamento veloce
  5. Pattern: router di configurazione
  6. Comportamento dello streaming con il ragionamento abilitato
  7. Ottimizzazione dei costi
  8. Punti chiave

Aggiornato il 2 novembre 2026 — modelli. o3, o3-pro e gli snapshot legacy di GPT-5 verranno rimossi dalle API l’11 dicembre 2026, mentre o4-mini è stato ormai superato da tempo. Per i nuovi agenti, inizia con la famiglia GPT-6: GPT-6.1 Sol per un equilibrio ottimale, GPT-6 Astra per i compiti più impegnativi.

Agenti di ragionamento (GPT-5.6, sforzo da alto a massimo)

Con la famiglia GPT-5.6 (disponibile da luglio 2026), il ragionamento non è più gestito da modelli separati come nella generazione precedente (o3-pro, o4-mini): è ora un’impostazione per richiesta (none, low, medium, high, xhigh, max) applicabile a ogni modello. Un agente che ha davvero bisogno di pensare — esplorando più percorsi prima di rispondere — utilizzerà tipicamente GPT-5.6 Sol con sforzo high o xhigh. Integrata nei tuoi agenti, questa capacità di ragionamento sblocca compiti che richiedono una vera deliberazione.

Quando abilitare il ragionamento in un agente

Il ragionamento profondo eccelle in situazioni specifiche e l’esperienza mostra che condividono tutte un tratto comune: confrontare possibili percorsi prima di prendere una decisione. Questo vale per la pianificazione complessa, dove scomponi un compito in passaggi ottimali, e per l’analisi matematica — calcoli, statistiche, ottimizzazione — dove un singolo errore invalida il resto. Si applica anche al debug, che richiede di risalire da un sintomo alla sua causa radice, e al processo decisionale, dove devi valutare diverse opzioni e scegliere la migliore. Anche la revisione del codice rientra in questa categoria: trovare un bug sottile richiede di simulare mentalmente esecuzioni che una lettura lineare non rivelerà.

Per compiti semplici (rispondere a una domanda, formattare testo), GPT-5.6 Terra o Luna con sforzo basso (o persino none) sono più veloci ed economici. Pagare per il ragionamento solo per riformulare un paragrafo è come lasciare al minimo un’auto da corsa nel traffico.

Sol + sforzo alto/xhigh: ragionamento profondo

GPT-5.6 Sol con sforzo di ragionamento elevato sostituisce ciò che faceva o3-pro. L’agente impiega più tempo ma produce analisi più profonde. L’esempio seguente è tipico: una domanda strategica con tre opzioni, dove la risposta corretta dipende dai compromessi tra rischio, costo e orizzonte temporale. Nota che le istruzioni definiscono esplicitamente le dimensioni da considerare: il ragionamento beneficia sempre di vincoli chiari.

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)

Per le analisi più critiche, aumenta fino a xhigh o max. Esiste anche un’impostazione ultra (annunciata a luglio 2026) che coordina di default 4 agenti in parallelo (fino a 16 in certe valutazioni) per i compiti più pesanti: potente, ma con un consumo di token significativamente più elevato; riservala ai problemi che giustificano il costo.

Terra + sforzo medio: ragionamento veloce

Tra l’assenza di ragionamento e l’analisi profonda esiste un punto di equilibrio ampiamente utilizzato in produzione. GPT-5.6 Terra con sforzo medium offre un buon compromesso tra capacità di ragionamento e velocità — l’equivalente del precedente o4-mini. Ideale per agenti che devono ragionare rapidamente, come questo agente diagnostico che legge le metriche del server e deve collegare la saturazione della memoria a un picco di errori 5xx in pochi secondi, mentre il sito sta subendo un incidente.

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

Pattern: router di configurazione

Non devi scegliere una configurazione per sempre. Usa una configurazione leggera per il routing e quella appropriata per l’esecuzione: un primo agente legge il compito, restituisce un oggetto tipizzato che indica quale modello e sforzo utilizzare, quindi istanzi l’agente di esecuzione con quella decisione. Il campo reason non è decorativo: ti permette, quando rivedi i tuoi log, di verificare che il router non stia sistematicamente sovradimensionando le risorse.

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

Comportamento dello streaming con il ragionamento abilitato

Quando il ragionamento è abilitato, lo streaming presenta una particolarità: il processo di pensiero interno del modello non viene trasmesso in testo semplice. La tua interfaccia riceve quindi token per la risposta finale, ma nulla durante la fase di ragionamento.

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)

Tieni conto di questa latenza nella tua UX: con sforzo high o superiore, i primi token potrebbero arrivare dopo un tempo di pensiero significativo. Un indicatore di attesa esplicito impedisce agli utenti di pensare che l’app si sia bloccata e di ricaricare la pagina nel momento peggiore.

Ottimizzazione dei costi

Il ragionamento consuma token aggiuntivi (il pensiero interno è fatturato). Due leve aiutano a contenere i costi: abbassa lo sforzo predefinito e aumentalo solo quando necessario, quindi separa la decisione dall’esecuzione — ovvero, ragiona per decidere ma esegui senza ragionamento. Il flusso di lavoro ibrido seguente applica il secondo principio: Terra a medium stabilisce l’approccio, Luna lo esegue con gli strumenti.

# 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

Punti chiave

  • Il ragionamento è un’impostazione per richiesta su ogni modello GPT-5.6 (da none a max), non più modelli separati come o3-pro/o4-mini
  • GPT-5.6 Sol con sforzo high/xhigh: pianificazione strategica, analisi complesse, matematica
  • GPT-5.6 Terra con sforzo medium: ragionamento veloce per diagnosi e routing
  • L’impostazione ultra coordina più agenti in parallelo per i compiti più pesanti — costo in token significativamente più elevato
  • Il pattern del router seleziona dinamicamente la combinazione modello + sforzo e ottimizza i costi
  • Ragiona per decidere, esegui senza ragionare: il miglior rapporto qualità-prezzo