Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Agentes de Raciocínio (GPT-5.6 Sol, esforço elevado a máximo)

Aula 16 de 25 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Agentes de Raciocínio (GPT-5.6, esforço elevado a máximo)
  2. Quando ativar o raciocínio num agente
  3. Sol + esforço high/xhigh: raciocínio profundo
  4. Terra + esforço medium: raciocínio rápido
  5. Padrão: router de configuração
  6. Comportamento de streaming com raciocínio ativado
  7. Otimização de custos
  8. Pontos-chave

Atualizado em 2 de novembro de 2026 — modelos. Os modelos o3, o3-pro e as versões antigas do GPT-5 serão removidos da API a 11 de dezembro de 2026, e o o4-mini já foi há muito substituído. Para novos agentes, comece pela família GPT-6: GPT-6.1 Sol para equilíbrio, GPT-6 Astra para as tarefas mais exigentes.

Agentes de Raciocínio (GPT-5.6, esforço elevado a máximo)

Com a família GPT-5.6 (disponível desde julho de 2026), o raciocínio deixou de ser gerido por modelos separados, como na geração anterior (o3-pro, o4-mini): passou a ser uma definição por pedido (none, low, medium, high, xhigh, max) aplicável a todos os modelos. Um agente que realmente precise de pensar — explorando múltiplos caminhos antes de responder — utilizará tipicamente o GPT-5.6 Sol com esforço high ou xhigh. Integrada nos seus agentes, esta capacidade de raciocínio desbloqueia tarefas que exigem uma deliberação genuína.

Quando ativar o raciocínio num agente

O raciocínio profundo destaca-se em situações específicas, e a experiência mostra que todas partilham uma característica comum: comparar caminhos possíveis antes de tomar uma decisão. Isto aplica-se ao planeamento complexo, onde divide uma tarefa em passos ótimos, e à análise matemática — cálculos, estatística, otimização — onde um passo errado invalida o restante. Aplica-se também à depuração (debugging), que envolve rastrear um sintoma até à sua causa raiz, e à tomada de decisões, onde deve avaliar várias opções e escolher a melhor. A revisão de código enquadra-se na mesma categoria: encontrar um erro subtil requer simular mentalmente execuções que uma leitura linear não revelaria.

Para tarefas simples (responder a uma pergunta, formatar texto), o GPT-5.6 Terra ou Luna com esforço baixo (ou mesmo none) é mais rápido e barato. Pagar por raciocínio para reformular um parágrafo é como deixar um carro de corrida ao ralenti no trânsito.

Sol + esforço high/xhigh: raciocínio profundo

O GPT-5.6 Sol com esforço de raciocínio elevado substitui o que o o3-pro fazia anteriormente. O agente demora mais tempo, mas produz análises mais profundas. O exemplo abaixo é típico: uma questão estratégica com três opções, onde a resposta certa depende de compromissos entre risco, custo e horizonte temporal. Note que as instruções definem explicitamente as dimensões a considerar — o raciocínio beneficia sempre de restrições claras.

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)

Para as análises mais críticas, aumente para xhigh ou max. Existe também uma definição ultra (anunciada em julho de 2026) que coordena 4 agentes em paralelo por defeito (até 16 em certas avaliações) para as tarefas mais pesadas — poderosa, mas com um consumo de tokens significativamente maior: reserve-a para problemas que justifiquem o custo.

Terra + esforço medium: raciocínio rápido

Entre a ausência de raciocínio e a análise profunda existe um ponto ideal amplamente utilizado em produção. O GPT-5.6 Terra com esforço medium oferece um bom compromisso entre capacidade de raciocínio e velocidade — o equivalente ao antigo o4-mini. Ideal para agentes que precisam de raciocinar rapidamente, como este agente de diagnóstico que lê métricas do servidor e deve ligar a saturação da memória a um pico de erros 5xx em segundos, enquanto o site enfrenta um 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."
)

Padrão: router de configuração

Não tem de escolher uma configuração para sempre. Utilize uma configuração ligeira para o encaminhamento e a adequada para a execução: um primeiro agente lê a tarefa, devolve um objeto tipificado indicando qual o modelo e o esforço a usar, e depois instancia o agente de execução com essa decisão. O campo reason não é decorativo — permite-lhe, ao rever os seus registos, verificar se o router não está a sobredimensionar sistematicamente os recursos.

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 de streaming com raciocínio ativado

Quando o raciocínio está ativado, o streaming tem uma particularidade: o processo de pensamento interno do modelo não é transmitido em texto simples. A sua interface recebe, portanto, tokens para a resposta final, mas nada durante a fase de raciocínio.

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)

Tenha em conta esta latência na sua experiência de utilizador (UX): com esforço high ou superior, os primeiros tokens podem chegar após um tempo de pensamento significativo. Um indicador de espera explícito impede que os utilizadores pensem que a aplicação congelou e atualizem a página no pior momento.

Otimização de custos

O raciocínio consome tokens adicionais (o pensamento interno é faturado). Duas alavancas ajudam a conter custos: reduzir o esforço por defeito e aumentá-lo apenas quando necessário; depois, separar a decisão da execução — ou seja, raciocinar para decidir, mas executar sem raciocínio. O fluxo de trabalho híbrido abaixo aplica o segundo princípio: o Terra em medium estabelece a abordagem, o Luna executa-a com ferramentas.

# 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

Pontos-chave

  • O raciocínio é uma definição por pedido em todos os modelos GPT-5.6 (none → max), deixando de ser modelos separados como o o3-pro/o4-mini
  • GPT-5.6 Sol com esforço high/xhigh: planeamento estratégico, análise complexa, matemática
  • GPT-5.6 Terra com esforço medium: raciocínio rápido para diagnósticos e encaminhamento
  • A definição ultra coordena múltiplos agentes em paralelo para as tarefas mais pesadas — custo de tokens significativamente mais elevado
  • O padrão de router seleciona dinamicamente a combinação modelo + esforço e otimiza custos
  • Raciocinar para decidir, executar sem raciocínio: a melhor relação qualidade-preço