Como usar o modo de raciocínio no Claude 4.5

“Modo de raciocínio” (também chamado de raciocínio estendido, raciocínio ou blocos de raciocínio) no Claude 4.5 é um modo de operação explícito e configurável que instrui o modelo a gastar um número de tokens separado gerando raciocínio interno, passo a passo (uma “cadeia de raciocínio”) antes de emitir a resposta final. Ele é projetado para melhorar o desempenho em raciocínios de múltiplas etapas, codificação complexa e fluxos agentes, além de tarefas de pesquisa, trocando latência e custo de tokens por uma deliberação interna mais profunda. O Claude 4.5 expõe essa capacidade no nível da API de Mensagens com parâmetros explícitos (por exemplo, thinking / budget_tokens ou um cabeçalho de esforço/“interleaved-thinking”), preserva e opcionalmente criptografa blocos de raciocínio para posterior verificação ou uso por ferramentas, e introduz comportamentos de cache e contabilização de tokens que você deve gerenciar ao construir cargas de trabalho em produção.

O que é o Claude 4.5? (E quais modelos importam?)

Claude 4.5 é o conjunto mais recente de modelos Claude lançado como atualizações incrementais “4.5” (por exemplo, Sonnet 4.5 e Opus 4.5). O Sonnet 4.5 é posicionado como o melhor equilíbrio entre inteligência, desempenho em codificação e capacidade agente para a maioria dos desenvolvedores; o Opus 4.5 foca em raciocínio de altíssimo esforço e preserva blocos de raciocínio para melhorar a continuidade em múltiplas rodadas. Ambos os modelos suportam as capacidades de raciocínio estendido do Claude, embora alguns comportamentos (por exemplo, raciocínio resumido vs completo) variem por modelo.

Os ganhos de desempenho no Claude 4.5, particularmente no Sonnet 4.5, são mais visíveis no benchmark SWE-bench Verified, que mede a capacidade de uma IA de resolver issues reais do GitHub.

Esses números indicam que o Claude 4.5 não é apenas melhor em escrever trechos; ele é significativamente mais capaz de navegar por sistemas de arquivos inteiros e executar tarefas autônomas sem intervenção humana.

Por que isso importa

• Código e agentes: O Sonnet 4.5 mostra ganhos sólidos em tarefas de software do mundo real e trabalho de codificação de longo horizonte — tornando-o uma escolha natural para geração e edição de código, e fluxos de agentes autônomos.
• Raciocínio estendido e contexto: Os modelos da família Claude 4.5 foram construídos para raciocinar com cadernos internos muito grandes (dezenas de milhares de tokens ou mais), permitindo raciocínios mais profundos de múltiplas etapas. Isso muda como você projeta prompts, orçamentos de tokens e interações com ferramentas.

O que é o Modo de Raciocínio no Claude 4.5?

O Modo de Raciocínio (oficialmente denominado “Raciocínio Estendido”) é uma capacidade que permite ao modelo “mostrar seu trabalho” para si mesmo antes de entregar um resultado final. Ao contrário de modelos padrão que se comprometem com uma resposta imediatamente, o Claude 4.5 usa um espaço dedicado de raciocínio para explorar múltiplas hipóteses, identificar possíveis erros em sua lógica e refinar sua estratégia.

A anatomia de uma resposta

Em uma interação padrão, o modelo recebe um prompt e começa a gerar a resposta. No Modo de Raciocínio, a resposta é dividida em dois blocos distintos:

Propriedades-chave do modo de raciocínio

