Como usar o modo de raciocínio no claude 4.5

“Thinking mode” (também chamado de extended thinking, thinking ou thinking blocks) 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 com orçamento separado gerando um raciocínio interno, passo a passo (uma “chain-of-thought”), antes de emitir a resposta final. Ele é projetado para melhorar o desempenho em raciocínio de múltiplas etapas, codificação complexa e fluxos de 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 Messages 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 pensamento para verificação posterior ou uso por ferramentas, e introduz comportamentos de cache e de contabilização de tokens que você deve gerenciar ao criar cargas de trabalho de produção.

O que é Claude 4.5? (E com quais modelos devo me importar?)

Claude 4.5 é o conjunto mais recente de modelos Claude lançado como atualizações “4.5” incrementais (por exemplo, Sonnet 4.5 e Opus 4.5). O Sonnet 4.5 é posicionado como o melhor equilíbrio entre inteligência, codificação e desempenho em fluxos de agentes para a maioria dos desenvolvedores; o Opus 4.5 foca em raciocínio de esforço muito alto e preserva blocos de pensamento para melhorar a continuidade em múltiplas interações. Ambos os modelos suportam os recursos de pensamento estendido do Claude, embora alguns comportamentos (por exemplo, pensamento resumido vs. completo) variem conforme o 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 de código; ele é significativamente mais capaz de navegar por sistemas de arquivos inteiros e executar tarefas autônomas sem intervenção humana.

Por que isso importa

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

O que é o Modo de Pensamento no Claude 4.5?

O Modo de Pensamento (oficialmente chamado “Extended Thinking”) é um recurso que permite ao modelo “mostrar seu trabalho” para si mesmo antes de entregar a saída final. Diferentemente dos modelos padrão, que se comprometem com uma resposta imediatamente, o Claude 4.5 usa um espaço de raciocínio dedicado para explorar múltiplas hipóteses, identificar potenciais erros em sua lógica e refinar sua estratégia.

A anatomia de uma resposta

Numa interação padrão, o modelo recebe um prompt e começa a gerar a resposta. No Modo de Pensamento, a resposta é dividida em dois blocos distintos:

Propriedades principais do modo de pensamento

• Habilitar sob demanda: você passa um objeto thinking na chamada de 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 => potencial de raciocínio mais profundo, mas com maior custo e latência. Nos modelos Claude 4, os tokens de pensamento são cobrados mesmo que você receba apenas uma visualização resumida.
• Resumo e ocultação: em muitos modelos Claude 4 o usuário vê uma versão resumida do conteúdo de pensamento; parte do raciocínio interno pode ser ocultada (criptografada) pelos sistemas de segurança e retornada como redacted_thinking.
• Assinaturas e verificação: os blocos de pensamento incluem uma signature opaca usada para verificação ao retornar blocos de pensamento à API (especialmente necessário ao usar ferramentas). Trate a assinatura como opaca — não tente analisá-la.
• Pensamento intercalado com ferramentas: o Claude 4 suporta intercalar blocos de pensamento com execuções de ferramentas (beta e com base em flags em alguns casos). Isso é poderoso para trabalho com agentes (executar ferramenta, pensar, executar outra ferramenta, etc.).

Para exemplos práticos e os parâmetros mais atualizados, a documentação de Messages/Extended Thinking da Anthropic é a referência canônica.

Como a API Messages retorna conteúdo de pensamento

Pensamento resumido vs. completo; criptografia e assinaturas

Diferentes versões de modelos Claude lidam com o pensamento de maneira diferente: 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 redigidos). Quando ferramentas são usadas (ou você precisa preservar o estado interno entre chamadas de ferramentas), você deve enviar de volta os blocos de pensamento para a 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 do processo de pensamento quando necessário.

Padrão prático de manuseio

• Uso de ferramentas / continuação: se sua próxima solicitação precisar continuar o mesmo estado interno (por exemplo, ferramentas foram executadas com base no pensamento), inclua o bloco de pensamento retornado ou a assinatura quando 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 criptografada ou um bloco redacted_thinking, ou (c) ambos.

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

Exemplo 1 — curl simples (não streaming) ativando o pensamento

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; os blocos thinking contêm o resumo da análise interna do modelo.

Exemplo 2 — Python: solicitar, analisar blocos de pensamento e de 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 pensamento resumido e a resposta final. Se você precisa preservar a continuidade em fluxos de agentes de múltiplas etapas, inclua os blocos de pensamento não modificados na próxima solicitação no array messages (veja o próximo exemplo).

Exemplo 3 — reutilizando blocos de pensamento 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 blocos de pensamento exatos e não modificados é crítico ao integrar ferramentas ou em fluxos de agentes longos. O Opus 4.5 tem padrões aprimorados para preservação e cache de blocos de pensamento.

Como faço streaming de saídas de pensamento e mostro progresso em uma UI?

Boas práticas de streaming

