Índice
- 1. O que realmente acontece — o token "court" e as tags invoke
- 2. Contexto: um agente também "gera" suas chamadas de ferramenta
- 3. Por que acontece — duas causas-raiz e gatilhos
- 4. Três equívocos comuns, corrigidos
- 5. Resolva agora (para usuários do Claude Code)
- 6. Para desenvolvedores: previna via API/SDK
- 7. Diferenciando de erros parecidos
- 8. Situação oficial
- 9. Checklist de prevenção
- Resumo
- FAQ
Se você já rodou sessões longas no Claude Code, talvez tenha visto uma string estranha surgir de repente na sua tela:
court
<invoke name="Bash">
<parameter name="command">ssh host 'cp file file.bak ; sed -i ...'</parameter>
<parameter name="description">…descrição do comando…</parameter>
</invoke>
Your tool call was malformed and could not be parsed. Please retry.Uma chamada de ferramenta (um comando) que deveria rodar nos bastidores vaza para o chat como texto cru — e nunca é executada. Na frente, aparece uma palavra sem sentido, court (ou call). É natural pensar "será que meu computador quebrou?" ou "configurei algo errado?". Mas a resposta curta é: não é o seu ambiente, nem o seu comando.
Trata-se de uma falha do lado do modelo, em que o Claude (especialmente a família Opus 4.8 / 4.7) corrompe as "tags de controle" de uma chamada de ferramenta no momento em que as gera. O repositório oficial da Anthropic tem muitas issues abertas sobre isso (#64108, #64150, #64690, #65705, #66153, #67295, #68354 e mais). Este artigo expõe o mecanismo, as causas, os equívocos comuns, as correções para usuário/desenvolvedor, como distingui-lo de erros parecidos e a situação oficial — com base na documentação da Anthropic e nas issues reais. A medida mais importante, logo de cara: quando o court aparecer, não insista naquela sessão — saia cedo para uma sessão nova (/clear). A razão está explicada abaixo.
O que "court" + tags invoke vazadas realmente são
— uma tag de controle é gerada quebrada, então vaza para a tela em vez de executar
Uma chamada quebrada não pode ser interpretada, então nunca é executada (fail-closed) — não há risco de um comando errado rodar.
Os problemas reais são um turno desperdiçado e uma "reação em cadeia" se você deixar passar.
1. O que realmente acontece — o token "court" e as tags invoke
O <invoke name="Bash"> e o <parameter name="command"> que você vê são "marcação de chamada de ferramenta" que você nunca deveria ver. Quando o Claude roda um comando ou edita um arquivo, ele gera essas tags estruturadas em estilo XML como tokens, e o Claude Code (o harness) as interpreta e de fato executa o comando. Normalmente o harness absorve as tags, elas nunca chegam à tela, e você só vê o resultado da ferramenta.
Desta vez, porém, o "token de controle de abertura" da chamada de ferramenta foi gerado quebrado, com a palavra sem relação court ou call surgindo na frente. O harness só reage a uma sintaxe estrita, então ele decide "isto não é uma chamada de ferramenta, é só texto" e despeja tudo direto na tela. O comando não roda, e você recebe "Your tool call was malformed and could not be parsed." Em alguns casos não há mensagem de erro nenhuma e ele simplesmente trava em silêncio (na issue #65705 a resposta voltou como stop_reason=end_turn sem nada para executar, então a conversa ficou pendurada).
A palavra court em si não tem significado. Mas também não é uma palavra totalmente aleatória e pontual — em vários relatos independentes, o vazamento aparece como court / call com uma consistência estranha. A issue #64690 analisa isso como "um token adjacente no vocabulário sendo selecionado no lugar da tag correta." Em outras palavras, é melhor entender o court como uma assinatura que ajuda você a reconhecer esse bug.
2. Contexto: um agente também "gera" suas chamadas de ferramenta
Por que uma "tag de controle" pode quebrar, afinal? A chave é que para um agente de IA, uma chamada de ferramenta é, no fim das contas, apenas geração de texto.
Quando você usa ferramentas com a API do Claude, o formato que você vê como desenvolvedor é JSON (um bloco tool_use). Internamente, porém, o modelo segue um system prompt oculto que a Anthropic injeta automaticamente e gera as tags envoltórias <function_calls>, <invoke> e <parameter> como um fluxo de tokens. A camada da API então interpreta isso e converte em um bloco tool_use JSON limpo (conforme a documentação oficial de tool use). Toda "chamada de ferramenta" em MCP e agentes de IA se apoia nesse mecanismo.
O que importa aqui é que o parser do harness é "fail-closed" (ele erra para o lado seguro). Se uma tag diferir da forma esperada em apenas um token, o harness não adivinha nem executa — ele rejeita imediatamente como malformada. Esse é o design de harness correto: "consertar prestativamente" um comando ambíguo e rodá-lo seria muito mais perigoso. Então todo esse fenômeno é um caso de "quebrou → foi rejeitado → não rodou" — ou seja, falhou de forma segura.
Em uma frase
Uma chamada de ferramenta é "texto com tags especiais" que o modelo gera. Quando o token de abertura dessas tags quebra durante a geração, o harness não consegue reconhecê-lo, então ele vaza para a prosa e não roda. A rejeição em si é um mecanismo de segurança correto; o bug está puramente na geração do lado do modelo.
3. Por que acontece — duas causas-raiz e gatilhos
Consolidando as issues reais, a causa se divide em "(1) corrupção no momento da geração" e na "(2) reação em cadeia por autoenvenenamento" que a torna desagradável.
Como quebra e depois "encadeia"
· Múltiplas chamadas de ferramenta em uma mensagem / uma chamada de ferramenta colocada logo após a prosa (#66153)
· O estado logo após rodar
/compact (#67295: recorre na primeira chamada após o compact)· Bash em segundo plano (run_in_background) ou 3+ servidores MCP conectados (#64690)
· Argumentos de ferramenta longos do tamanho de parágrafos (#49747: uma variante separada em que o XML vaza para o JSON)
Lição: a quebra em si é uma rara flutuação de amostragem. A parte realmente desagradável é a cadeia em (2) —
e é por isso que "insistir com retentativas na mesma sessão" pode ser a pior jogada.
4. Três equívocos comuns, corrigidos
A informação sobre esse fenômeno se embaralha facilmente. Para reagir corretamente, aqui estão três equívocos comuns esclarecidos.
| Crença comum | Realidade |
|---|---|
| "A ferramenta saiu do controle / deu defeito" | O contrário. A chamada quebrada foi rejeitada sem executar (fail-closed). Não há risco de um comando errado rodar; tudo o que aconteceu foi um "turno desperdiçado + um vazamento visual." Falhou de forma segura. |
| "Basta tentar de novo — se você deixar, ele se cura sozinho" | Só meia verdade. Um caso leve se recupera numa única retentativa, mas uma vez que o bloco quebrado fica no histórico o modelo o imita e encadeia. A #65705 teve 14 falhas seguidas em mais de 5 horas; a #66153 teve mais de 30 numa única sessão. Insistir na mesma sessão tem efeito reverso. |
"court significa algo / é um comando" | Não significa nada — apenas destroços de um token de controle corrompido. Mas court/call recorrem como um marcador, então são úteis como um sinal de diagnóstico. |
O segundo é o que mais importa. Relatos de incidentes costumam dizer "se recuperou na retentativa, então sem problema" — mas isso só vale para o caso "leve" antes de a cadeia começar. A essência desse bug é que uma vez que ele entra em modo de cadeia, nenhuma quantidade de retentativas dentro daquela sessão vai consertá-lo.
5. Resolva agora (para usuários do Claude Code)
A reação depende de "você ainda está leve ou a cadeia já começou?" Em ordem de prioridade:
Ordem de prioridade
court aparecer, faça /clear ou inicie uma sessão nova cedo. Cortar o histórico envenenado é o mais confiável. Antes de mudar, salve o estado com git commit ou uma nota de passagem./compact já foi relatado recorrendo logo depois — não é uma solução confiável.
A regra: "errou duas vezes, abandone a sessão e comece do zero."
Quanto mais você insiste num histórico envenenado, mais fundo é o ferimento. Mantenha a CLI atualizada (mas note: nenhuma correção foi lançada ainda — atualizar é higiene, não uma cura mágica).
Dica: se você habitualmente salva o estado em git ou numa nota de passagem em .md, mudar para uma sessão nova a qualquer momento não custa nada. Quanto mais você roda sessões autônomas longas, mais esse hábito compensa (e ele se conecta diretamente à gestão da sua janela de contexto).
6. Para desenvolvedores: previna via API/SDK
Se você constrói seu próprio agente sobre a API / SDK do Claude, pode adicionar as defesas a seguir no seu harness. A lógica de detecção proposta na issue #65705 é prática.
// Inspecione o turno do assistente recebido antes de executar
const text = assistantText(resp);
const looksLeaked =
/<invoke\s+name=/.test(text) ||
/function_calls/.test(text) ||
/\bcourt\s*<invoke/.test(text);
// 1) Marcação acima presente mas SEM bloco tool_use estruturado → chamada quebrada
if (looksLeaked && !hasToolUseBlock(resp)) {
// 2) Não mostre; registre em log. NÃO mantenha o bloco quebrado no histórico (previne autoenvenenamento)
// 3) Empurre para "emitir como tool_use estruturado, não texto" e tente de novo automaticamente
return retryWithNudge(messages);
}
// Rejeite um tool_use incompleto causado por truncamento
if (resp.stop_reason === 'max_tokens' && lastBlock(resp)?.type === 'tool_use') {
return retryWith({ max_tokens: higher }); // não execute
}Quatro princípios. (1) Sempre verifique o stop_reason (um end_turn sem nenhuma ferramenta de fato rodando = detecte a trava silenciosa). (2) Antes de executar, verifique se o texto não contém <invoke name= ou function_calls; se contiver, tente de novo em vez de executar. (3) Não mantenha o bloco quebrado no histórico da conversa (mantê-lo faz a próxima geração imitá-lo — autoenvenenamento / #62344). (4) Mantenha os argumentos de ferramenta curtos e divida saídas longas (evite a variante de payload longo na #49747). Mesmo ao usar um harness oficial como o Claude Agent SDK, vale entender como os loops de longa duração se comportam.
7. Diferenciando de erros parecidos
Existem vários erros de "a ferramenta não roda", e eles precisam de correções diferentes. Distinga estes cinco para não confundi-los.
| Sintoma | O que realmente é | Correção principal |
|---|---|---|
| court / call + tags invoke cruas exibidas, sem execução | O tema deste artigo. Corrupção na geração do token de controle + encadeamento via autoenvenenamento | Prefira uma sessão nova (/clear); não insista após dois erros |
| 400 "thinking blocks cannot be modified" trava a sessão | Um descompasso de assinatura no extended thinking (um bug diferente). Um erro fatal da API | Veja o artigo dedicado (Esc×2 / rewind) |
| A resposta é cortada no meio do fluxo (sem XML embaralhado) | Um truncamento normal por atingir o max_tokens. Não é um erro | Aumente o max_tokens e rode de novo |
| O XML não é estruturado no Bedrock, LangChain, etc. | Um cliente de terceiros falhando em interpretar o formato da Anthropic (langchain-aws #521). Não se reproduz na API oficial / Claude Code | Revise a biblioteca de integração / camada de hospedagem |
| Em uma sessão longa, falas de usuário inventadas ou texto de instruções aparecem na resposta (às vezes, uma resposta em inglês numa conversa em outro idioma) | Uma quebra do próprio formato da saída, relatada a partir de setembro de 2026. Diferente do court, não se limita a tags embaralhadas. Sem resposta oficial sobre a causa | Não deixe o contexto inchar; encerre a sessão quando ela quebrar. Veja a seção 8 do artigo sobre respostas em inglês |
O eixo para diferenciá-los é simples. Se você vê um "embaralhamento court / call + XML cru," é este bug. Um erro de assinatura 400 é o erro de bloco de thinking. Um corte limpo é só o limite de saída. Apenas no Bedrock ou via LangChain aponta para a camada de integração. Para outros erros comuns do Claude Code, veja a compilação de erros.
8. Situação oficial
Em junho de 2026, não há correção oficial confirmada (entrada de changelog) afirmando que esse fenômeno foi resolvido. Rastreando as notas de versão até o Claude Code mais recente (a linha 2.1.183), não há entrada que trate da corrupção de serialização de chamada de ferramenta, e muitas das issues relacionadas permanecem abertas, ou foram registradas como "duplicate / stale." Então toda correção neste artigo é uma solução de contorno enquanto se aguarda uma correção oficial, e não dá para afirmar que "atualizar para a versão mais recente resolve" (atualizar é recomendado, mas não é cura garantida).
Dito isso, o design fail-closed do harness de "rejeitar uma chamada quebrada em vez de executá-la por adivinhação" está, em si, correto. O que precisa de conserto é a estabilidade da geração do modelo — não afrouxar o parser para "consertar e rodar mesmo assim," o que convidaria o risco sério de rodar o comando errado. A melhor coisa que nós, usuários, podemos fazer é operar para evitar a cadeia e reportar reproduções nas issues oficiais com seu ambiente e logs (mais relatos elevam a prioridade e aceleram a correção).
9. Checklist de prevenção
Usuários do Claude Code: (1) Quando court/call aparecer, tente de novo no máximo duas vezes; se persistir, faça /clear / sessão nova imediatamente. (2) Evite sessões muito longas / de vários dias; salve o trabalho em git/notas nos pontos de parada. (3) Não empilhe múltiplas chamadas de ferramenta numa única mensagem. (4) Lembre-se de que o /compact não é uma panaceia (pode recorrer logo depois). (5) Mantenha a CLI atualizada e reporte reproduções nas issues oficiais.
Desenvolvedores de API/SDK: (1) Sempre verifique o stop_reason. (2) Detecte <invoke name= / function_calls vazando no texto e tente de novo. (3) Não mantenha chamadas quebradas no histórico (previna o autoenvenenamento). (4) Mantenha os argumentos de ferramenta curtos; divida saídas longas. (5) Nunca execute um tool_use incompleto vindo de um corte por max_tokens — tente de novo em vez disso.
Resumo
No Claude Code, "court / call + uma tag <invoke> crua exibida, com a ferramenta não executando" é uma falha do lado do modelo, em que o Claude (a família Opus 4.8 / 4.7) gera o token de controle de uma chamada de ferramenta de forma quebrada. O harness o rejeita em modo fail-closed, então não há risco de um comando errado rodar (falhou de forma segura). A parte realmente desagradável é que uma vez que o bloco quebrado fica no histórico, o modelo o imita e "encadeia." Por isso, "tentar de novo resolve" só vale enquanto está leve, e a regra passa a ser "errou duas vezes, saia para uma sessão nova."
A causa tem duas camadas: (1) corrupção na geração do token de controle + (2) encadeamento via autoenvenenamento. Os gatilhos incluem sessões longas / de vários dias, contexto pesado, o estado pós-/compact, múltiplas ferramentas concorrentes, 3+ servidores MCP e argumentos de ferramenta longos. Como nenhuma correção oficial foi lançada até junho de 2026, todo remédio é uma solução de contorno. Usuários devem "preferir uma sessão nova + salvar o estado com frequência"; desenvolvedores devem "verificar o stop_reason, tentar de novo ao detectar vazamento, nunca manter histórico quebrado e encurtar os argumentos." Ler o invalid signature in thinking block, a compilação de erros do Claude Code e MCP junto com este texto vai deixar você muito mais resiliente a problemas de chamada de ferramenta. Para entender como o /rewind e os checkpoints funcionam — e o que exatamente eles restauram —, veja os checkpoints e o /rewind do Claude Code.
FAQ
Q. O "court" ou a tag invoke na minha tela são causados por um erro no meu comando ou nas configurações?
A. Não — quase certamente não. Esta é uma falha conhecida do lado do modelo, em que o Claude gera tags de chamada de ferramenta de forma quebrada, com várias issues registradas no repositório oficial da Anthropic (#64108, #65705, #66153 e mais). Não é um erro no seu ambiente, comando ou configurações. Trate court/call como uma "assinatura" do bug.
Q. Um comando errado poderia rodar e danificar meu servidor ou arquivos quando isso acontece?
A. Não. Uma chamada de ferramenta quebrada é julgada "malformada" e rejeitada sem executar (design fail-closed). Tudo o que acontece é que o turno é desperdiçado e o texto de controle fica visível; não há efeito sobre seus dados ou o estado do servidor. Ele é projetado para falhar de forma segura.
Q. Ouvi dizer "basta tentar de novo que se resolve sozinho." Isso é verdade?
A. Só quando está leve. Numa primeira ocorrência pontual, um empurrãozinho para "continuar" muitas vezes faz o modelo reemitir corretamente. Mas uma vez que o bloco quebrado fica no histórico da conversa, o modelo o usa como template e repete a mesma corrupção (autoenvenenamento). A partir daí, tentar de novo na mesma sessão tem efeito reverso. Se falhar duas vezes seguidas, pare de insistir e mude para uma sessão nova (/clear).
Q. O /compact vai resolver?
A. Não de forma confiável. Compactar o contexto às vezes ajuda, mas na issue #67295 ele recorreu na primeiríssima chamada de ferramenta logo após o /compact. A medida mais confiável não é o /compact e sim uma sessão nova (/clear) que reseta totalmente o histórico. Salve seu estado de trabalho em git ou notas antes de mudar.
Q. Atualizar o Claude Code para a versão mais recente vai resolver?
A. Não dá para afirmar que "resolve." Em junho de 2026 não há entrada oficial de changelog confirmando uma correção, e muitas issues relacionadas permanecem abertas ou duplicadas. Atualizar é recomendado como higiene, mas não é uma cura mágica. Por ora, a melhor abordagem é operar para evitar a cadeia (errou duas vezes → sessão nova) e reportar reproduções nas issues oficiais.
Erros do Claude Code relacionados: Unable to connect, "Prompt is too long", 529 Overloaded / 500, Invalid API key, Response stalled mid-stream / court loop.