• Habilitado sob demanda: Você passa um objeto thinking na chamada à API, como {"type":"enabled","budget_tokens":10000}, para ativá-lo e dar ao modelo um orçamento interno de tokens para raciocínio.
• Orçamentação: budget_tokens limita os tokens de raciocínio interno do modelo. Mais orçamento => maior potencial de raciocínio profundo, mas com custo e latência mais altos. Nos modelos Claude 4, tokens de raciocínio são cobrados mesmo que você receba apenas uma visão resumida.
• Resumo e ocultação: Para muitos modelos Claude 4, o usuário vê uma versão resumida do conteúdo de raciocínio; algum raciocínio interno pode ser ocultado (criptografado) pelos sistemas de segurança e retornado como redacted_thinking.
• Assinaturas e verificação: Blocos de raciocínio incluem uma signature opaca usada para verificação ao retornar blocos de raciocínio à API (especialmente necessário ao usar ferramentas). Você deve tratar a assinatura como opaca — não tente analisá-la.
• Raciocínio intercalado com ferramentas: O Claude 4 suporta intercalar blocos de raciocínio com execuções de ferramentas (beta e com flags em alguns casos). Isso é poderoso para trabalho de agentes (executar ferramenta, raciocinar, executar outra ferramenta etc.).

Para exemplos práticos e os parâmetros mais atualizados, a documentação de Mensagens/Raciocínio Estendido da Anthropic é a referência canônica.

Como a API de Mensagens retorna conteúdo de raciocínio

Raciocínio resumido vs completo; criptografia e assinaturas

Diferentes versões dos modelos Claude lidam com raciocínio de maneiras diferentes: modelos Claude 4 mais recentes (como Sonnet/Opus 4.5) frequentemente retornam uma visão pública resumida do raciocínio interno, enquanto o caderno completo pode ser criptografado e disponibilizado apenas via um campo signature (ou blocos ocultados). Quando ferramentas são usadas (ou você precisa preservar o estado interno entre chamadas de ferramentas), você deve passar blocos de raciocínio de volta à API ou usar o mecanismo de assinatura descrito na documentação. Esse mecanismo ajuda a proteger o raciocínio interno sensível enquanto permite a continuação segura de um processo de pensamento quando necessário.

Padrão prático de tratamento

Uso de ferramentas / continuação: se sua próxima solicitação deve continuar o mesmo estado interno (por exemplo, ferramentas foram executadas com base no raciocínio), inclua o bloco de raciocínio retornado ou a assinatura quando você chamar a API novamente para que o modelo possa descriptografar e continuar de onde parou.

Solicitação: envie thinking: {type: "enabled", budget_tokens: N}.

Resposta: você pode receber (a) uma saída pública resumida, (b) uma signature ou redacted_thinking criptografadas, ou (c) ambos.

CometAPI oferece a API do Claude 4.5 por 20% do preço oficial, e também pode ser chamada usando a Anthropic Messages. Você precisará obter uma chave de API antes de começar.

Exemplo 1 — curl simples (não streaming) habilitando raciocínio

curl https://api.cometapi.com/v1/messages \
  -H "x-api-key: $CometAPI_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 16000,
    "thinking": {
      "type": "enabled",
      "budget_tokens": 10000
    },
    "messages": [
      {"role": "user", "content": "Design a robust data validation strategy for CSV imports, show tests + code."}
    ]
  }'

A resposta conterá blocos content. Inspecione cada bloco e prefira os blocos text para a saída final; blocos thinking contêm o resumo da análise interna do modelo.

Exemplo 2 — Python: solicitar, analisar blocos de raciocínio e texto

import os, requests

API_KEY = os.environ["CometAPI_API_KEY"]
URL = "https://api.cometapi.com/v1/messages"
HEADERS = {
    "x-api-key": API_KEY,
    "anthropic-version": "2023-06-01",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-5",
    "max_tokens": 16000,
    "thinking": {"type": "enabled", "budget_tokens": 8000},
    "messages": [{"role": "user", "content": "Explain how to do property-based testing in Python; include example code."}]
}

r = requests.post(URL, headers=HEADERS, json=payload)
r.raise_for_status()
resp = r.json()

# Parse blocks
for block in resp.get("content", []):
    if block.get("type") == "thinking":
        thinking_summary = block.get("thinking")
        print("=== THINKING (summary) ===")
        print(thinking_summary[:1000])  # truncate for logs
        print("signature:", block.get("signature")[:64], "...")
    elif block.get("type") == "text":
        print("=== FINAL TEXT ===")
        print(block.get("text"))