• Use os endpoints de streaming do SDK (os SDKs de Python/TypeScript têm auxiliares de stream). Para tarefas longas ou com alto orçamento de raciocínio, o streaming previne timeouts HTTP e fornece texto parcial enquanto o modelo computa. Um código típico usa um iterador sobre text_stream (Python) ou parsing de eventos (JS).
• Espere streams em duas fases às vezes: o modelo pode primeiro produzir fragmentos de raciocínio visíveis, depois finalizar com a resposta. Construa sua UI para lidar com conteúdo fragmentado e mostrar estados de “pensando…” vs. resposta final.
• Se a API retornar um signature_delta ou content_block_delta durante o streaming, capture-o e anexe-o a chamadas subsequentes conforme exigido pela especificação.

Se você precisar mostrar progresso de raciocínio intermediário numa UI, faça streaming da 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 fazer streaming, manipule os eventos content_block_start, content_block_delta (que inclui thinking_delta e text_delta) e content_block_stop nessa 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 pensamento? (terminal + VS Code)

Claude Code é o terminal interativo e agentivo de codificação que integra a API Messages e executores de ferramentas. A experiência no CLI/IDE expõe o pensamento 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 pede permissões, se preserva blocos de pensamento, 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 de CLI: você pode escolher claude-sonnet-4-5 ou claude-opus-4-5 como o modelo ativo no REPL; as ferramentas e o comportamento de pensamento então seguem a semântica da API Messages. O CHANGELOG e as notas de versão indicam que o pensamento agora é habilitado por padrão em alguns deployments do Opus 4.5 e que a configuração de pensamento é exibida via /config.

Fluxo prático no Claude Code:

1. Inicie um projeto no REPL.
2. Use /config para inspecionar flags relacionadas ao pensamento (preservação, verbosidade, etc.).
3. Peça ao agente que execute uma tarefa longa — ele produzirá conteúdo de pensamento e, se necessário, pedirá permissão para executar determinadas etapas no bash. Preserve blocos de pensamento quando precisar verificar ou refazer 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 pensamento no terminal

O 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 de git), preserve quaisquer blocos thinking se o CLI/agente os retornar; caso contrário, o agente pode perder contexto entre as etapas.

Benefícios do Pensamento Intercalado e da Preservação de Blocos

Para fluxos avançados com agentes, o Claude 4.5 introduz dois recursos beta que melhoram significativamente as interações multi-turn e o uso de ferramentas: Pensamento Intercalado e Preservação de Blocos de Pensamento.

Pensamento Intercalado (Beta)

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

Imagine que o Claude está depurando um servidor:

1. Pense: "Eu deveria verificar os logs primeiro."
2. Chamada de ferramenta: read_file(logs.txt)
3. Pense: "Os logs mostram um timeout de 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 recebidos das ferramentas, em vez de seguir um plano rígido e pré-definido.

Preservação de Blocos de Pensamento

Em conversas de múltiplas etapas, especialmente aquelas que envolvem uso de ferramentas, é fundamental enviar de volta os blocos thinking anteriores para a API.

• Continuidade do raciocínio: ao receber seus pensamentos anteriores, o Claude mantém o contexto lógico de sua jornada.
• Otimização no Opus 4.5: no Claude Opus 4.5, esse comportamento é automatizado. O modelo preserva todos os blocos de pensamento anteriores em seu contexto por padrão, garantindo que, mesmo em sessões que duram mais de 30 horas, o modelo não “esqueça” por que tomou certas decisões arquiteturais dez interações atrás.

Boas práticas para usar o modo de pensamento 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 em que você precisa do melhor trade-off entre velocidade, custo e fortes habilidades de codificação; use o Opus 4.5 para o raciocínio mais profundo e as maiores janelas de contexto ou quando planejar executar sessões autônomas longas. Ambos suportam pensamento estendido. Escolha budget_tokens proporcionalmente à 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 de pensamento completos que o Claude produz, não pelo resumo que você recebe. Isso significa que deliberações internas longas aumentam o custo mesmo se você vir apenas um resumo curto. Acompanhe o uso de tokens e considere ajustes graduais (por exemplo: 2k → 8k → 32k) ao passar da exploração para a produção.

Preserve blocos de pensamento apenas quando necessário

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

Quando fazer streaming do pensamento para usuários

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

Uso de ferramentas e intercalação

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

Notas práticas de troubleshooting e operação

Erros comuns e o que significam

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

Observabilidade e instrumentação

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

Lançamento progressivo e humano-no-loop

Lance modelos com pensamento habilitado por trás de feature flags. Comece com uma porcentagem do tráfego de desenvolvedores ou interno, colete falhas ou ocultações, e itere em 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 budget_tokens baixo e aumente para entender melhorias incrementais.
• Ative o streaming e registre eventos content_block_delta / de assinatura para entender quando o modelo produz blocos de pensamento.
• Se estiver usando 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 Extended Thinking e do 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 avançou além da era dos “chatbots” para a era dos “agentes”.

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

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 do modelo da CometAPI no Playground e consulte o guia da API para instruções detalhadas. Antes de acessar, certifique-se de ter feito login na CometAPI e obtido a chave de API. A CometAPI oferece um preço muito inferior ao oficial para ajudar na integração.

Pronto para começar? → Avaliação gratuita do Claude 4.5!