Agenti di ragionamento (GPT-5.6 Sol, sforzo da alto a massimo)
In questa pagina
- Agenti di ragionamento (GPT-5.6, sforzo da alto a massimo)
- Quando abilitare il ragionamento in un agente
- Sol + sforzo alto/xhigh: ragionamento profondo
- Terra + sforzo medio: ragionamento veloce
- Pattern: router di configurazione
- Comportamento dello streaming con il ragionamento abilitato
- Ottimizzazione dei costi
- Punti chiave
Aggiornato il 2 novembre 2026 — modelli.
o3,o3-proe gli snapshot legacy di GPT-5 verranno rimossi dalle API l’11 dicembre 2026, mentreo4-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
ultracoordina 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