Este código extrai e imprime o raciocínio resumido e a resposta final. Se você precisar preservar a continuidade em fluxos de agentes de múltiplas rodadas, inclua os blocos de raciocínio não modificados na próxima requisição no array messages (veja o próximo exemplo).

Exemplo 3 — reutilizando blocos de raciocínio em um fluxo multi-turn (pseudo Python)

# After initial response (resp above):
# Add the assistant message including the thinking block back into the conversation
assistant_message = {
  "role": "assistant",
  "content": resp["content"]  # include raw content array (contains thinking + text blocks)
}

# Next user turn: ask follow-up and include previous assistant message
payload2 = {
  "model": "claude-opus-4-5",  # Opus preserves thinking blocks better across turns
  "max_tokens": 20000,
  "thinking": {"type": "enabled", "budget_tokens": 12000},
  "messages": [
    {"role": "user", "content": "Now adapt the validation logic for an avro pipeline."},
    assistant_message
  ]
}
r2 = requests.post(URL, headers=HEADERS, json=payload2)

Preservar exatamente os blocos de raciocínio sem modificações é crítico ao integrar ferramentas ou conduzir fluxos de agentes longos. O Opus 4.5 tem padrões aprimorados para preservação e cache de blocos de raciocínio.

Como transmitir saídas de raciocínio e mostrar progresso em uma UI?

Boas práticas de streaming

• Use os endpoints de streaming dos SDKs (os SDKs de Python/TypeScript têm helpers de stream). Para trabalhos de raciocínio de longa duração ou alto orçamento, o streaming evita timeouts de HTTP e fornece texto parcial enquanto o modelo calcula. O código típico utiliza um iterador sobre text_stream (Python) ou análise de eventos (JS).
• Espere streams em duas fases às vezes: o modelo pode primeiro produzir pedaços visíveis de raciocínio e depois finalizar com a resposta. Construa sua UI para lidar com conteúdo fragmentado e para mostrar estados “raciocinando…” vs resposta final.
• Se a API retornar um signature_delta ou content_block_delta durante o streaming, capture-o e anexe-o às chamadas subsequentes conforme exigido pela especificação.

Se você precisar mostrar progresso de raciocínio intermediário em uma UI, transmita a resposta. O servidor emitirá eventos thinking_delta seguidos por eventos text_delta.

curl https://api.cometapi.com/v1/messages \
  --header "x-api-key: $CometAPI_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 16000,
    "stream": true,
    "thinking": { "type": "enabled", "budget_tokens": 8000 },
    "messages": [ { "role": "user", "content": "Walk me through debugging this failing unit test and propose fixes." } ]
  }'

Ao transmitir, lide com eventos content_block_start, content_block_delta (que incluem thinking_delta e text_delta) e content_block_stop em ordem. É assim que você pode exibir o raciocínio passo a passo do modelo conforme ele acontece.

Como o Claude Code interage com o modo de raciocínio? (terminal + VS Code)

Claude Code é o terminal interativo e agente de codificação que integra a API de Mensagens e executores de ferramentas. A experiência de CLI/IDE expõe o raciocínio de duas maneiras:

• Configurações globais / por sessão: O Claude Code expõe um painel de configurações /config para ajustar o comportamento (como o agente solicita permissões, se preserva blocos de raciocínio etc.). Use essa UI em vez de digitar JSON bruto se você quiser uma mudança de comportamento persistente.
• Seleção de modelo e comandos da CLI: Você pode escolher claude-sonnet-4-5 ou claude-opus-4-5 como modelo ativo no REPL; as ferramentas e o comportamento de raciocínio então seguem as semânticas da API de Mensagens. O CHANGELOG e as notas de versão indicam que o raciocínio agora é habilitado por padrão em algumas implantações do Opus 4.5 e que a configuração de raciocínio é exposta via /config.

Fluxo prático no Claude Code:

1. Inicie um projeto no REPL.
2. Use /config para inspecionar flags relacionadas ao raciocínio (preservação, verbosidade etc.).
3. Peça ao agente para executar uma tarefa longa — ele produzirá conteúdo de raciocínio e, se necessário, solicitará permissão para executar etapas específicas de bash. Preserve blocos de raciocínio quando precisar verificar ou reexecutar decisões depois.

Instalação e configuração

Claude Code requer Node.js e pode ser instalado globalmente.

# Install Claude Code CLI
npm install -g @anthropic/claude-code

# Authenticate
claude-code --init

Ativando o raciocínio no terminal

Claude Code suporta várias flags e gatilhos em linguagem natural para controlar a profundidade do raciocínio.

Dicas:

• Use think/think harder quando quiser que o agente explore implementações alternativas.
• Quando o Claude Code realiza chamadas de ferramentas (executar testes, operações git), preserve quaisquer blocos thinking se a CLI/agente os retornar; caso contrário, o agente pode perder contexto entre etapas.

Benefícios do raciocínio intercalado e da preservação de blocos

Para fluxos de trabalho de agentes avançados, o Claude 4.5 introduz dois recursos beta que melhoram significativamente interações de múltiplas rodadas e o uso de ferramentas: Raciocínio Intercalado e Preservação de Blocos de Raciocínio.

Raciocínio Intercalado (Beta)

O raciocínio padrão ocorre uma vez antes da saída. O Raciocínio Intercalado (habilitado via o cabeçalho interleaved-thinking-2025-05-14) permite que o Claude “pense” entre chamadas de ferramentas.

Imagine que o Claude esteja depurando um servidor:

1. Raciocinar: "Eu deveria verificar os logs primeiro."
2. Chamada de ferramenta: read_file(logs.txt)
3. Raciocinar: "Os logs mostram um timeout do banco de dados. Agora preciso verificar as configurações do pool de conexões."
4. Chamada de ferramenta: read_file(db_config.yml)

Essa “reflexão contínua” garante que o modelo adapte sua estratégia com base nos dados que recebe das ferramentas, em vez de seguir um plano rígido e pré-definido.

Preservação de Blocos de Raciocínio

Em conversas de múltiplas rodadas, especialmente as que envolvem uso de ferramentas, é fundamental passar os blocos thinking anteriores de volta para a API.

• Continuidade de raciocínio: Ao receber seus pensamentos anteriores, o Claude mantém o contexto lógico de sua trajetória.
• Otimização no Opus 4.5: No Claude Opus 4.5, esse comportamento é automatizado. O modelo preserva todos os blocos de raciocínio anteriores em seu contexto por padrão, garantindo que, mesmo em sessões com duração de 30+ horas, o modelo não “esqueça” por que tomou certas decisões arquitetônicas há dez rodadas.

Boas práticas para usar o modo de raciocínio com o Claude 4.5

Escolha o modelo e o orçamento certos para a tarefa:

Use o Sonnet 4.5 para codificação e fluxos de agentes onde você precisa do melhor equilíbrio entre velocidade, custo e fortes habilidades de codificação; use Opus 4.5 para o raciocínio mais profundo e as maiores janelas de contexto ou quando você planeja executar sessões autônomas longas. Ambos suportam raciocínio estendido. Escolha budget_tokens proporcional à complexidade da tarefa (comece pequeno para experimentos; aumente o orçamento apenas se observar melhorias materiais na qualidade).

Monitore e controle custo e latência

Você é cobrado pelos tokens completos de raciocínio que o Claude produz, não pela saída resumida que você recebe. Isso significa que deliberações internas longas aumentam o custo mesmo que você veja apenas um resumo curto. Acompanhe o uso de tokens e considere ajustes graduais (por exemplo: 2k → 8k → 32k) ao passar de exploração para produção.

Preserve blocos de raciocínio apenas quando necessário

Blocos de raciocínio podem ser assinados criptograficamente e preservados para verificação posterior e uso intercalado com ferramentas. Evite ecoar blocos de raciocínio em cada solicitação subsequente, a menos que seu fluxo de trabalho exija que o modelo retenha suas deliberações internas anteriores (por exemplo, quando um agente irá reexecutar etapas e precisa das justificativas preservadas). Preservar raciocínio o tempo todo aumenta o volume de contexto e pode complicar a contabilização de tokens.

Quando transmitir raciocínio para usuários

Raciocínio transmitido é excelente para ferramentas de desenvolvedor e UIs educacionais (mostrando “trabalho em andamento” enquanto o modelo delibera). Não transmita raciocínio bruto para usuários finais de aplicativos de consumo voltados à produção sem considerar segurança e ocultação: raciocínio resumido existe precisamente por esse motivo. Se transmitir, forneça recursos na UI que rotulem o raciocínio interno (por exemplo, “Raciocínio do assistente — interno”), e controle se o usuário final vê o raciocínio resumido ou completo.

Uso de ferramentas e intercalação

Ao combinar raciocínio com ferramentas (execução de código, busca na web, processos locais), use o design de raciocínio intercalado quando precisar que o modelo selecione ferramentas, as execute e raciocine sobre resultados na mesma rodada. A intercalação aumenta a complexidade (e pode exigir flags de recursos), mas é poderosa para automação por agentes. Seja explícito sobre qual raciocínio você preserva e teste como o modelo seleciona ferramentas em uma execução com raciocínio habilitado.

Notas práticas de solução de problemas e operação

Erros comuns e o que significam

• Raciocínio inválido + escolha de ferramenta forçada: Se você solicitar raciocínio mas também forçar modos de uso de ferramentas incompatíveis com o raciocínio, a API retornará um erro — não misture tool_choice: {"type":"tool","name":"..."} com raciocínio.
• Budget > max_tokens: Para cenários de raciocínio intercalado as regras efetivas de tokens diferem — a plataforma explica quando budget_tokens pode exceder max_tokens. Leia com atenção a seção “raciocínio intercalado” antes de testar grandes orçamentos.
• Validação de assinatura: Se você preservar blocos de raciocínio para chamadas posteriores, inclua a signature retornada para que a API possa verificar que vieram do Claude; isso evita adulterações e mantém a cadeia verificável.

Observabilidade e instrumentação

Registre: (1) seleção de model, (2) thinking.budget_tokens, (3) consumo real de tokens de raciocínio (você é cobrado por isso), (4) latências de streaming (tempo até o primeiro thinking_delta) e (5) tokens de texto finais. Use essas métricas para construir orçamentos e SLOs para fluxos voltados ao usuário.

Implantação progressiva e humano no loop

Implante modelos com raciocínio habilitado atrás de flags de recursos. Comece com uma porcentagem do tráfego de desenvolvedores ou interno, colete falhas ou ocultações e itere prompts e orçamentos. Para domínios sensíveis, exija revisão humana em saídas que incluam raciocínio interno substancial antes da liberação.

Dicas de depuração

• Comece pequeno: habilite baixo budget_tokens e aumente para entender melhorias incrementais.
• Ative streaming e registre eventos content_block_delta / de assinatura para entender quando o modelo produz blocos de raciocínio.
• Se usar o Claude Code: verifique /config e as configurações no nível do projeto; consulte o changelog do Claude Code se o comportamento não corresponder aos padrões esperados.

Conclusão:

O Claude 4.5, combinado com o poder do Raciocínio Estendido e o CLI Claude Code, representa o salto mais significativo na produtividade de desenvolvedores desde a invenção do IDE. Ao permitir que o modelo “mostre seu trabalho” e delibere sobre problemas complexos, a Anthropic foi além da era dos “chatbots” e entrou na era “agente”.

Quer você esteja integrando a API de Mensagens em uma ferramenta de desenvolvimento personalizada ou usando o Claude Code para gerenciar seus PRs diários, dominar o Modo de Raciocínio é essencial. Ele fornece a transparência necessária para confiança e a profundidade de raciocínio necessária para excelência.

Os desenvolvedores podem acessar o modelo Claude 4.5 (Claude Sonnet 4.5, Claude Haiku 4.5, Claude Opus 4.5) por meio da CometAPI. Para começar, explore as capacidades dos modelos da CometAPI no Playground e consulte o guia da API para instruções detalhadas. Antes de acessar, certifique-se de que você fez login na CometAPI e obteve a chave de API. CometAPI oferece um preço muito inferior ao oficial para ajudar na sua integração.

Pronto para começar? → Teste gratuito do Claude 4.5!