---
title: Otimizando para custo e inteligência
url: https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence
description: Equilibre custo e inteligência na Claude Platform, com resultados medidos para cache de prompt, esforço, escolha de modelo, limites de saída e estratégias multimodelo.
---
O modelo mais capaz pode ser caro demais em escala, e o modelo mais barato pode deixar a desejar em qualidade. A Claude Platform dá a você controle direto sobre esse equilíbrio. Você escolhe o modelo, o nível de "effort" (esforço) e a arquitetura de cada requisição, o que permite posicionar uma carga de trabalho em praticamente qualquer ponto da fronteira entre custo e inteligência.
Custo e inteligência costumam ser representados como uma fronteira em que um se obtém à custa do outro. O primeiro grupo de alavancas desta página aproxima uma carga de trabalho dessa fronteira, cortando custo sem afetar a qualidade; apenas o segundo grupo se move ao longo dela:
As alavancas são de dois tipos:
* **Ganhos gratuitos** reduzem o gasto sem afetar a qualidade: "prompt caching" (cache de prompt), higiene de tokens, uma auditoria de prompts em relação ao modelo que você está executando, "[batch processing](https://platform.claude.com/docs/pt-BR/build-with-claude/batch-processing)" (processamento em lote) com 50% de desconto para trabalhos que podem esperar até 24 horas, e [limites de gastos do workspace](https://platform.claude.com/docs/pt-BR/api/rate-limits#setting-lower-limits-for-workspaces) como rede de segurança.
* **Compensações** trocam custo por inteligência: escolha de modelo, esforço, limites de saída e orçamentos de sessão, um relógio de tempo decorrido e arquiteturas multimodelo.
Cada alavanca vem com resultados medidos e a regra de quando ela compensa. Nas medições da Anthropic, o cache de prompt geralmente foi a maior alavanca. As alavancas multimodelo são mais restritas; um segundo modelo foi medido em dois formatos, um conselheiro (advisor) e um orquestrador (orchestrator).
## Comece aqui
Encontre a linha que corresponde à sua situação.
| Sua situação | Faça isto | Onde |
| ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Qualquer carga de trabalho, qualquer modelo | Ative o cache de prompt e corte tokens desnecessários; ambos são gratuitos | [Armazene contexto repetido em cache](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#cache-repeated-context) · [Corte tokens](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) |
| Uma pessoa espera entre os turnos | Conte os intervalos entre suas requisições e escolha a duração do cache na tabela dessa seção | [Escolha a duração do cache](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#pick-the-cache-duration) |
| Os custos estão altos demais; a qualidade está boa | Experimente um esforço menor no modelo que você usa agora | [Ajuste o esforço](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort) |
| Você não está no modelo mais recente | Faça o upgrade; nas medições da Anthropic, cada modelo mais novo resolveu pelo menos tantas tarefas quanto o anterior, geralmente por um custo menor por tarefa resolvida | [Faça upgrade do modelo](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#upgrade-the-model) |
| Você está escolhendo ou trocando de modelo | Compare pelo custo por tarefa concluída, não por token | [Compare modelos](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task) |
| Trabalho de alto volume com saídas que você pode verificar | Experimente primeiro o Claude Haiku 5.5 | [Compare modelos](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task) |
| A qualidade não é boa o suficiente | Se você reduziu o esforço, restaure-o; caso contrário, experimente o nível acima com seu esforço padrão | [Ajuste o esforço](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort) · [Compare modelos](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task) |
| As tentativas terminam com `stop_reason: max_tokens` | Aumente `max_tokens` para 64.000: nos testes da Anthropic, apenas 2 de cerca de 14.000 turnos foram mais longos, e o custo por tarefa resolvida permaneceu praticamente o mesmo | [Defina orçamentos](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps) |
| Você consegue verificar as saídas (testes, um verificador) | Execute com esforço `low` e execute novamente as falhas com `high`: nos testes da Anthropic, custo cerca de 40% menor do que tudo em `high`, com a mesma taxa de aprovação | [Reexecute as falhas](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#re-run-failures-at-higher-effort) |
| Loops de agente com algumas execuções muito caras | Defina um orçamento de sessão do Claude Managed Agents e um limite de gastos do workspace | [Defina orçamentos](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps) |
| Você quer que as execuções do agente terminem mais cedo | Diga ao modelo que o tempo importa e mostre a ele o tempo decorrido: de 7% a 47% menos tempo nos testes da Anthropic, por alguns pontos de pontuação | [Mostre ao modelo o tempo decorrido](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time) |
| Um modelo mais barato trava apenas em decisões difíceis | Experimente um advisor. Ele só pode ajudar quando seu modelo o consulta; primeiro, calcule o preço do modelo dele sozinho com esforço baixo e meça a taxa de consulta | [Estratégia advisor](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#advisor-strategy-escalate-hard-decisions) |
| O trabalho excede uma janela de contexto | Divida o trabalho e entregue as partes a modelos de menor custo | [Estratégia de orquestrador](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#orchestrator-strategy-delegate-bulk-work) |
Esses resultados são internos da Anthropic ([Benchmarks referenciados](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs)) e indicativos, não garantias, então meça na sua própria carga de trabalho com o [método de quatro etapas](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#measure-on-your-own-workload).
## Corte gastos sem perder qualidade
Cache de prompt, higiene de tokens, processamento em lote e uma auditoria de prompt em relação ao seu modelo atual reduzem o que você paga sem reduzir a qualidade da saída. Duas ressalvas se aplicam: o processamento em lote troca latência pelo seu desconto, e a edição de contexto, uma alavanca de higiene de tokens, custou mais do que economizou na execução medida nesta seção.
### Armazene contexto repetido em cache
#### Por que o cache vem primeiro
Ative o [cache de prompt](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching) antes de qualquer outra alavanca, porque cada turno de uma tarefa agêntica reenvia toda a conversa crescente: "system prompt" (prompt do sistema), definições de ferramentas e todos os turnos anteriores.
* Uma tarefa de 40 turnos envia seu primeiro turno 40 vezes, então o custo da tarefa cresce aproximadamente com o quadrado do número de turnos.
* O cache não impede o reenvio, mas cada reenvio custa cerca de um décimo (um vigésimo no Claude Opus 5.5 e no Claude Sonnet 5.5, um quadragésimo no Claude Fable 5.1 e Claude Mythos 5.1) e é processado mais rapidamente.
* O prefixo é cobrado pela [taxa de leitura de cache](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching#pricing) em vez do preço de entrada, e cada turno paga a taxa de gravação de cache de 1,25x apenas pelo que é novo.
**Como é um bom resultado.**
* Ao longo de um dia inteiro de tráfego real, os loops de agente leram uma mediana de 84% de sua entrada do cache, e os 10% melhores deles, de codificação ou não, leram 94% ou mais[17](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs).
* Já avançado em uma tarefa, um loop bem construído paga o preço cheio em menos de 1% de sua entrada.
* Abaixo de cerca de 80%, procure algo que esteja quebrando o cache (consulte [O que quebra o cache](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#what-breaks-the-cache)).
Nas execuções medidas pela Anthropic, as leituras de cache são rotineiramente o maior componente individual do custo da tarefa, tornando o cache mais valioso do que a maioria das decisões de escolha de modelo. A Anthropic precificou as execuções do DeepResearch Bench II[7](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) com e sem cache:
O tempo de vida padrão do cache é de 5 minutos e os turnos de um loop de agente ocorrem com segundos de intervalo, então o desconto se aplica à maioria dos tokens em cada turno. As execuções do gráfico de cache leram de 84% a 90% de seus tokens de entrada do cache.
Calcular o preço das contagens de tokens registradas de outras execuções da mesma forma, com cada modelo em seu esforço padrão, fornece o custo médio de tokens por tarefa sem cache (nenhuma dessas execuções foi feita com o cache desativado):
| Benchmark | Modelo | Sem cache |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- | --------------------------- |
| SWE-bench Pro[3](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Opus 5.5 | 3,3 vezes o custo com cache |
| SWE-bench Pro | Claude Sonnet 5.5 | 3,1 vezes o custo com cache |
| Conjunto de tarefas do Claude Managed Agents[25](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), cujas sessões são curtas | Claude Haiku 5.5 | 1,7 vez o custo com cache |
| Um pequeno agente que faz a triagem de relatórios de bugs ([Corte tokens de entrada e de contexto](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens))[16](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Sonnet 5.5 | 7,3 vezes o custo com cache |
A economia varia conforme o número de turnos que uma tarefa leva, porque loops mais curtos releem menos.
No Claude Haiku 5.5, [compacte uma sessão longa](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#manage-the-context-lifecycle) em um limite de tarefa, antes que suas requisições ultrapassem 100.000 tokens de prompt. Uma requisição cujo prompt tem mais de 100.000 tokens paga 5 vezes mais por cada um de seus tokens, incluindo a saída. Leituras e gravações de cache contam para os 100.000 tokens, então uma requisição com um grande prefixo em cache ainda pode ultrapassar o limite. Consulte [Preços de contexto longo](https://platform.claude.com/docs/pt-BR/about-claude/pricing#long-context-pricing).
#### Escolha a duração do cache
Se o seu loop espera por uma pessoa entre os turnos, use a [duração de cache de 1 hora](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching#1-hour-cache-duration) quando cerca de 1 turno em 20 vier após uma pausa entre 5 minutos e uma hora e poucos intervalos passarem de uma hora. No Claude Fable 5.1, Claude Opus 5.5 e Claude Sonnet 5.5, manter o cache de 5 minutos aquecido pode custar menos.
A duração de 1 hora custa mais para gravar (2x o preço de entrada em vez de 1,25x). Uma falha de cache em qualquer uma das durações cobra o prefixo inteiro pelo preço de gravação em vez do preço de leitura.
A Anthropic mediu um pequeno agente que faz a triagem de relatórios de bugs ([Corte tokens de entrada e de contexto](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens)) com pausas inseridas antes de alguns turnos para simular o atraso de uma pessoa[16](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs). A precisão permaneceu dentro do ruído entre execuções em todas as configurações medidas. A Anthropic também mediu requisições extras que mantêm o cache de 5 minutos aquecido (requisições de keep-alive).
Para decidir, conte os intervalos entre requisições consecutivas em uma conversa e encontre sua linha na tabela a seguir:
| Seus intervalos entre requisições | Modelo | Use |
| ------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------- | ---------------------------------------------------------------- |
| Os turnos chegam com segundos de intervalo | Qualquer | Padrão de 5 minutos |
| Cerca de 1 intervalo em 20 ou mais fica entre 5 minutos e uma hora, e poucos intervalos passam de uma hora | Qualquer | Duração de 1 hora |
| Intervalos de mais de uma hora são comuns: cerca de 60% ou mais das suas pausas com mais de 5 minutos também passam de uma hora | Qualquer | Padrão de 5 minutos |
| Apenas 1 ou 2 intervalos em 20 ficam entre 5 minutos e uma hora, e nenhum dura mais do que cerca de meia hora | Claude Opus 5.5 e Claude Sonnet 5.5 | Cache de 5 minutos mantido aquecido, em vez da duração de 1 hora |
| Há uma pausa antes de cada turno | Claude Opus 5.5 e Claude Sonnet 5.5 | Duração de 1 hora |
| As pausas duram minutos | Claude Fable 5.1 | Cache de 5 minutos mantido aquecido, em vez da duração de 1 hora |
| As pausas se aproximam de uma hora | Claude Fable 5.1 | Duração de 1 hora |
No Claude Haiku 5.5, use as linhas "Qualquer". As requisições de keep-alive não foram medidas nele. Pelos preços de tabela, não por medição, cada uma custa o dobro, em relação ao preço de entrada, do que no Claude Opus 5.5 e no Claude Sonnet 5.5: o Claude Haiku 5.5 lê o cache pelo padrão de 0,1x, e esses dois por 0,05x.
**Por quê, linha por linha.**
* **Qualquer modelo.**
* **Os turnos chegam com segundos de intervalo.** Sem pausas: o padrão custou cerca de 19% menos do que a configuração de 1 hora no Claude Sonnet 5.5, e cerca de 15% a 18% menos no Claude Opus 5.5.
* **Cerca de 1 intervalo em 20 ou mais.** O ponto de equilíbrio, calculado a partir das contagens de tokens, é de cerca de 1 turno em 30 no Claude Sonnet 5.5 e no Claude Opus 5.5.
* **Intervalos de mais de uma hora são comuns.** Em qualquer modelo, um intervalo de mais de uma hora expira ambas as durações, e a configuração de 1 hora então regrava o prefixo pelo seu preço de gravação mais alto.
* **Claude Opus 5.5 e Claude Sonnet 5.5**, cujas leituras de cache custam 0,05x o preço de entrada.
* **Apenas 1 ou 2 intervalos em 20.** No esforço padrão, as requisições de keep-alive custam de 8% a 13% menos do que a duração de 1 hora no Claude Opus 5.5, e de 8% a 16% menos no Claude Sonnet 5.5.
* **Há uma pausa antes de cada turno.** No Claude Opus 5.5 e no Claude Sonnet 5.5, as requisições de keep-alive custam alguns por cento a mais do que a duração de 1 hora com pausas de 6 minutos e mais de 50% a mais com pausas de 45 minutos.
* **Claude Fable 5.1**, cujas [leituras de cache](https://platform.claude.com/docs/pt-BR/about-claude/pricing#prompt-caching) custam 0,025x o preço de entrada.
* **As pausas duram minutos.** No Claude Fable 5.1, as requisições de keep-alive[19](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) custam de 13% a 20% menos do que o cache de 1 hora, com 10% dos turnos pausados e com uma pausa de 6 minutos antes de cada turno.
* **As pausas se aproximam de uma hora.** No Claude Fable 5.1, somente com uma pausa de 45 minutos antes de cada turno o cache de 1 hora venceu, por cerca de $0,12 USD em uma sessão de 5 relatórios de bugs.
O gráfico a seguir mostra o custo por sessão em relação à proporção de turnos pausados no Claude Sonnet 5.5:
O gráfico a seguir adiciona o cache de 5 minutos mantido aquecido por requisições de keep-alive, no Claude Fable 5.1, Claude Opus 5.5 e Claude Sonnet 5.5:
**O que saber.**
* A regra de 1 em 20 deixa uma margem sobre o ponto de equilíbrio de cerca de 1 turno em 30. Com 1 turno em 20, as configurações de 5 minutos e de 1 hora custaram praticamente o mesmo no Claude Sonnet 5.5, dentro da variação entre execuções; com 1 turno em 10, a configuração de 5 minutos custou 54% a mais (referência 16).
* Em modelos diferentes do Claude Sonnet 5.5 e do Claude Opus 5.5, os preços colocam o ponto de equilíbrio na mesma faixa: todos os modelos atuais usam os mesmos multiplicadores de gravação de cache, e todos os modelos, exceto Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5 e Claude Sonnet 5.5, o mesmo preço de leitura.
* Os números de keep-alive do Claude Opus 5.5 e do Claude Sonnet 5.5 vêm de requisições enviadas com `max_tokens: 1`. Se uma requisição com `max_tokens: 0` atualiza uma entrada de cache existente não foi medido no Claude Opus 5.5 (referência 16).
Para manter o cache aquecido:
1. Pegue a requisição anterior, defina `max_tokens` como 0 e remova `stream` se estiver definido. Não altere nenhum byte do prefixo.
2. Reenvie os cabeçalhos da requisição junto com seu corpo. Sem o cabeçalho `anthropic-beta` da requisição original, os campos restritos a beta no corpo reenviado são rejeitados.
3. Envie-a dentro de 4 minutos a partir do início da requisição anterior, e a cada 4 minutos depois disso. Conte a partir do início da requisição, porque o [tempo de vida de 5 minutos do cache](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching#how-prompt-caching-works) começa a contar a partir daí.
Essa é a [requisição de pré-aquecimento](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching#pre-warming-the-cache): ela renova o tempo de vida do cache, não retorna saída e custa pouco mais do que a leitura do cache. Depois que o cache expira, a próxima requisição, seja de keep-alive ou não, regrava o prefixo pelo preço de gravação de cache[16](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs).
Uma requisição com `max_tokens: 0` é rejeitada nos seguintes casos:
* A requisição define `thinking.type: "enabled"` (o pensamento adaptativo padrão no Claude Fable 5.1 não tem problema), saídas estruturadas ou uma escolha de ferramenta forçada ([suas limitações](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching#limitations)). Nessas cargas de trabalho, contrate a duração de 1 hora.
* A requisição contém o parâmetro de nível superior `compaction`, então não reenvie uma requisição de compactação da [compactação sob demanda](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-on-demand) como requisição de keep-alive.
```bash cURL
# Em até 4 minutos após o início da última requisição (o tempo gasto na geração conta
# para o tempo de vida do cache), reenvie essa requisição com max_tokens definido como
# 0, removendo stream (uma requisição com max_tokens: 0 não pode usar streaming). Envie os mesmos
# cabeçalhos da requisição original, incluindo qualquer cabeçalho anthropic-beta.
jq '.max_tokens = 0 | del(.stream)' last_request.json | \
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
--data-binary @-
```
#### Ative o cache
A configuração exige pouco trabalho. O [cache automático](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching#automatic-caching) posiciona os "breakpoints" (pontos de interrupção) para você; caso contrário, a [skill Claude API](https://platform.claude.com/docs/pt-BR/agents-and-tools/agent-skills/claude-api-skill) que acompanha o Claude Code pode adicionar cache a uma integração existente a partir de um único prompt, `/claude-api add prompt caching to this integration`. No código que produziu essas medições, ela colocou um breakpoint no bloco de sistema e um em cada um dos dois turnos de usuário mais recentes; [Pontos de interrupção de cache explícitos](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching#explicit-cache-breakpoints) explica onde posicioná-los.
#### O que quebra o cache
Mantenha o texto específico de cada requisição no turno de usuário mais recente, após o último breakpoint de cache, e faça toda alteração que invalida o cache em uma pausa natural, como a primeira requisição após uma compactação. O cache é uma correspondência de prefixo exata byte a byte sobre a requisição em ordem (ferramentas, depois prompt do sistema, depois mensagens), então uma alteração em qualquer ponto invalida tudo o que vem depois dela.
O risco é maior no Claude Fable 5.1 e Claude Mythos 5.1, em que uma quebra regrava o prefixo a 1,25x o preço de entrada em vez de lê-lo a 0,025x. A tabela a seguir mostra quanto custa um turno quebrado em um prefixo de 100.000 tokens, calculado a partir dos preços de tabela com o cache de 5 minutos, não medido:
| Modelo | Um turno quebrado | A leitura em vez disso | Comparado com a leitura |
| ------------------------------------ | ----------------- | ---------------------- | ----------------------- |
| Claude Fable 5.1 e Claude Mythos 5.1 | $1,25 USD | $0,025 USD | 50 vezes |
| Claude Opus 5.5 | $0,50 USD | $0,02 USD | 25 vezes |
| Claude Sonnet 5.5 | $0,25 USD | $0,01 USD | 25 vezes |
Nos outros modelos atuais ele custa 12,5 vezes a leitura.
**O que fazer.**
* Não coloque nada que mude a cada requisição, como um timestamp ou uma posição na fila, antes do prefixo estável: isso transforma cada requisição em uma gravação de cache completa. Em uma medição em um modelo anterior, uma linha de status de 25 tokens no início do prompt do sistema fez uma execução de um pequeno agente que faz a triagem de relatórios de bugs ([Corte tokens de entrada e de contexto](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens)) custar mais do que executar com o cache desativado[18](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs).
* A página de [cache de prompt](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching#what-invalidates-the-cache) lista as alterações que invalidam o cache, como uma alteração em [`effort`](https://platform.claude.com/docs/pt-BR/build-with-claude/effort), na configuração de pensamento, no prompt do sistema ou em uma definição de ferramenta. Alterar o formato de saída invalida o cache para aquela conversa (consulte [saídas estruturadas](https://platform.claude.com/docs/pt-BR/build-with-claude/structured-outputs#prompt-modification-and-token-costs)).
* Nos modelos mais recentes, altere instruções com uma [mensagem de sistema no meio da conversa](https://platform.claude.com/docs/pt-BR/build-with-claude/mid-conversation-system-messages), uma mensagem `{"role": "system"}` anexada a `messages`, em vez de editar o campo de nível superior `system`: o prefixo em cache permanece intacto. Consulte essa página para saber quais modelos oferecem suporte. Uma alteração de esforço por mensagem também mantém o prefixo em cache intacto, mas em menos modelos: [Alterar o esforço no meio da conversa](https://platform.claude.com/docs/pt-BR/build-with-claude/effort#changing-effort-mid-conversation) os lista.
* Após uma alteração que invalida o cache, confirme que as leituras de cache não caíram; se caíram, o [diagnóstico de cache](https://platform.claude.com/docs/pt-BR/build-with-claude/cache-diagnostics) mostra onde o prefixo divergiu.
A Anthropic mediu o momento de uma alteração em um modelo anterior, nas sessões longas do agente de triagem[18](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs). Nessa medição, as sessões custaram mais quando uma alteração de esforço e uma ferramenta adicionada foram feitas no meio da sessão, ou na requisição que acionou a compactação, do que quando as mesmas duas alterações foram feitas na primeira requisição após a compactação. A precisão ficou dentro do ruído entre execuções em todos os casos.
As sessões sem alterações custaram mais do que as sessões alteradas após a compactação, mas não por causa do cache. Elas rodaram no esforço padrão o tempo todo e duas compactaram uma segunda vez, enquanto as outras começaram com esforço baixo (referência 18):
### Corte tokens de entrada e de contexto
A maioria das requisições de agente carrega tokens que nunca influenciam a resposta. Cortá-los raramente custa qualidade de saída, embora nem toda alavanca aqui tenha economizado dinheiro quando medida. Há dois lugares para examinar:
* **Redução de entrada.**
* A [filtragem dinâmica](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool#dynamic-filtering) na ferramenta web fetch mantém conteúdo repetitivo fora das páginas buscadas.
* O [redimensionamento de imagens](https://platform.claude.com/docs/pt-BR/build-with-claude/vision#evaluate-image-size) ajusta o tamanho das entradas de visão.
* A [busca de ferramentas com carregamento adiado](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/tool-search-tool) carrega definições de ferramentas apenas quando necessário (medido mais adiante nesta seção).
* A [chamada programática de ferramentas](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/programmatic-tool-calling) permite que o Claude execute várias chamadas de ferramentas a partir de código, de modo que apenas o resultado filtrado entre no contexto; sua documentação relata 24% menos tokens de entrada em benchmarks de busca agêntica, com uma pontuação mais alta.
* [Gerenciar o contexto de ferramentas](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/manage-tool-context) compara busca de ferramentas, chamada programática de ferramentas, cache de prompt e edição de contexto.
* **Ciclo de vida do contexto.** A [edição de contexto](https://platform.claude.com/docs/pt-BR/build-with-claude/context-editing) limpa resultados de ferramentas obsoletos, e a [compactação automática](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold), com seu limite, impede que loops longos carreguem todo o histórico adiante.
As alavancas interagem com o cache e entre si, então avalie-as pelo efeito líquido e use o [diagnóstico de cache](https://platform.claude.com/docs/pt-BR/build-with-claude/cache-diagnostics) para confirmar que seu prefixo em cache sobrevive a cada alteração.
Em medições em um modelo anterior[28](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), a Anthropic as executou em um agente de triagem de issues trabalhando em 20 relatórios de bugs reais com capturas de tela de um repositório público, e em uma variante mais longa do mesmo trabalho com 2,6 vezes os tokens. Com o cache ativado, a redução de entrada (redimensionamento de imagens e busca de ferramentas) reduziu ainda mais o custo de ambas as execuções.
#### Adie definições de ferramentas não utilizadas
Toda definição de ferramenta anexada a uma requisição é entrada em cada turno, e alguns servidores MCP somam centenas delas.
Em uma medição em um modelo anterior[27](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), a Anthropic executou o agente de triagem com suas duas ferramentas próprias mais um catálogo de definições de ferramentas reais de servidores MCP públicos, totalizando até 502 ferramentas, carregando todas elas ou marcando as extras com `defer_loading` por trás da [busca de ferramentas](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/tool-search-tool):
* Com todas as definições carregadas, o custo da execução aumentou à medida que o catálogo cresceu, acompanhando os tokens de schema em cada requisição.
* Com a busca de ferramentas, o custo da execução permaneceu estável em todos os tamanhos de catálogo.
* A precisão ficou na mesma faixa em ambos os casos, e o modelo nunca chamou uma ferramenta errada, então nessa escala o catálogo custa dinheiro, não correção.
* No mesmo modelo anterior, com um servidor MCP público do GitHub conectado por meio do [conector MCP](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-connector), adiar seu conjunto de ferramentas (`default_config: {defer_loading: true}`) reduziu o custo da execução com a mesma precisão.
#### Mantenha arquivos de dados fora do prompt
Quando o modelo precisa computar sobre uma tabela, faça o upload dela com a [Files API](https://platform.claude.com/docs/pt-BR/build-with-claude/files) e deixe o modelo consultá-la com [execução de código](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/code-execution-tool) em vez de colá-la. A Anthropic fez 25 perguntas agregadas[15](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) (somas, contagens filtradas, agrupamentos e um filtro de data) sobre um CSV público de 1.862 linhas, com as respostas computadas pelo pandas:
Colada no prompt, a tabela ocupa cerca de 91.000 tokens de entrada em cada requisição, e o Claude Sonnet 5 respondeu corretamente 7 de 25 perguntas. Enviada por upload, com execução de código, ele respondeu todas as 25, e a execução custou cerca de um doze avos. O Claude Opus 5 mostrou o mesmo padrão.
#### Gerencie o ciclo de vida do contexto
As alavancas de contexto só compensam em uma sessão longa o suficiente para precisar delas:
A Anthropic mediu essas alavancas em um modelo anterior[28](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs):
* Na execução de 20 issues, as alavancas economizaram pouco ou nada, e a edição de contexto fez a execução custar mais.
* Na execução longa, a poda e a compactação reduziram o custo, enquanto a edição de contexto não mudou nada.
* A poda são algumas linhas que você mesmo escreve: em cada limite de tarefa, substitua resultados de ferramentas grandes e obsoletos por um extrato de uma linha.
* A poda funciona bem com o cache porque as edições ficam no final da conversa, onde a próxima tarefa adiciona conteúdo novo de qualquer forma.
* Ao longo de toda a execução, a poda e a edição de contexto funcionam com o cache de forma praticamente igual. Se você usar edição de contexto, [limpe em poucos lotes grandes](https://platform.claude.com/docs/pt-BR/build-with-claude/context-editing#context-editing-and-prompt-caching).
No Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 e Claude Haiku 5.5, reescrever um resultado de ferramenta anterior [invalida todos os blocos de pensamento posteriores a ele](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking#prefix-check), então use a compactação em vez disso. A poda foi medida em um modelo anterior sem [pensamento preservado](https://platform.claude.com/docs/pt-BR/build-with-claude/preserved-thinking); nesses quatro modelos, a [edição de contexto](https://platform.claude.com/docs/pt-BR/build-with-claude/context-editing) e a [compactação](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction) são executadas no servidor e não invalidam blocos de pensamento.
A poda, adaptada do código do agente de triagem:
```python
import re
PRUNED = "[pruned at issue boundary]"
def prune_task_boundary(messages, tool_name_by_id, threshold=2000):
"""Call once per task boundary. Replaces large, stale search results with a one-line extract."""
for message in messages:
if message["role"] != "user" or not isinstance(message["content"], list):
continue
for block in message["content"]:
if not (isinstance(block, dict) and block.get("type") == "tool_result"):
continue
if tool_name_by_id.get(block.get("tool_use_id")) != "search_issues":
continue
result_text = block.get("content")
if not isinstance(result_text, str) or len(result_text) <= threshold:
continue
if result_text.startswith(PRUNED):
continue # already pruned on an earlier boundary
# limita resultados de linha única para manter o extrato curto
first_line = result_text.split("\n", 1)[0].strip()[:200]
refs = re.findall(r"#(\d+)", result_text)[:5]
extract = f"{PRUNED} {first_line}"
if refs:
extract += " kept refs: " + " ".join("#" + r for r in refs)
block["content"] = extract
```
### Coloque em lote o trabalho que pode esperar
Encaminhe toda requisição pela qual ninguém está esperando por meio da [Batch API](https://platform.claude.com/docs/pt-BR/build-with-claude/batch-processing) e mantenha o caminho interativo para o restante. A Batch API dá 50% de desconto em cada token de uma requisição, incluindo os em cache, em troca de os resultados chegarem a qualquer momento dentro de 24 horas.
* O processamento em lote é a segunda maior alavanca gratuita, depois do cache, para trabalho de agente não supervisionado: execuções de avaliação, preenchimentos retroativos e jobs agendados, como uma execução recorrente do agente de triagem de issues da [medição de corte de tokens](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens).
* O processamento em lote se combina com tudo nesta página, exceto interatividade, mas não está disponível para sessões do Claude Managed Agents, que são interativas por design (consulte [Preços do Claude Managed Agents](https://platform.claude.com/docs/pt-BR/about-claude/pricing#claude-managed-agents-pricing)).
### Audite prompts em relação ao modelo atual
Audite os prompts em relação ao modelo que você executa agora, e novamente sempre que trocar de modelo: é um ganho gratuito.
* Cada geração de modelo responde aos prompts de forma diferente, então um prompt acumula texto escrito para um modelo que você não usa mais.
* O caso mais comum são instruções excessivamente específicas adicionadas para compensar um modelo mais antigo: "verifique duas vezes", "seja o mais minucioso possível", um procedimento passo a passo obrigatório ou um rascunho de raciocínio feito à mão.
* Um modelo mais novo segue essas instruções ao pé da letra, produzindo rodadas extras de ferramentas e escrita extra, então a conta sobe sem ganho de precisão.
A auditoria é um único comando. A [skill Claude API](https://platform.claude.com/docs/pt-BR/agents-and-tools/agent-skills/claude-api-skill) que acompanha o Claude Code tem um comando `prompt-audit` que lê os prompts e o código de requisição de um projeto e relata o que foi escrito para um modelo diferente. Este trecho resumido mostra ele sendo executado em um prompt de central de suporte e código de requisição contendo esses padrões:
```text wrap
$ claude
> /claude-api prompt-audit
10 findings. The three that matter most:
1. budget_tokens returns a 400 on Opus 5 (support_agent.py:10). This code
does not run against its own target model. Everything else here is
quality; this one is an outage.
2. The prompt contains two live contradictions. Line 15 says confirm before
every refund, line 17 says process every eligible refund immediately.
Line 19 asks for a complete recap *and* a three-sentence maximum.
3. The reasoning scaffold and the 6-step script fight the model rather than
steer it. + "reason step by step" is now a request
parameter, not prose; the mandatory 6-step procedure plus "investigate
fully even when the ticket looks simple" forces four tool calls on a
"where's my package" ticket.
...
-After any refund or escalation, verify twice before submitting: re-fetch
-the order, re-check every figure in your reply against the fresh lookup,
-and review the reply a second time for errors.
+Before submitting a refund or an escalation, re-fetch the order and confirm
+every figure in your reply matches the fresh lookup.
```
O comando então propõe suas edições como um diff (um trecho mostrado) e lista o que deliberadamente deixou intacto: a janela de reembolso, o requisito de tom e o padrão de qualidade. Você revisa um patch, não uma reescrita.
A Anthropic mediu o efeito em uma avaliação de central de suporte[14](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), em duas migrações entre modelos anteriores:
* Do Claude Opus 4.8 para o Claude Opus 5, prompts escritos para o modelo mais antigo custaram mais por ticket no modelo mais novo, sem mudança na precisão.
* Executar a auditoria sobre os mesmos prompts tornou o Claude Opus 5 tanto mais barato do que a versão não auditada quanto mais preciso, um ganho fora do ruído.
* Do Claude Sonnet 4.6 para o Claude Sonnet 5, a auditoria reduziu o custo por ticket com a mesma precisão.
Os dois tipos de texto obsoleto têm custos diferentes:
* Instruções que o novo modelo segue literalmente demais custam dinheiro: remover "verifique duas vezes" reduziu o custo por ticket do Claude Opus 5, e remover "seja o mais minucioso possível" o reduziu quase na mesma medida.
* Texto que não se encaixa mais no modelo custa precisão: uma configuração de pensamento desativada, regras contraditórias e um rascunho feito à mão que conflita com o próprio pensamento do modelo restauraram, cada um, a precisão no Claude Opus 5 quando removidos.
Os mesmos padrões tendem a aparecer em descrições de ferramentas e skills, que também vale a pena auditar.
## Troque custo por inteligência
Essas alavancas definem onde um único modelo fica entre custo e inteligência: escolha de modelo, esforço, reexecução de falhas em uma configuração mais alta, os orçamentos e limites dentro dos quais ele trabalha e se ele consegue ver quanto tempo passou. Comece com uma varredura de esforço no seu modelo atual ([Ajuste o esforço](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort)). Do menor para o maior custo e capacidade, os modelos atuais são Claude Haiku 5.5, Claude Sonnet 5.5, Claude Opus 5.5 e Claude Fable 5.1 (o modelo de fronteira); a [Visão geral dos modelos](https://platform.claude.com/docs/pt-BR/models/overview) traz a linha completa e os preços.
### Compare modelos pelo custo por tarefa
Compare modelos pelo custo por tarefa concluída, não por token, porque você paga por tarefas concluídas. Para a maioria das cargas de trabalho de agentes, comece com o Claude Opus 5.5 no seu esforço padrão (`medium`).
Um modelo mais capaz pode concluir uma tarefa com menos trabalho, o que pode compensar boa parte do preço mais alto por token. A Anthropic mediu isso no subconjunto do SWE-bench Pro[3](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), cujas pontuações não são comparáveis às do leaderboard público, com preços calculados da forma como um cliente é cobrado:
A tabela a seguir lista os resultados:
| Benchmark | Modelo | Esforço | Pontuação | Custo |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------- | ----------------- | --------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| Subconjunto do SWE-bench Pro[3](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Sonnet 5.5 | `high` (padrão) | 87,6% das tarefas resolvidas | $0,11 USD por tarefa resolvida |
| Subconjunto do SWE-bench Pro | Claude Opus 5.5 | `low` | 87,4% das tarefas resolvidas | $0,12 USD por tarefa resolvida |
| Subconjunto do SWE-bench Pro | Claude Opus 5.5 | `medium` (padrão) | 92,8% das tarefas resolvidas | $0,22 USD por tarefa resolvida |
| Subconjunto do SWE-bench Pro | Claude Fable 5.1 | `high` (padrão) | 92,3% das tarefas resolvidas (uma única execução) | $1,19 USD por tarefa resolvida |
| Benchmark interno de codificação agêntica[11](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Opus 5.5 | `medium` (padrão) | 86,6% | $0,84 USD por tentativa |
| Benchmark interno de codificação agêntica | Claude Fable 5.1 | `medium` | 84,2% (uma única execução) | $2,68 USD por tentativa |
| GPQA Diamond[9](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Haiku 5.5 | `medium` (padrão) | 85% de precisão, em comparação com 91% para cada um dos modelos Claude Opus 5.5 e Claude Sonnet 5.5 | Cerca de um vigésimo do custo do Claude Opus 5.5 por resposta correta e cerca de um décimo do custo do Claude Sonnet 5.5 |
| Conjunto de tarefas do Claude Managed Agents[25](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), 79 tarefas | Claude Haiku 5.5 | `medium` | 93% das tentativas aprovadas (uma única execução) | Cerca de $0,011 USD por tentativa aprovada |
**O que fazer.**
* Comece com o Claude Opus 5.5 no seu esforço padrão: no subconjunto do SWE-bench Pro, ele igualou o Claude Fable 5.1 no seu padrão, dentro do ruído entre execuções, por cerca de um quinto do custo por tarefa resolvida. O Opus 5.5 e o Fable 5.1 praticamente saturam o subconjunto do SWE-bench Pro. Use o Claude Fable 5.1 para raciocínio exigente e trabalho agêntico de longo horizonte, ou quando suas avaliações do Claude Opus 5.5 com esforço mais alto ainda ficarem aquém.
* No outro extremo, o Claude Haiku 5.5 é adequado para trabalho de alto volume e sensível à latência, com saídas verificáveis.
* Calcule o preço de cada candidato em custo por tarefa concluída no seu próprio tráfego, incluindo o Claude Opus 5.5 no seu esforço padrão e o modelo de fronteira com esforço reduzido. Cada um dos preços por token do Claude Opus 5.5, incluindo leituras de cache, é o dobro do Claude Sonnet 5.5, mas no subconjunto do SWE-bench Pro o Opus 5.5 em `low` resolveu aproximadamente a mesma proporção de tarefas que o Sonnet 5.5 no seu padrão, dentro do ruído entre execuções, por cerca de 7% a mais por tarefa resolvida.
* A classificação se inverte conforme a carga de trabalho, e nenhuma tabela de preços diz para qual lado, então meça na sua própria carga de trabalho. Em loops longos de pesquisa, o Claude Fable 5.1 pode fazer mais trabalho, não menos, e assim custar mais por tarefa (DeepResearch Bench II[7](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs)).
* Calcule o preço da cauda da sua carga de trabalho, não da mediana: compare modelos no décimo mais difícil das suas tarefas, não na tarefa típica.
A conta é decidida pelas tarefas em que o modelo mais barato falha, porque uma tarefa com falha ainda cobra seus tokens, depois a nova tentativa, depois o que quer que a falha custe mais adiante. A cauda também é para onde vai o dinheiro mesmo quando nada falha. Em uma execução do WideSearch[1](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) com 20 problemas, dois problemas concentraram 43% do gasto:
As [estratégias multimodelo](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#combine-models) existem para gastar inteligência de fronteira nessa cauda sem pagar preços de fronteira pelo restante.
### Faça upgrade do modelo
Se você está um ou dois modelos atrás, a alavanca mais barata é a string do modelo. Nas medições da Anthropic, cada modelo mais novo resolveu pelo menos tantas tarefas quanto o anterior, geralmente por um custo menor por tarefa resolvida. O gráfico mostra modelos Claude recentes no subconjunto do SWE-bench Pro[3](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), em que todos os modelos rodaram na mesma configuração de teste, e no Terminal-Bench 3[20](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs); a tabela lista o que cada upgrade mudou:
| Benchmark | Upgrade | Esforço | Pontuação | Custo |
| ------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------- | ---------------------------------------------- | ---------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| Subconjunto do SWE-bench Pro[3](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Sonnet 4.6 para Claude Sonnet 5 | Padrão | 5 pontos a mais | 16% a menos por tarefa resolvida |
| Subconjunto do SWE-bench Pro | Claude Sonnet 5 para Claude Sonnet 5.5 | Padrão | Cerca de 10 pontos a mais | 87% a menos por tarefa resolvida; 85% a menos aos preços do Claude Sonnet 5 |
| Subconjunto do SWE-bench Pro | Claude Opus 5 para Claude Opus 5.5 | Padrão: `high` para `medium` | Aproximadamente a mesma: de 91,9% para 92,8% das tarefas resolvidas | 78% a menos por tarefa resolvida; cerca de 69% a menos aos preços do Claude Opus 5 |
| Subconjunto do SWE-bench Pro | Claude Fable 5 para Claude Fable 5.1 | Padrão | Aproximadamente a mesma pontuação | 43% a menos por tarefa resolvida |
| DeepResearch Bench II[7](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Fable 5 para Claude Fable 5.1 | `high` | 2 a 3 pontos a mais nas 21 tarefas em que nenhuma tentativa foi interrompida | 46% a mais por tarefa em todas as 50 tarefas |
| DeepResearch Bench II | Claude Fable 5 para Claude Fable 5.1 | `low` | 2 a 3 pontos a mais nas 21 tarefas em que nenhuma tentativa foi interrompida | 94% a mais por tarefa em todas as 50 tarefas |
| Terminal-Bench 3[20](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Opus 4.7 para Claude Opus 4.8 | `high` | De 7% para 15% das tarefas resolvidas | De $183 USD para $63 USD por tarefa resolvida |
| Terminal-Bench 3 | Claude Opus 4.8 para Claude Opus 5 | `high` | De 15% para 41% das tarefas resolvidas | De $63 USD para $28 USD por tarefa resolvida, uma economia de 56% |
| Conjunto de tarefas do Claude Managed Agents[25](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Haiku 4.5 para Claude Haiku 5.5 | Conforme servido; `medium` no Claude Haiku 5.5 | De 62% para 93% das tentativas aprovadas, uma execução por modelo | De $0,041 USD para cerca de $0,010 USD em custo de tokens por tentativa; cerca de 84% a menos por tentativa aprovada |
**Quando compensa.**
* Onde modelos mais antigos já resolvem a maioria das tarefas, o custo de cada tentativa decide a economia: no subconjunto do SWE-bench Pro, o Claude Opus 5.5 pontua aproximadamente o mesmo que o Claude Opus 5 por 78% a menos por tarefa resolvida.
* Onde modelos mais antigos falham na maioria das vezes, a taxa de aprovação decide a economia: no Terminal-Bench 3[20](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), o upgrade do Claude Opus 4.8 para o Claude Opus 5 eleva as tarefas resolvidas de 15% para 41% e custa 56% a menos por tarefa resolvida.
* Meça o upgrade na sua própria carga de trabalho antes de presumir que ele economiza. A economia não é garantida: no DeepResearch Bench II[7](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), o Claude Fable 5.1 custa mais por tarefa do que o Claude Fable 5 porque o novo modelo faz mais trabalho por tarefa ali, embora os preços de entrada e saída sejam os mesmos e a leitura de cache seja 4x mais barata.
* Compare pelo custo por tarefa resolvida, não por token: o mesmo texto custa cerca de 30% mais tokens no Claude 4.7 e em modelos posteriores, então uma comparação por token faz os modelos mais novos parecerem mais caros por construção.
### Ajuste o esforço
Varie o esforço na sua própria carga de trabalho antes de adicionar um segundo modelo. Um esforço menor custa menos e costuma ser mais rápido, e quanta precisão ele sacrifica depende da tarefa: em codificação de longo horizonte, o esforço comprou precisão, e em tarefas de pesquisa comprou muito em uma medição e nada em outra. O parâmetro [`effort`](https://platform.claude.com/docs/pt-BR/build-with-claude/effort) controla quanto pensamento, chamadas de ferramentas e autoverificação o modelo faz; `high` é o padrão na maioria dos modelos, e `medium` no Claude Opus 5.5 e no Claude Haiku 5.5.
A tabela a seguir lista as medições da Anthropic em dois benchmarks com modelos atuais; pontuações e custos não são comparáveis entre os dois benchmarks. Os custos são por tarefa, não por tarefa resolvida como em [Compare modelos pelo custo por tarefa](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task). Cada pontuação agrega duas execuções no SWE-bench Pro e três no DeepResearch Bench II, a menos que sua célula diga o contrário:
| Benchmark | Modelo | Esforço | Pontuação | Custo por tarefa |
| ------------------------------------------------------------------------------------------------------------------------------------- | ---------------- | ----------------- | ------------------------------------------------- | ---------------- |
| Subconjunto do SWE-bench Pro[3](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Opus 5.5 | `low` | 87,4% das tarefas resolvidas | $0,11 USD |
| Subconjunto do SWE-bench Pro | Claude Opus 5.5 | `medium` (padrão) | 92,8% das tarefas resolvidas | $0,21 USD |
| Subconjunto do SWE-bench Pro | Claude Opus 5.5 | `high` | 95,3% das tarefas resolvidas | $0,29 USD |
| Subconjunto do SWE-bench Pro | Claude Opus 5.5 | `xhigh` | 96,7% das tarefas resolvidas (uma única execução) | $0,74 USD |
| DeepResearch Bench II[7](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Claude Fable 5.1 | `low` | Pontuação de rubrica de 66% | $4,48 USD |
| DeepResearch Bench II | Claude Fable 5.1 | `high` (padrão) | Pontuação de rubrica de 65% | $6,89 USD |
O gráfico a seguir mostra a precisão em relação ao custo por tarefa para o Claude Opus 5.5 no subconjunto do SWE-bench Pro[3](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs):
O gráfico a seguir mostra a pontuação de rubrica em relação ao custo por tarefa para o Claude Fable 5.1 no DeepResearch Bench II[7](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs):
**O que fazer.**
* Teste dois ou três níveis de esforço em uma amostra do seu próprio tráfego, cada um em uma sessão separada: alterar o esforço de nível superior no meio da sessão [invalida o cache](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#cache-repeated-context) e distorce a comparação. A curva é a linha de base que qualquer estratégia multimodelo precisa superar ([etapa 2 de medir na sua própria carga de trabalho](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#measure-on-your-own-workload)).
* Em codificação de longo horizonte, o esforço é uma troca real, que [executar novamente as falhas com esforço maior](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#re-run-failures-at-higher-effort) transforma de volta em economia. Em `medium`, o Claude Sonnet 5.5 pontuou cerca de 7 pontos a menos do que no seu padrão, `high`, no subconjunto do SWE-bench Pro[3](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) por cerca de 59% do custo por tarefa (2 execuções cada), e pontuou 62,7% em comparação com 77,8% no benchmark interno de codificação agêntica[11](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) (1 tentativa por tarefa).
* Em tarefas de pesquisa, meça o modelo que você coloca em produção. O Claude Fable 5.1 pontuou quase o mesmo de `low` a `high` no DeepResearch Bench II; o Claude Opus 5.5 pontuou 13,3 pontos a menos em `low` do que em `medium` no DRACO[21](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs). Os dois resultados vêm de modelos diferentes em benchmarks diferentes, então mostram que a resposta varia, não o porquê.
* Em `low`, a tarefa típica do Claude Opus 5.5 levou 84% menos tempo do que em `medium` no DRACO[21](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), 30% menos no HLE[22](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) e 47% menos em um conjunto interno de problemas de física[23](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), e pontuou 13,3, 3,4 e 14,0 pontos a menos (3, 3 e 4 tentativas por tarefa).
* Em um benchmark interno de busca de defeitos para trabalhos maiores do que uma "context window" (janela de contexto)[8](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), o Claude Fable 5.1 levou 15,2, 17,5 e 19,9 horas por execução em `low`, `medium` e `high` (3 execuções cada). Para economizar tempo, compare também um esforço menor com as duas mudanças em [Mostre ao modelo o tempo decorrido](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time): o esforço `low` economizou mais tempo, e as mudanças preservaram mais da pontuação.
### Reexecute falhas com esforço maior
Quando o resultado de uma tarefa é verificável, a política mais barata na curva de esforço não é uma configuração fixa: execute todas as tarefas em uma configuração baixa e reexecute apenas as falhas em uma mais alta.
A Anthropic calculou essa política tarefa por tarefa a partir das execuções de esforço do Claude Opus 5.5 no subconjunto do SWE-bench Pro[3](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) em [Ajuste o esforço](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort):
Na tabela a seguir, os custos de nova execução incluem as tentativas baratas que falharam:
| Política | Tarefas resolvidas | Custo por tarefa |
| ----------------------------------------------- | ------------------ | ------------------ |
| `low`, falhas executadas novamente em `high` | Cerca de 97% | Cerca de $0,17 USD |
| `medium`, falhas executadas novamente em `high` | Cerca de 97% | Cerca de $0,24 USD |
| Tudo em `high` | 95,3% | $0,29 USD |
* Em `low`, 13% das tarefas falharam. Com essas executadas novamente em `high`, a taxa de aprovação foi ligeiramente maior do que com tudo em `high`, por pouco mais da metade do custo.
* Use essa política pela economia, não pelo ganho. A maior parte do pequeno ganho vem da segunda tentativa: executar novamente as falhas de uma execução em `high` também em `high` pontua aproximadamente o mesmo, por mais dinheiro.
Duas condições se aplicam. Primeiro, você precisa de um sinal de falha (aqui, os próprios testes do benchmark); um verificador que aprova trabalho ruim deixa essas falhas passarem. Segundo, cada falha na primeira passagem leva o tempo de relógio de duas execuções, então a economia é paga em latência nas falhas.
### Defina orçamentos e limites de saída
Dois controles fazem dois trabalhos diferentes: um orçamento de sessão limita o que uma sessão do Claude Managed Agents pode gastar, e `max_tokens` limita o tamanho de uma resposta. Defina cada um onde se aplica, com um [limite de gastos do workspace](https://platform.claude.com/docs/pt-BR/api/rate-limits#setting-lower-limits-for-workspaces) como proteção final.
* **Orçamentos de sessão no Claude Managed Agents** são uma parada rígida nos gastos. Um [orçamento de sessão](https://platform.claude.com/docs/pt-BR/managed-agents/budgets) é um limite em dólares sobre o [custo de tabela](https://platform.claude.com/docs/pt-BR/managed-agents/budgets#how-list-cost-is-measured) de uma sessão, que a plataforma mede para tokens, pesquisas na web e tempo de execução da sessão.
* No limite, ou um pouco além dele, a sessão é pausada com `stop_reason: budget_reached`; aumentar o orçamento a retoma. Ele é aplicado pela plataforma e funciona em qualquer modelo com preço de tabela. As implantações aplicam o mesmo orçamento a cada sessão que iniciam.
* **`max_tokens`** limita uma única resposta, de forma invisível para o modelo, então reduzi-lo não faz o modelo economizar. Os turnos que precisavam do espaço são descartados e ainda assim cobrados. Tentar novamente as tentativas limitadas raramente ajuda: com o mesmo limite, a maioria falha de novo, e com um limite maior você também paga pela tentativa desperdiçada.
* Defina `max_tokens` como 64.000 para trabalho agêntico, ou como 128.000, o máximo, quando uma única tentativa interrompida for custosa. Faça [streaming das respostas](https://platform.claude.com/docs/pt-BR/build-with-claude/streaming) desse tamanho, trate [`stop_reason: max_tokens`](https://platform.claude.com/docs/pt-BR/build-with-claude/handling-stop-reasons#max-tokens) como uma falha e economize com o esforço, que o modelo consegue ver.
A tabela a seguir mostra o que cada modelo resolveu e quanto custou uma tarefa resolvida em cada limite em um benchmark interno de tarefas em repositórios[12](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), uma tentativa por tarefa, cada modelo no seu esforço padrão. As linhas em 16.384 são a média de duas execuções, e as demais linhas são uma execução cada:
| Modelo | `max_tokens` | Tentativas encerradas pelo limite | Tarefas resolvidas | Custo por tarefa resolvida |
| ---------------- | ------------ | --------------------------------- | ------------------ | ---------------------------- |
| Claude Opus 5.5 | 16.384 | 25% | 57,6% | $5,38 USD a preços de tabela |
| Claude Opus 5.5 | 64.000 | 0% | 75,6% | $5,38 USD a preços de tabela |
| Claude Opus 5.5 | 128.000 | 0% | 68,9% | $5,94 USD a preços de tabela |
| Claude Fable 5.1 | 16.384 | 43% | 36,3% | $21,37 USD conforme cobrado |
| Claude Fable 5.1 | 64.000 | 0% | 58,5% | $21,53 USD conforme cobrado |
| Claude Fable 5.1 | 128.000 | 1% | 60,0% | $21,74 USD conforme cobrado |
**Claude Opus 5.5 em 64.000 e 128.000:** Nenhuma tentativa foi interrompida em nenhum dos dois limites, então o limite não explica por que essas duas linhas diferem em tarefas resolvidas ou em custo por tarefa resolvida. Cada linha é uma execução.
Compare os limites dentro de cada modelo. Os dois modelos foram executados com um mês de diferença, e seus custos são calculados em bases diferentes.
Peça respostas mais curtas. Tokens de saída custam cinco vezes os tokens de entrada no Claude Haiku 5.5, Claude Sonnet 5.5, Claude Opus 5.5, e Claude Fable 5.1, e em um loop de agente cada token que o modelo escreve volta como entrada em todos os turnos seguintes, então você paga por uma resposta longa repetidas vezes.
Em uma medição em um modelo anterior[26](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), a Anthropic executou um pequeno agente que faz a triagem de relatórios de bugs ([Corte tokens de entrada e de contexto](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens)) sob três instruções de resposta final, três execuções cada, com o mesmo modelo e as mesmas ferramentas:
* A original pedia duas linhas.
* A variante mais curta pedia uma.
* A variante mais longa pedia um memorando com seis seções com títulos.
O gráfico a seguir mostra o custo por execução de cada formato:
Os três pontuaram dentro do ruído entre execuções uns dos outros em relação aos rótulos corretos, então os formatos diferem muito mais no que você paga do que no que acertam. Peça a resposta que você vai ler, não a que parece minuciosa.
Nas tarefas internas em repositórios[12](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), quase todos os turnos terminam muito abaixo de um limite de 16.384 tokens. O raro turno longo é o que um limite maior compra:
### Mostre ao modelo o tempo decorrido
Para fazer um agente terminar mais cedo e custar menos, diga a ele que o tempo importa e mostre o tempo decorrido em cada requisição. Na medição da Anthropic, as duas mudanças reduziram o tempo de um único agente Claude Opus 5.5 com esforço `medium` em 47% e seu custo em 60% na tarefa de pesquisa típica (mediana) do DRACO[21](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), e sua pontuação média foi 4,1 pontos menor.
No HLE[22](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) e em um conjunto interno de física[23](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), a tarefa típica levou 14% e 7% menos tempo, e a pontuação de física foi 3,0 pontos menor. Reduzir o esforço para `low` economizou mais tempo e custo do que as mudanças, e perdeu mais pontuação (referência 21). Verifique a pontuação nas suas próprias tarefas antes de adotar as mudanças.
Para código funcional, consulte a receita do Claude Cookbook [Multi-agent teams under latency pressure and budgets](https://github.com/anthropics/claude-cookbooks/blob/main/patterns/agents/latency_multi_agent.ipynb), que aplica as duas mudanças a uma equipe de agentes. Para dizer que o tempo importa no prompt do sistema, consulte [Sinais de tempo para harnesses multiagente](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#time-signals-for-multi-agent-harnesses).
O gráfico a seguir também mostra uma equipe, cujo agente líder raramente iniciava auxiliares, e um único agente com esforço `low`:
## Combine modelos
Ajuste um modelo antes de adicionar um segundo: primeiro varie o esforço no seu modelo atual, porque a maioria das cargas de trabalho termina aí, e se a variação mostrar uma lacuna, calcule o preço do modelo mais forte sozinho com esforço baixo. Construa um pareamento apenas se ele superar toda a curva de pontuação em relação ao gasto do modelo único. Os resultados multimodelo nesta página foram avaliados em relação ao mesmo modelo com esforço menor e em relação ao modelo imediatamente inferior rodando sozinho, que é a comparação a fazer na sua própria carga de trabalho.
A tabela a seguir compara as duas estratégias:
| Estratégia | Fluxo de controle | Papel do modelo de fronteira | Adequada para | O custo de fronteira escala com |
| ---------------- | ---------------------------------------------------------------- | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
| **Advisor** | O modelo menor executa o loop, escala sob demanda | Consultado para planos e correções | Trabalho serial que é difícil em alguns pontos, como os muitos turnos de um agente de codificação entre algumas decisões reais | Com que frequência o executor fica travado |
| **Orquestrador** | O modelo de fronteira executa o loop, delega o trabalho em massa | Planeja, despacha e sintetiza | Trabalho que se espalha por arquivos, documentos ou casos genuinamente independentes, especialmente mais de uma janela de contexto deles | Quão difícil é coordenar as partes |
### Estratégia advisor: escale decisões difíceis
Um advisor só pode ajudar quando o executor o consulta.
Nas medições da Anthropic em modelos atuais, o único pareamento cujo executor consultou com frequência, em um benchmark de codificação, pontuou 1,7 ponto a mais do que o executor sozinho com o mesmo esforço, no limite do ruído entre execuções, por cerca de 2,1 vezes o custo. Onde o executor raramente ou nunca consultou, o pareamento pontuou dentro do ruído entre execuções do executor sozinho, ou abaixo.
Para ativá-la, adicione a [ferramenta advisor](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/advisor-tool), um recurso beta, à sua requisição. No Claude Managed Agents, [dê um advisor à sessão](https://platform.claude.com/docs/pt-BR/managed-agents/multiagent-orchestration#give-the-session-an-advisor). Para o Claude Code, consulte [escalando decisões difíceis com a ferramenta advisor](https://code.claude.com/docs/en/advisor).
A tabela a seguir compara cada pareamento com seu executor sozinho com o mesmo esforço:
| Benchmark | Pontuação | Custo | Advisor consultado |
| --------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------- |
| Benchmark interno de codificação agêntica[11](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) | 90,1%, 1,7 ponto acima do executor sozinho, no limite do ruído entre execuções | $2,92 USD por tentativa, cerca de 2,1 vezes o executor sozinho | Cerca de 1,4 vez por tentativa; 4% das tentativas não receberam conselho |
| GPQA Diamond[9](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) | Dentro do ruído entre execuções do executor sozinho | 12% a mais por pergunta para o Claude Haiku 5.5, 25% a mais para o Claude Sonnet 5.5 | Em nenhuma das 198 perguntas, em duas execuções cada; nenhum prompt do sistema pedia consultas |
| Chartography[13](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) | 61,7, 7 pontos abaixo do executor sozinho e além do ruído entre execuções | Aproximadamente o mesmo que o executor sozinho | Em 1 de 300 tarefas |
* **Benchmark interno de codificação agêntica.** Claude Opus 5.5 em `high`, com um advisor Claude Fable 5.1.
* **GPQA Diamond.** Claude Haiku 5.5 ou Claude Sonnet 5.5 no padrão de cada modelo (`medium` e `high`), com um advisor Claude Opus 5.5.
* **Chartography.** Claude Opus 5.5 em `low`, com um advisor Claude Fable 5.1.
O advisor só pode transferir capacidade que falta ao executor: no GPQA Diamond, o Claude Sonnet 5.5 sozinho empatou com o Claude Opus 5.5 sozinho em 91% com recusas contadas como erradas, mas apenas porque o Opus 5.5 recusou seis perguntas de biologia por execução, em comparação com uma do Sonnet 5.5. Nas perguntas que cada um respondeu, o Opus 5.5 liderou por cerca de 2 pontos.
No benchmark de codificação, o ganho do pareamento está no limite do ruído entre execuções, e ele fica aproximadamente sobre a própria curva de esforço do Claude Opus 5.5, então o advisor comprou aproximadamente o que mais esforço faz. O gráfico a seguir mostra o pareamento em relação a essa curva e à do Claude Fable 5.1 de agosto:
**O que fazer.**
* Meça a taxa de consulta nas suas próprias tarefas. A definição da ferramenta advisor, cerca de 1.000 tokens de prompt por requisição, adiciona custo mesmo quando o executor nunca consulta. Com [cache de prompt](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#cache-repeated-context), um loop de agente com vários turnos paga pela definição ao preço de leitura de cache após a primeira requisição, então essa sobrecarga importa mais para tarefas curtas de uma única requisição.
* Se o executor raramente consulta, consulte [Prompts para tarefas de codificação e de agente](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/advisor-tool#prompting-for-coding-and-agent-tasks) para prompts do sistema que pedem consultas, e meça novamente depois de adicionar um. Em 20 problemas do SWE-bench Pro[3](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), o prompt sugerido não fez diferença clara para o Claude Sonnet 5.5.
* Restaure o esforço do executor se a taxa de consulta despencar. Em medições em modelos anteriores, um pareamento que consultava na maioria das tarefas com o esforço padrão passou a consultar em poucas quando o esforço foi reduzido, e então pontuou abaixo do executor sozinho (SWE-bench Pro[3](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs)).
* Verifique novamente a cada lançamento de modelo, porque os lançamentos alteram tanto a diferença de capacidade quanto a relação de preços.
### Estratégia de orquestrador: delegue o trabalho em massa
A delegação economizou dinheiro em apenas duas situações, em medições com workers no Claude Sonnet 5, um modelo anterior:
* Trabalho rotineiro com uma longa cauda de custo (uma fatia fácil do BrowseComp[4](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs))
* Trabalho maior do que uma janela de contexto (um benchmark interno de busca de defeitos[8](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs))
Quando o trabalho é uma única cadeia dependente, ou cabe em um único contexto sem uma longa cauda de custo, o modelo do orquestrador sozinho com esforço menor saiu na frente em todos os casos medidos, também em modelos anteriores (o conjunto mais difícil do BrowseComp e o DeepWideSearch[6](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs)); trabalhos externos independentes relatam o mesmo padrão[5](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs).
Para construir um orquestrador, use a [orquestração multiagente](https://platform.claude.com/docs/pt-BR/managed-agents/multiagent-orchestration) no Claude Managed Agents: configure um agente orquestrador e agentes workers que ele pode chamar, cada um com seu próprio modelo.
A [Matriz de seleção de modelos](https://platform.claude.com/docs/pt-BR/about-claude/models/choosing-a-model#model-selection-matrix) lista o Claude Haiku 5.5 para tarefas de subagentes; antes de usá-lo como worker, [meça-o na sua própria carga de trabalho](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#measure-on-your-own-workload).
O gráfico a seguir mostra as configurações do benchmark de busca de defeitos por custo e pontuação:
**O que fazer.**
* **Trabalho rotineiro com uma longa cauda de custo:** meça este caso primeiro, tanto pela precisão quanto pelo custo. A medição por trás dele cobre apenas problemas que a configuração delegada respondeu corretamente em todas as execuções (referência 4).
* **Trabalho maior do que uma janela de contexto:** delegue partições aos workers. Reduzir o esforço não ajuda, porque a conta é a própria leitura: no benchmark de busca de defeitos[8](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), o Claude Fable 5.1 sozinho custou de $468 USD a $552 USD por execução nas suas três configurações de esforço e levou de 15 a 20 horas. Com workers de modelos anteriores, a delegação custou menos e terminou mais cedo, com uma pontuação menor.
## Meça na sua própria carga de trabalho
Meça na sua própria carga de trabalho: os números nesta página refletem os preços de tabela no momento da medição e vão variar à medida que modelos e preços mudam. Sua taxa de escalonamento, a clareza com que as tarefas se dividem e o comprimento das transcrições também os alteram. O método permanece o mesmo:
1. Extraia algumas tarefas dos logs de produção, ponderadas como o tráfego real, e [escreva verificações de resultado](https://platform.claude.com/docs/pt-BR/test-and-evaluate/develop-tests) para cada uma: testes passam, ticket fechado, contagem de linhas correta. Registre o custo por tarefa ao lado da pontuação.
2. Estabeleça a linha de base dos níveis de modelo em todos os níveis de esforço, não apenas no padrão, e plote a pontuação em relação ao gasto. Uma configuração multimodelo precisa superar a curva inteira do modelo único.
3. Se a curva mostrar uma lacuna que o esforço não consegue fechar, adicione a estratégia multimodelo adequada e execute o conjunto de testes novamente.
4. Execute a vencedora em modo sombra em uma fatia do tráfego antes da migração e, depois, mantenha o conjunto de testes em execução.
**Como precificar uma tarefa.** O `usage` de cada resposta tem cinco contagens de tokens precificadas. Precifique cada uma pela sua própria tarifa: entrada sem cache, gravações de cache de 5 minutos e de 1 hora a 1,25x e 2x o preço de entrada, leituras de cache e saída. Some-as em todas as requisições da tarefa (a [API de Uso e Custo](https://platform.claude.com/docs/pt-BR/manage-claude/usage-cost-api) informa o agregado). No Claude Haiku 5.5, precifique cada requisição pelas tarifas correspondentes ao comprimento do seu prompt, contando leituras e gravações de cache (consulte [Preços de contexto longo](https://platform.claude.com/docs/pt-BR/about-claude/pricing#long-context-pricing)).
O exemplo a seguir calcula o custo de uma requisição com os preços de tabela do Claude Opus 5.5. Altere os três preços para outro modelo:
```bash cURL
INPUT_PER_MTOK=4.00 # Claude Opus 5.5
CACHE_READ_PER_MTOK=0.20 # 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
OUTPUT_PER_MTOK=20.00
response=$(curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 1024,
"messages": [{"role": "user", "content": "Hello, Claude"}]
}')
cost=$(jq -r --argjson in_price "$INPUT_PER_MTOK" --argjson read_price "$CACHE_READ_PER_MTOK" --argjson out_price "$OUTPUT_PER_MTOK" '
.usage
| (.input_tokens * $in_price
+ (.cache_creation.ephemeral_1h_input_tokens // 0) * $in_price * 2.00 # 1-hour cache write
+ (.cache_creation.ephemeral_5m_input_tokens // 0) * $in_price * 1.25 # 5-minute cache write
+ (.cache_read_input_tokens // 0) * $read_price # cache read
+ .output_tokens * $out_price) / 1e6
' <<<"$response")
printf 'Request cost: $%.6f\n' "$cost"
```
```bash CLI
INPUT_PER_MTOK=4.00 # Claude Opus 5.5
CACHE_READ_PER_MTOK=0.20 # 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
OUTPUT_PER_MTOK=20.00
USAGE=$(ant messages create \
--model claude-opus-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello, Claude"}' \
--transform usage)
COST=$(jq -r --argjson in_price "$INPUT_PER_MTOK" --argjson read_price "$CACHE_READ_PER_MTOK" --argjson out_price "$OUTPUT_PER_MTOK" '
(.input_tokens * $in_price
+ (.cache_creation.ephemeral_1h_input_tokens // 0) * $in_price * 2.00 # 1-hour cache write
+ (.cache_creation.ephemeral_5m_input_tokens // 0) * $in_price * 1.25 # 5-minute cache write
+ (.cache_read_input_tokens // 0) * $read_price # cache read
+ .output_tokens * $out_price) / 1e6
' <<<"$USAGE")
printf 'Request cost: $%.6f\n' "$COST"
```
```python Python
INPUT_PER_MTOK = 4.00 # Claude Opus 5.5
# 0,05x o preço de entrada no Claude Opus 5.5; o multiplicador varia por modelo
CACHE_READ_PER_MTOK = 0.20
OUTPUT_PER_MTOK = 20.00
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello, Claude"}],
)
usage = response.usage
cache_writes = usage.cache_creation
writes_1h = cache_writes.ephemeral_1h_input_tokens if cache_writes else 0
writes_5m = cache_writes.ephemeral_5m_input_tokens if cache_writes else 0
cost = (
usage.input_tokens * INPUT_PER_MTOK
# Gravações em cache de 1 hora custam 2x o preço de entrada, de 5 minutos 1,25x; leituras ao preço de leitura de cache.
+ writes_1h * INPUT_PER_MTOK * 2.0
+ writes_5m * INPUT_PER_MTOK * 1.25
+ (usage.cache_read_input_tokens or 0) * CACHE_READ_PER_MTOK
+ usage.output_tokens * OUTPUT_PER_MTOK
) / 1_000_000
print(f"Request cost: ${cost:.6f}")
```
```typescript TypeScript
const INPUT_PER_MTOK = 4.0; // Claude Opus 5.5
const CACHE_READ_PER_MTOK = 0.2; // 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
const OUTPUT_PER_MTOK = 20.0;
const client = new Anthropic();
const response = await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello, Claude" }]
});
const usage = response.usage;
const cost =
(usage.input_tokens * INPUT_PER_MTOK +
(usage.cache_creation?.ephemeral_1h_input_tokens ?? 0) * INPUT_PER_MTOK * 2 + // 1-hour cache write
(usage.cache_creation?.ephemeral_5m_input_tokens ?? 0) * INPUT_PER_MTOK * 1.25 + // 5-minute cache write
(usage.cache_read_input_tokens ?? 0) * CACHE_READ_PER_MTOK + // cache read
usage.output_tokens * OUTPUT_PER_MTOK) /
1_000_000;
console.log(`Request cost: $${cost.toFixed(6)}`);
```
```csharp C#
const double InputPerMtok = 4.00; // Claude Opus 5.5
const double CacheReadPerMtok = 0.20; // 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
const double OutputPerMtok = 20.00;
AnthropicClient client = new();
var response = await client.Messages.Create(
new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 1024,
Messages = [new() { Role = Role.User, Content = "Hello, Claude" }],
}
);
var usage = response.Usage;
double cost =
(
usage.InputTokens * InputPerMtok
+ (usage.CacheCreation?.Ephemeral1hInputTokens ?? 0) * InputPerMtok * 2.00 // 1-hour cache write
+ (usage.CacheCreation?.Ephemeral5mInputTokens ?? 0) * InputPerMtok * 1.25 // 5-minute cache write
+ (usage.CacheReadInputTokens ?? 0) * CacheReadPerMtok // cache read
+ usage.OutputTokens * OutputPerMtok
) / 1_000_000;
Console.WriteLine($"Request cost: ${cost:F6}");
```
```go Go
const (
inputPerMTok = 4.00 // Claude Opus 5.5
cacheReadPerMTok = 0.20 // 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
outputPerMTok = 20.00
)
// ...
client := anthropic.NewClient()
response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
},
})
if err != nil {
log.Fatal(err)
}
usage := response.Usage
cost := (float64(usage.InputTokens)*inputPerMTok +
float64(usage.CacheCreation.Ephemeral1hInputTokens)*inputPerMTok*2.00 + // 1-hour cache write
float64(usage.CacheCreation.Ephemeral5mInputTokens)*inputPerMTok*1.25 + // 5-minute cache write
float64(usage.CacheReadInputTokens)*cacheReadPerMTok + // cache read
float64(usage.OutputTokens)*outputPerMTok) / 1_000_000
fmt.Printf("Request cost: $%.6f\n", cost)
```
```java Java
static final double INPUT_PER_MTOK = 4.00; // Claude Opus 5.5
static final double CACHE_READ_PER_MTOK = 0.20; // 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
static final double OUTPUT_PER_MTOK = 20.00;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
Message response = client.messages().create(MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(1024)
.addUserMessage("Hello, Claude")
.build());
Usage usage = response.usage();
long writes1h = usage.cacheCreation().map(CacheCreation::ephemeral1hInputTokens).orElse(0L);
long writes5m = usage.cacheCreation().map(CacheCreation::ephemeral5mInputTokens).orElse(0L);
double cost = (usage.inputTokens() * INPUT_PER_MTOK
+ writes1h * INPUT_PER_MTOK * 2.00 // 1-hour cache write
+ writes5m * INPUT_PER_MTOK * 1.25 // 5-minute cache write
+ usage.cacheReadInputTokens().orElse(0L) * CACHE_READ_PER_MTOK // cache read
+ usage.outputTokens() * OUTPUT_PER_MTOK) / 1_000_000;
IO.println("Request cost: $%.6f".formatted(cost));
}
```
```php PHP
const INPUT_PER_MTOK = 4.00; // Claude Opus 5.5
const CACHE_READ_PER_MTOK = 0.20; // 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
const OUTPUT_PER_MTOK = 20.00;
$client = new Client();
$response = $client->messages->create(
model: 'claude-opus-5-5',
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello, Claude']],
);
$usage = $response->usage;
$cost = (
$usage->inputTokens * INPUT_PER_MTOK
+ ($usage->cacheCreation?->ephemeral1hInputTokens ?? 0) * INPUT_PER_MTOK * 2.00 // 1-hour cache write
+ ($usage->cacheCreation?->ephemeral5mInputTokens ?? 0) * INPUT_PER_MTOK * 1.25 // 5-minute cache write
+ ($usage->cacheReadInputTokens ?? 0) * CACHE_READ_PER_MTOK // cache read
+ $usage->outputTokens * OUTPUT_PER_MTOK
) / 1_000_000;
printf("Request cost: \$%.6f\n", $cost);
```
```ruby Ruby
INPUT_PER_MTOK = 4.00 # Claude Opus 5.5
CACHE_READ_PER_MTOK = 0.20 # 0.05x the input price on Claude Opus 5.5; the multiplier differs by model
OUTPUT_PER_MTOK = 20.00
client = Anthropic::Client.new
response = client.messages.create(
model: "claude-opus-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello, Claude" }]
)
usage = response.usage
cost = (
usage.input_tokens * INPUT_PER_MTOK +
usage.cache_creation&.ephemeral_1h_input_tokens.to_i * INPUT_PER_MTOK * 2.00 + # 1-hour cache write
usage.cache_creation&.ephemeral_5m_input_tokens.to_i * INPUT_PER_MTOK * 1.25 + # 5-minute cache write
usage.cache_read_input_tokens.to_i * CACHE_READ_PER_MTOK + # cache read
usage.output_tokens * OUTPUT_PER_MTOK
) / 1_000_000
puts format("Request cost: $%.6f", cost)
```
**O que verificar.**
* **Participação das leituras de cache.** Em loops de agente, a maioria dos tokens de entrada deve ser leituras de cache. Se `cache_read_input_tokens` for pequeno em comparação com `input_tokens` mais `cache_creation_input_tokens`, verifique se o cache está ativo e se o prefixo permanece o mesmo entre as requisições.
* **Ferramenta advisor e compactação.** Quando a [ferramenta advisor](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/advisor-tool#usage-and-billing) ou a [compactação](https://platform.claude.com/docs/pt-BR/build-with-claude/compaction-threshold#understanding-usage) está habilitada, alguns tokens são informados apenas em `usage.iterations` e não nos totais de nível superior. Em vez disso, some sobre `usage.iterations` e precifique as entradas `advisor_message` pelas tarifas do modelo advisor.
A tabela a seguir lista as alavancas na ordem em que você deve experimentá-las. Os números vêm dos próprios testes da Anthropic; cada seção vinculada e suas referências informam o modelo e o método:
| Alavanca | Economia nos testes da Anthropic | Custo de qualidade | Latência | Onde |
| ---------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Cache de prompt | Custo reduzido por um fator de 2,7 a 5,5 em um agente de pesquisa, e de 83% a 86% em um pequeno agente de triagem | Nenhum | Mais rápido | [Armazene contexto repetido em cache](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#cache-repeated-context) |
| Duração de cache de 1 hora | Com 1 turno em 10 após uma pausa, o padrão de 5 minutos custou 54% a mais; com 1 em 20, aproximadamente o mesmo | Nenhum | Permaneceu aquecido após uma pausa[16](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs) | [Escolha a duração do cache](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#pick-the-cache-duration) |
| Redução da entrada | Mais 21% a 26% a menos na conta de um pequeno agente de triagem | Nenhum | Neutra | [Corte tokens de entrada e de contexto](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) |
| Remoção de resultados de ferramentas obsoletos nos limites das tarefas | 39% em uma tarefa longa de agente; nada nas curtas. Nos modelos citados nessa seção, use a compactação em vez disso | Nenhum medido | Neutra | [Gerencie o ciclo de vida do contexto](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#manage-the-context-lifecycle) |
| Busca de ferramentas | 45% com 500 definições de ferramentas anexadas; 20% ao adiar o conjunto de ferramentas de um servidor MCP do GitHub | Nenhum | Neutra | [Corte tokens de entrada e de contexto](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) |
| Arquivos de dados por meio de execução de código | 92% em uma tarefa de dados com 25 perguntas | Um ganho: 25 de 25 corretas em vez de 7 | Mais rápido | [Corte tokens de entrada e de contexto](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) |
| Batch API | 50% | Nenhum | Resultados em até 24 horas | [Coloque em lote o trabalho que pode esperar](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#batch-work-that-can-wait) |
| Auditoria de prompts em relação ao modelo atual | 14% em ambos os upgrades de modelo testados | Nenhum; um ganho em um deles | Mais rápido (menos rodadas de ferramentas) | [Audite prompts em relação ao modelo atual](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#audit-prompts-against-the-current-model) |
| Atualizar o modelo | Geralmente menos por tarefa resolvida: até 87% a menos em um benchmark de codificação | Nenhum; um ganho na maioria | Neutra | [Faça upgrade do modelo](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#upgrade-the-model) |
| Reduzir o esforço | Em tarefas longas de codificação, `medium` custou cerca de 30% a 52% menos que `high`, e `low` cerca de dois terços a menos | Até 15 pontos a menos, dependendo da tarefa; nenhum em um agente de pesquisa | Mais rápido | [Ajuste o esforço](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#tune-effort) |
| Reexecutar falhas | Cerca de 40% a menos do que executar tudo em `high`, com a mesma taxa de aprovação ou um pouco melhor | Nenhum | Uma segunda tentativa nas tarefas que falham | [Reexecute falhas com esforço maior](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#re-run-failures-at-higher-effort) |
| Pedir respostas mais curtas | Cerca de 13% a menos, com 39% menos tokens de saída | Nenhum | Mais rápido | [Defina orçamentos e limites de saída](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps) |
| Aumentar `max_tokens` | Nenhuma: o custo por tarefa resolvida permaneceu praticamente o mesmo | Um ganho: até 22 pontos a mais de tarefas resolvidas em um benchmark de codificação; nenhum em outro | Neutra | [Defina orçamentos e limites de saída](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#set-budgets-and-output-caps) |
| Advisor | Nenhuma: cerca de 2,1 vezes o custo do modelo sozinho, em um benchmark de codificação | Em codificação, um pequeno ganho que pode ser acaso; na leitura de gráficos, uma perda | Cerca de 1,4 chamada extra por tentativa, em codificação | [Estratégia advisor](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#advisor-strategy-escalate-hard-decisions) |
| Orquestrador | Cerca de metade do custo do modelo do orquestrador sozinho, em trabalhos maiores que uma janela de contexto; em trabalhos rotineiros, meça primeiro | 10 a 12 pontos a menos nesse trabalho | Muito mais rápida nesse trabalho | [Estratégia de orquestrador](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#orchestrator-strategy-delegate-bulk-work) |
### Automatize a busca com a skill Claude API
Execute o comando `cost-optimize` da [skill Claude API](https://platform.claude.com/docs/pt-BR/agents-and-tools/agent-skills/claude-api-skill) antes de buscar economias. Ele traça o perfil de para onde seus tokens vão e aplica as alavancas em ordem, começando pelo cache. Em seguida, execute `/claude-api hillclimb` no diretório que contém sua avaliação.
A Anthropic mediu a primeira alavanca do `cost-optimize` e duas buscas no tau2-bench retail[24](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#refs), todas em modelos anteriores. Os breakpoints de cache que o `cost-optimize` produziu reduziram o custo por tarefa, e a taxa de aprovação caiu menos do que a variação entre execuções idênticas.
Uma busca encontrou uma configuração mais barata ao reduzir o esforço e descer um nível de modelo. Sua taxa de aprovação permaneceu dentro da faixa definida antes da busca por uma fração de tarefa, e terminou abaixo do piso mais rigoroso que a busca usou para seus próprios veredictos. Uma segunda busca, iniciada a partir do modelo de menor custo em seu esforço padrão, não manteve nada. A referência 24 traz os números e quanto custou executar cada busca.
O gráfico a seguir plota cada etapa da primeira busca:
Duas configurações determinam se você pode confiar na resposta da busca:
* **Reserve uma divisão que a busca nunca lê.** A busca avalia a adoção ali, de modo que a confirmação detecta uma mudança que se ajusta apenas às tarefas que a busca viu, como aconteceu com as edições de prompt (referência 24).
* **Repita a linha de base antes da primeira mudança.** Execuções idênticas de uma mesma configuração inicial diferiram em várias tarefas nessas medições (referência 24). As repetições dão ao critério de adoção da busca uma barra de ruído.
## Benchmarks referenciados
Exceto quando uma referência indicar o contrário, as medições são execuções internas da Anthropic desses benchmarks. Salvo indicação em contrário, os custos estão em USD aos preços de tabela vigentes quando cada benchmark foi executado; os números do Claude Sonnet 5 usam $2 USD e $10 USD por milhão de tokens de entrada e de saída. Os números do Claude Sonnet 5.5 das execuções de 24 de setembro de 2026 usam os mesmos preços de entrada e saída e seu preço atual de leitura de cache, $0,10 USD por milhão de tokens, em vez do seu preço de lançamento de $0,20 USD, aplicados às contagens de tokens registradas em cada execução. Essas execuções usaram uma build de pré-lançamento do Claude Sonnet 5.5, e nenhuma tentativa nelas foi respondida por um modelo de fallback. Gráficos rotulados "notional USD" (USD nocional) precificam as contagens de tokens de cada requisição a essas taxas, em vez de reportar faturas.
1. **WideSearch:** Wong et al., "WideSearch: Benchmarking Agentic Broad Info-Seeking," arXiv:2508.07999, 2025. Tarefas amplas de pesquisa na web avaliadas pela completude e precisão de uma tabela com muitas linhas; 200 problemas, 3 execuções por configuração, executadas de 1 a 2 de agosto de 2026. Com o Claude Fable 5 neste benchmark, no DeepWideSearch (referência 6), no BrowseComp (referência 4) e no GDPval (referência 2), o esforço `low` abriu mão de 1 a 3 pontos em troca de um terço a metade a menos no custo por tarefa, `medium` igualou a precisão do padrão a cerca de 70% a 87% do seu custo, e o padrão não trouxe nenhum ganho mensurável sobre `medium` em nenhum dos quatro. O gráfico de concentração de custo é uma execução separada de 20 problemas, 3 execuções por problema, executada de 3 a 4 de agosto de 2026, com custos calculados a partir dos registros de faturamento por requisição. Ele cobre 59 das 60 execuções. A sexagésima, faturada em $10,91 USD do total de $432,31 USD, não tem custo registrado com seu resultado e não está incluída.
2. **GDPval:** OpenAI, "GDPval: Evaluating AI Model Performance on Real-World Economically Valuable Tasks," 2025. Entregáveis de trabalho do conhecimento avaliados com base em rubricas de tarefas; uma execução de 210 tarefas do conjunto gold publicado, uma tentativa por tarefa, realizada em 2 de agosto de 2026. Um modelo Claude faz a avaliação, portanto as pontuações absolutas podem diferir dos resultados publicados.
3. **SWE-bench Pro:** Scale AI, "SWE-Bench Pro: Can AI Agents Solve Long-Horizon Software Engineering Tasks?", 2025.
* **O que foi medido:** Um subconjunto de 482 problemas selecionado por compatibilidade com o harness de avaliação da Anthropic; as pontuações não são comparáveis ao leaderboard público. Também não são comparáveis aos resultados do SWE-bench Pro no system card do Claude Opus 5.5, que vêm de execuções com esforço `max` em um conjunto de problemas diferente.
* **Como foi precificado:** Os custos neste subconjunto são precificados da forma como a organização de um cliente é medida: o prompt anterior de cada requisição como leitura de cache e seus novos tokens como gravação de cache de 5 minutos, a partir dos próprios registros de uso das execuções, conferidos com um livro-razão de cliente.
* **Execuções do Claude Opus 5.5:** Os números do Claude Opus 5.5 fazem a média de duas execuções em `low`, `medium` (seu padrão) e `high`, e usam uma execução em `xhigh`, todas executadas de 19 a 20 de setembro de 2026, com o mesmo limite de 16.384 tokens por turno das execuções de agosto do Claude Opus 5; o limite interrompeu 2 tentativas em `xhigh` e nenhuma nas outras configurações. Em comparação com `high`, o Claude Opus 5.5 pontuou cerca de 2,5 pontos a menos no seu padrão, `medium`, por cerca de 70% do custo por tarefa, e cerca de 8 pontos a menos em `low` por cerca de um terço do custo; `xhigh` pontuou cerca de 1,4 ponto a mais por 2,5 vezes o custo de `high`. As razões vêm de custos não arredondados.
* **Os 478 problemas:** As execuções do Opus 5.5 usaram uma versão do benchmark cujos contêineres de avaliação só conseguem acessar espelhos internos de pacotes. Essa versão descarta um problema cujo teste precisa de um site ativo, e em mais três a solução de referência falha ali, então as comparações do Opus 5.5, e os números do Claude Fable 5.1 colocados ao lado delas, usam os 478 problemas restantes.
* **Execuções do Claude Sonnet 5.5:** O Claude Sonnet 5.5 executou a mesma versão do benchmark: duas execuções no seu padrão, `high`, e duas em `medium`, todas em 24 de setembro de 2026, com o mesmo limite de 16.384 tokens por turno, que não interrompeu nenhuma de suas tentativas. Seus números usam os 478 problemas, assim como os números do Claude Sonnet 5 colocados ao lado deles, contados sobre esses problemas a partir de suas execuções de agosto.
* **Execuções do Claude Opus 5:** Os números do SWE-bench Pro do Claude Opus 5 em [Faça upgrade do modelo](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#upgrade-the-model) e nesta referência fazem a média de duas execuções no seu esforço padrão e usam uma execução em `low`, todas executadas em 4 de agosto de 2026.
* **Advisor, pareamentos com o Claude Sonnet 5:** Os pareamentos de executor Claude Sonnet 5 com um advisor Claude Opus 5 por trás dos exemplos de taxa de consulta em [Estratégia advisor](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#advisor-strategy-escalate-hard-decisions) vêm da mesma série de medições neste subconjunto: o pareamento no esforço padrão foi executado duas vezes (7 e 8 de agosto de 2026, uma execução e uma replicação exata), o pareamento de esforço baixo uma vez (8 de agosto de 2026), e o Claude Sonnet 5 sozinho duas vezes (77,4%, a linha de base para ambos os pareamentos).
* **Advisor, verificação de consultas do Claude Sonnet 5.5:** A verificação de consultas do Claude Sonnet 5.5 citada em [Estratégia advisor](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#advisor-strategy-escalate-hard-decisions) executou uma tentativa em cada um de 20 dos 478 problemas, em 24 de setembro de 2026, com um advisor Claude Opus 5.5 por meio da ferramenta advisor. Quatro configurações foram executadas: `high` e `xhigh`, cada uma com e sem o prompt do sistema sugerido pela documentação da ferramenta advisor para tarefas de codificação. No seu esforço padrão, `high`, o Claude Sonnet 5.5 não consultou o advisor em nenhum dos 20 problemas, com ou sem o prompt. Em `xhigh`, consultou em 3 dos 20 problemas sem o prompt e em 4 com ele, sempre nas suas tentativas com mais turnos.
* **Números de escalonamento:** Os números de escalonamento vêm tarefa por tarefa das execuções do Opus 5.5: `low` primeiro, depois `high` nas suas falhas, resolveu de 96,4% a 97,5% entre os pareamentos de execuções por cerca de $0,17 USD; `medium` primeiro, de 96,0% a 97,1% por cerca de $0,24 USD; `high` reexecutado nas suas próprias falhas, 96,9% por $0,31 USD; tudo em `high`, de 94,8% a 95,8% por $0,29 USD.
* **Compare modelos:** O número do Claude Fable 5.1 em [Compare modelos](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task) vem de uma execução no mesmo subconjunto no esforço padrão, executada em 26 de agosto de 2026: contado sobre os 478 problemas, resolveu 92,3% por $1,19 USD por tarefa resolvida. O gráfico dessa seção e seus números do Claude Opus 5.5 e do Claude Sonnet 5.5 agrupam as duas execuções em cada configuração plotada, todas contadas sobre os 478 problemas: Claude Opus 5.5 em `low`, `medium` e `high`, e Claude Sonnet 5.5 em `medium` e `high`.
* **Compare modelos, trabalho por tarefa:** Nesses números, o Claude Opus 5.5 em `low` fez menos trabalho em cada tarefa do que o Claude Sonnet 5.5 no seu padrão: um pouco mais da metade dos tokens de saída do Sonnet 5.5 e um pouco mais de um terço das suas leituras de cache. Nos seus padrões, o Opus 5.5 em `medium` resolveu cerca de 5 pontos percentuais a mais do que o Sonnet 5.5 por cerca do dobro do custo. Nessa configuração, fez um pouco mais de trabalho por tarefa do que o Sonnet 5.5.
* **Faça upgrade do modelo, execuções:** O ponto do Claude Fable 5 em Faça upgrade do modelo agrupa três execuções no esforço padrão, executadas em 26 de agosto de 2026, precificadas da forma como a organização de um cliente é medida. A escada de atualização conta cada modelo sobre os 478 problemas, cada um nos seus padrões de lançamento. Usa uma execução por modelo, exceto Opus 5, Opus 5.5, Sonnet 5 e Sonnet 5.5 (duas execuções cada) e Fable 5 (as três execuções descritas acima). As execuções do Opus 4.7, Opus 4.8, Sonnet 4.6 e Sonnet 5 ocorreram de 17 a 19 de agosto de 2026, e as do Opus 5 em 4 de agosto, todas em um mesmo harness e organização; as execuções do Opus 5.5 e do Sonnet 5.5 são as descritas anteriormente nesta referência.
* **Faça upgrade do modelo, custo por tarefa resolvida:** O Claude Opus 5 custa 21% a mais por tarefa resolvida do que o Claude Opus 4.8 quando essas execuções do Claude Opus 5 são comparadas com uma execução do Claude Opus 4.8 nos seus padrões de lançamento da série de 17 a 19 de agosto, contadas sobre os mesmos 478 problemas; o painel do SWE-bench Pro do gráfico não mostra nem o Claude Opus 4.7 nem o Claude Opus 4.8. Nas mesmas medições, precificadas como um cliente é faturado, o Claude Opus 5 resolve 12 pontos a mais de tarefas do que o Claude Opus 4.8 com esses 21% a mais por tarefa resolvida, o Claude Opus 4.8 resolve a mesma parcela de tarefas que o Claude Opus 4.7 por 14% a menos por tarefa resolvida, e o Claude Opus 5 com esforço `low` supera o padrão do Claude Opus 4.8 neste benchmark por cerca de 30% do seu custo por tarefa resolvida.
* **Faça upgrade do modelo, preços:** A economia do Claude Sonnet 5 em relação ao Claude Sonnet 4.6 em Faça upgrade do modelo vem do seu preço por token mais baixo, que mais do que compensa os tokens extras que ele usa por tarefa. O Claude Sonnet 5.5 cobra o mesmo que o Claude Sonnet 5 por tudo, exceto leituras de cache, que custam metade. Os preços por token do Claude Opus 5.5 são mais baixos que os do Claude Opus 5, sobretudo para leituras de cache. Assim como o Claude Sonnet 5, o nível de fronteira ganhou pelo preço: a maior parte da economia do Claude Fable 5.1 é o preço mais baixo de leitura de cache.
* **Custo sem cache, precificado a partir das contagens de tokens registradas:** A Anthropic também reprecificou as contagens de tokens registradas das execuções do Claude Opus 5.5 e do Claude Sonnet 5.5 descritas anteriormente nesta referência, sobre os 478 problemas, para os fatores de cache em [Por que o cache vem primeiro](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#why-caching-comes-first); não fez nenhuma execução com o cache desativado.
* **Os fatores, por modelo:** Cada fator é o custo de tokens com todo token de entrada ao preço de entrada, tokens de saída inalterados, dividido pelo custo precificado como a organização de um cliente é medida: para o Claude Opus 5.5, 3,3 em `medium`, 2,4 em `low`, 3,8 em `high` e 5,4 em `xhigh` (uma execução); para o Claude Sonnet 5.5, com leituras de cache a $0,10 USD por milhão de tokens, 3,1 em `high` e 2,4 em `medium`, ou 2,8 em `high` ao preço de lançamento de $0,20 USD. Diferentemente das execuções do gráfico de cache, estas não tiveram taxas de busca na web, e a primeira requisição de uma tarefa é precificada como gravação de cache.
4. **BrowseComp:** Wei et al., "BrowseComp: A Simple Yet Challenging Benchmark for Browsing Agents," OpenAI, 2025. Os números de esforço usam um recorte de 500 problemas, de uma a três execuções por configuração, executadas em 3 de agosto de 2026, com o ponto padrão agrupando duas execuções de 26 a 27 de julho de 2026. A medição de trabalho rotineiro com uma longa cauda de custo em [Estratégia de orquestrador](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#orchestrator-strategy-delegate-bulk-work) usa 10 problemas que o modelo resolvia de forma confiável sozinho quando o protocolo foi fixado, de uma fatia de 26 problemas, 50 execuções delegadas (5 por problema; 1 a 2 de agosto de 2026) e 70 execuções do modelo sozinho (50 de 2 a 3 de agosto de 2026; 20 arquivadas de 12 a 13 de julho e 1º de agosto de 2026), $6,45 USD em comparação com $11,99 USD por execução em valor esperado; os números delegados têm uma faixa de medição de cerca de 20%. Os 10 problemas são aqueles em que a configuração delegada, um orquestrador Claude Fable 5 com um worker Claude Sonnet 5, acertou em todas as 5 execuções e o Claude Fable 5 sozinho em ambas as execuções arquivadas; as execuções delegadas são essas mesmas execuções, e apenas o Claude Fable 5 sozinho foi executado novamente nos dez. Em suas 70 execuções, arquivadas e novas, o Claude Fable 5 sozinho acertou em 68. Nesses problemas, a configuração delegada custou cerca de metade do Claude Fable 5 sozinho em média (os $6,45 USD e $11,99 USD mencionados anteriormente) e cerca de um terço no percentil 90 ($12 USD em comparação com $33 USD por execução), e sua execução mais cara custou $42 USD em comparação com $84 USD; essa execução de $84 USD também errou. No conjunto completo e mais difícil do BrowseComp, o Claude Fable 5 sozinho alcançou a precisão da configuração de orquestrador medida nesse conjunto com custo de 22% a 30% menor.
5. **Escalonamento de arquiteturas de agentes:** Kim et al., "Towards a Science of Scaling Agent Systems," arXiv:2512.08296, 2025. Estudo externo independente, citado apenas pela direção da conclusão sobre quando a delegação não compensa, e não por qualquer número.
6. **DeepWideSearch:** "DeepWideSearch: Benchmarking Depth and Width in Agentic Information Seeking," arXiv:2510.20168, 2025. As 220 perguntas abrangem 15 domínios, cada uma combinando coleta de muitas linhas com recuperação multi-hop; medido no conjunto de linhas padrão do benchmark, 3 execuções por configuração, executadas em 2 de agosto de 2026 (o ponto da equipe com um único worker foi executado de 26 a 27 de julho de 2026). Com o Claude Fable 5, o esforço `low` igualou um orquestrador com um worker Claude Sonnet 5 com custo 29% menor, e levou 4,5 minutos por problema, em comparação com 7,9 minutos no padrão.
7. **DeepResearch Bench II:** Li et al., "DeepResearch Bench II: Diagnosing Deep Research Agents via Rubrics from Expert Report," arXiv:2601.08536, 2026.
* **O que foi medido:** Suas 132 tarefas de pesquisa em 22 domínios são avaliadas segundo rubricas binárias derivadas de especialistas. Medido em um subconjunto de 50 tarefas estratificado por todos os temas, uma tentativa por tarefa, 3 execuções por configuração, no [Claude Managed Agents](https://platform.claude.com/docs/pt-BR/managed-agents/overview) com as próprias ferramentas de busca e fetch na web da plataforma (26 a 27 de agosto de 2026).
* **Como foi pontuado:** Pontuado nas 33 tarefas que nenhuma configuração recusou, com as tentativas interrompidas pelos classificadores de segurança de produção removidas. O Claude Opus 4.6 julga segundo o protocolo de rubricas do benchmark; o original usa um juiz diferente, e um juiz da Anthropic pode favorecer o estilo da casa.
* **Pontuações:** As pontuações são a média de cada modelo na base de 33 tarefas com suas próprias tarefas preemptadas removidas; nas 21 das 33 tarefas em que nenhuma configuração teve uma tentativa interrompida, o Claude Fable 5.1 mantém uma vantagem de 2 a 3 pontos sobre o Claude Fable 5 em todos os níveis de esforço, e ambos os modelos ficam estáveis entre os níveis de esforço.
* **Como foi precificado:** Os custos são precificados da forma como a organização de um cliente é medida: o prompt anterior de cada requisição como leitura de cache e seus novos tokens como gravação de cache de 5 minutos, com a primeira requisição de uma sessão mantendo a leitura de cache que obteve, a partir dos próprios registros de uso das execuções, mais as taxas de busca na web da plataforma. Cada custo por tarefa é o custo de uma execução de 50 tarefas dividido por 50, com as tentativas interrompidas incluídas, em média sobre as três execuções.
* **Resultados, Claude Fable 5:** O Claude Fable 5 custou $2,30 USD por tarefa em `low` e $4,71 USD em `high`, precificado da mesma forma; as porcentagens em [Faça upgrade do modelo](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#upgrade-the-model) vêm de custos não arredondados.
* **Resultados, Claude Opus 5:** O Claude Opus 5 no seu esforço padrão foi executado na mesma superfície e subconjunto, três execuções, em 28 de agosto de 2026: 68,8% nas 50 tarefas brutas, 70,8% na base de 33 tarefas e 71,1% no conjunto de 21 tarefas, a $6,28 USD por tarefa ($23,72 USD sem cache); nenhuma de suas tentativas foi interrompida pelos classificadores de segurança, sob uma implantação de salvaguardas mais recente do que aquela sob a qual os outros modelos foram executados.
* **Compare modelos:** A comparação de pesquisa em [Compare modelos](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task) se baseia nestes números: o Claude Fable 5.1 em `low` pontuou 10 pontos acima do Claude Sonnet 5 na base de 33 tarefas (66% contra 56%) a cerca de quatro vezes o custo por tarefa sobre todas as 50 tarefas ($4,48 USD contra $1,18 USD); o Claude Opus 5 no seu padrão, cujas pontuações e custo são dados anteriormente nesta referência, pontuou acima do Claude Fable 5.1 no seu padrão, que pontuou 65% na base de 33 tarefas e custou $6,89 USD por tarefa sobre todas as 50 tarefas, então, em pesquisa, o Claude Fable 5.1 justifica seu preço apenas em `low`.
* **Gráfico de cache:** O gráfico de cache reprecifica as mesmas requisições com todo token de entrada à taxa sem cache.
* **Não medido:** O Claude Sonnet 5.5 não foi medido neste benchmark.
8. **Varredura de defeitos em corpus:** Interno da Anthropic, para trabalho maior do que uma "context window" (janela de contexto): um corpus de 21,6 milhões de tokens de 14 fontes públicas de pacotes Python com 130 defeitos plantados e avaliação determinística; protocolo fixado antes das execuções e revisado internamente; três execuções por configuração. Todas as configurações foram executadas no Claude Managed Agents. A configuração de equipe no gráfico é aquela em que o orquestrador Claude Fable 5.1 executou toda a varredura dentro da plataforma no seu limite documentado de 25 workers Claude Sonnet 5 simultâneos, executada em 30 de agosto de 2026; suas três execuções pontuaram F1 0,764, 0,825 e 0,791 após a auditoria de extras (brutos 0,751, 0,821 e 0,781) por $225 USD, $234 USD e $283 USD. A configuração de equipe custou cerca de metade do Claude Fable 5.1 sozinho em `low`, `medium` ou `high` (47% a 55% menos), pontuou de 10 a 12 pontos abaixo dele e levou cerca de 2,3 horas por execução, em comparação com 15 a 20 horas. A configuração de equipe leu cerca de 560 milhões de tokens em cache por execução, quase todos à taxa de leitura de cache do Claude Sonnet 5. Isso é cerca de uma vez e meia os aproximadamente 365 milhões que o Claude Fable 5.1 leu sozinho. O Claude Fable 5.1 sozinho com esforço `high` ainda detém a precisão máxima, a cerca de 2,2 vezes o custo da configuração de equipe, então a delegação aqui compra a maior parte da precisão, não toda ela. A configuração com o Claude Sonnet 5 sozinho foi executada de 3 a 4 de agosto de 2026; as configurações com o Claude Fable 5.1 sozinho foram executadas de 24 a 25 de agosto de 2026, sob as configurações de serviço de lançamento da plataforma, três seeds por configuração de esforço, na mesma build do corpus. A imagem do sandbox continha cópias instaladas de parte do corpus, e a etapa final de montagem do Claude Fable 5.1 comparou com elas em 7 de 9 execuções; reavaliar sem essas adições alterou as seeds afetadas em até 3 pontos. O F1 absoluto é específico desta build do corpus, não comparável entre benchmarks; as comparações de configuração são equivalentes.
9. **GPQA Diamond:** Rein et al., "GPQA: A Graduate-Level Google-Proof Q\&A Benchmark," 2023. O subconjunto Diamond de 198 perguntas, avaliado por modelo em relação a respostas de referência, com tokens do advisor medidos por requisição. O Claude Haiku 5.5 e o Claude Sonnet 5.5, cada um sozinho e com um advisor Claude Opus 5.5, e o Claude Opus 5.5 sozinho fizeram duas execuções por configuração em 7 de outubro de 2026, todas com o [fallback no lado do servidor](https://platform.claude.com/docs/pt-BR/build-with-claude/refusals-and-fallback#server-side-fallback) desativado, no esforço padrão de cada modelo, e com recusas contadas como erradas. Uma verificação de segurança da plataforma recusou uma pergunta de biologia por execução no Claude Haiku 5.5 e no Claude Sonnet 5.5 sozinhos, uma em duas execuções no Haiku 5.5 com o advisor, nenhuma no Sonnet 5.5 com o advisor, e seis por execução no Opus 5.5, que pontuou 91% com elas contadas como erradas e 93,5% nas perguntas que respondeu. O Claude Haiku 5.5 sozinho pontuou 85%, 6 pontos abaixo do Opus 5.5. As configurações com advisor adicionaram a ferramenta sem um prompt pedindo consultas, e nenhum dos executores chamou o advisor em nenhuma pergunta. Os pareamentos pontuaram 0,5 ponto (Claude Haiku 5.5) e 1,0 ponto (Claude Sonnet 5.5) acima do executor sozinho, ambos dentro do ruído entre execuções.
10. **DeepSWE:** Datacurve, "DeepSWE: Measuring Frontier Coding Agents on Original, Long-Horizon Engineering Tasks," arXiv:2607.07946, 2026. O conjunto tem 113 tarefas originais em cinco linguagens com verificadores baseados em programas. Os pareamentos são duas execuções cada, executadas em 7 de agosto de 2026, com tokens do advisor medidos por requisição, e usaram um loop de advisor no lado do cliente em vez da ferramenta advisor, com contabilização idêntica. As varreduras de esforço de modelo único são execuções únicas precificadas a partir das contagens de tokens, uma aproximação que considera o cache. Os custos por tarefa são os totais das execuções divididos por 113. Neste benchmark, um executor Claude Sonnet 5 de esforço baixo com um advisor pontuou 23 pontos acima do mesmo executor sozinho.
11. **Benchmark interno de codificação agêntica:**
* **O que foi medido:** Interno da Anthropic: 370 tarefas de repositório avaliadas pelos próprios testes dos repositórios. Os números da API foram medidos com um agente simples de API e um limite de saída de 128.000 tokens, uma execução por configuração: Opus 5 sozinho no esforço padrão de 9 a 10 de agosto de 2026, e em `low` e `medium` em 10 de agosto de 2026; Claude Fable 5.1 sozinho em cinco valores de esforço definidos explicitamente em 20 de agosto de 2026 (o gráfico mostra três deles); e o pareamento de 24 a 25 de agosto de 2026.
* **Execuções de agosto:** As execuções de agosto tiveram cinco tentativas por tarefa para o pareamento e o controle do Claude Opus 5 e uma para os outros pontos.
* **Como foi precificado:** Os custos são por tentativa. Os custos são precificados da forma como a organização de um cliente é medida: o prompt anterior de cada requisição do loop do agente como leitura de cache e seus novos tokens como gravação de cache de 5 minutos, a partir dos próprios registros de uso das execuções, e cada chamada ao advisor, que não usa cache, a partir dos seus tokens registrados, tudo a preços de tabela.
* **Claude Opus 5.5 sozinho:** O Claude Opus 5.5 sozinho foi executado em todas as 370 tarefas, de 19 a 20 de setembro de 2026: no seu esforço padrão (`medium`) e em `high` com cinco tentativas por tarefa, e em `low` e `xhigh` com uma (369 de 370 pontuadas em cada, após uma falha na verificação de configuração). O Claude Opus 5.5 sozinho resolveu 74,8% das tentativas em `low` por $0,35 USD por tentativa, 86,6% em `medium` por $0,84 USD, 88,4% em `high` por $1,38 USD e 91,1% em `xhigh` por $4,11 USD.
* **Claude Opus 5.5 com um advisor Claude Fable 5.1, execuções:** O executor Claude Opus 5.5 em `high` com o Claude Fable 5.1 lançado como advisor (as execuções de agosto usaram um snapshot de pré-lançamento) executou cinco tentativas por tarefa nas mesmas datas; uma tarefa falhou na verificação de configuração, então 1.845 tentativas foram pontuadas. As 279 tentativas em que o advisor foi recusado sob carga foram reexecutadas, e as tentativas cujas consultas expiraram foram mantidas, como em agosto.
* **Claude Fable 5.1 isoladamente:** Para comparação, o Claude Fable 5.1 lançado sozinho em `high`, seu padrão, pontuou 85,7% (317 de 370 tarefas), uma tentativa por tarefa em 7 de outubro de 2026.
* **Consultas:** O pareamento de agosto teve em média cerca de duas consultas ao advisor por tentativa; o pareamento do Claude Opus 5.5 solicitou 1,39 e recebeu 1,35.
* **Claude Opus 5.5 com um advisor Claude Fable 5.1, resultados:** O pareamento do Claude Opus 5.5 pontuou 90,1% a $2,92 USD por tentativa: em comparação com o Claude Opus 5.5 no seu padrão, `medium`, são 3,5 pontos por cerca de 3,5 vezes o dinheiro. O custo de latência são as próprias consultas: cerca de uma ou duas chamadas extras a um modelo de fronteira por tarefa, cada uma no caminho crítico da tarefa. Com o executor Claude Opus 5.5, o conselho quase não economizou custo do executor: $1,36 USD por tentativa em comparação com $1,38 USD para o Claude Opus 5.5 sozinho em `high`, enquanto as consultas custaram $1,55 USD.
* **Pareamento de agosto:** Em agosto, com um executor Claude Opus 5 e um advisor Claude Fable 5.1, o executor gastou $1,26 USD a menos por tentativa do que o Claude Opus 5 sozinho no seu padrão, e as consultas custaram $2,47 USD, então essa economia pagou cerca de metade do conselho. Esse pareamento de agosto foi a configuração mais precisa medida na época, a $6,21 USD por tentativa.
* **Claude Sonnet 5.5 sozinho, execuções:** O Claude Sonnet 5.5 sozinho foi executado em todas as 370 tarefas em 24 de setembro de 2026, no seu esforço padrão (`high`) e em `medium`, uma tentativa por tarefa, com o mesmo limite de saída de 128.000 tokens, que não interrompeu nenhuma de suas tentativas. Todas as 370 foram pontuadas em `medium`, e 369 de 370 em `high`, após uma falha na verificação de configuração. Seus custos são precificados da forma como a organização de um cliente é medida.
* **Claude Sonnet 5.5 sozinho, resultados:** Sem advisor, o Claude Sonnet 5.5 pontuou 77,8% no seu padrão, `high`, por $0,33 USD por tentativa, cerca de 9 pontos abaixo do Claude Opus 5.5 no seu padrão por cerca de dois quintos do custo; em `medium`, pontuou 62,7% por $0,16 USD. Em `medium`, o Claude Sonnet 5.5 pontuou cerca de 15 pontos a menos do que no seu padrão, `high`, por cerca de 48% do custo por tentativa.
* **Compare modelos:** Em [Compare modelos](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#compare-models-on-cost-per-task), o Claude Opus 5.5 no seu padrão custou menos de um terço do custo por tentativa do Claude Fable 5.1 em `medium`, que é uma única execução.
12. **Benchmark interno de tarefas de repositório (medição de limite):**
* **O que foi medido:** Um conjunto interno separado da Anthropic de cerca de 130 tarefas de repositório, executado em 20 de agosto de 2026 (Claude Fable 5.1) e 19 de setembro de 2026 (Claude Opus 5.5, no seu esforço padrão, `medium`), com um loop simples de agente de API, uma tentativa por tarefa.
* **Como foi precificado:** O custo por tarefa resolvida é precificado como um cliente é faturado, com um cache de prompt de 5 minutos, para o Claude Fable 5.1, e a preços de tabela a partir das contagens de tokens registradas nas suas execuções para o Claude Opus 5.5.
* **Execuções do Claude Fable 5.1:** As execuções do Claude Fable 5.1 são 135 tarefas por limite no esforço padrão definido explicitamente: o número de 16.384 tokens faz a média de duas execuções (36,3% em ambas); os números de 64.000 e 128.000 são execuções únicas (58,5% e 60,0%). Cinco problemas receberam uma recusa de segurança em todas as quatro execuções e contam como falhas.
* **Execuções do Claude Opus 5.5:** O número de 16.384 tokens do Claude Opus 5.5 faz a média de duas execuções (134 e 135 tarefas pontuadas), e seus números de 64.000 e 128.000 são execuções únicas (135 tarefas cada); duas tentativas em cada execução de 16.384 tokens e uma em cada uma das execuções de 64.000 e 128.000 tokens terminaram em recusa de segurança e contam como falhas. O Claude Opus 5.5 resolveu 57,6% em 16.384 (58,2% e 57,0%), 75,6% em 64.000 e 68,9% em 128.000. Nenhuma de suas tentativas foi interrompida em 64.000 ou 128.000, então o limite não explica a diferença entre essas duas execuções.
* **Tentativas encerradas pelo limite:** Apenas 1 das 66 tentativas do Claude Opus 5.5 que o limite de 16.384 tokens encerrou, e 9 das 117 tentativas do Claude Fable 5.1, ainda passaram.
* **Custo por tentativa:** O custo por tentativa foi de $3 USD em 16.384 e $4 USD em 64.000 para o Claude Opus 5.5, a preços de tabela, e $8 USD e $13 USD para o Claude Fable 5.1, como um cliente é faturado.
* **Números de limite do SWE-bench Pro:** Os números de limite do SWE-bench Pro são uma execução do Claude Fable 5.1 por limite no esforço padrão, executada em 26 de agosto de 2026, em um subconjunto de 100 problemas estratificado a partir do conjunto de 482 problemas da referência 3, não comparável às suas pontuações; no esforço padrão, as execuções em 16.384 e em 64.000 resolveram cada uma 94 dos 100 problemas.
* **Comprimento dos turnos:** As distribuições por turno no gráfico de pontos da seção vêm das execuções do Claude Opus 5.5 e do Claude Fable 5.1 em 128.000: nenhum turno do Opus 5.5 atingiu o limite (o mais longo teve cerca de 61.000 tokens, e 0,56% dos seus turnos excederam 16.384), e um turno do Fable 5.1 atingiu 128.000 (0,46% dos seus turnos excederam 16.384). Com o limite em 128.000, 2 dos 14.331 turnos do Claude Fable 5.1 foram mais longos que 64.000 tokens, e nenhum turno do Claude Opus 5.5 foi.
13. **Chartography:** Surge AI, "Chartography," 2026.
* **O que foi medido:** O conjunto completo publicado de 100 perguntas, medido em 6 e 9 de agosto de 2026 (Claude Opus 5 sozinho) e 20 de setembro de 2026 (Claude Opus 5.5), com a implementação da Anthropic no Claude Managed Agents (sandbox de nuvem padrão; as configurações com advisor usam o advisor do Managed Agents).
* **Como foi pontuado:** O Claude Sonnet 4.6 avalia em vez do juiz de referência e o benchmark é executado com ferramentas, então as pontuações são comparáveis entre configurações aqui, mas não com o leaderboard publicado. Também não são comparáveis aos resultados do Chartography no system card do Claude Opus 5.5, que usam um avaliador diferente e são executados com esforço `max`. Duas execuções por configuração (três para o Claude Opus 5.5), agrupadas; as variações entre execuções foram de até 10 pontos.
* **Como foi precificado:** Os custos são o que um cliente que executa o agente rotineiramente é faturado: a primeira requisição de cada gráfico lê do cache o prompt do sistema e as ferramentas compartilhados do agente, como acontece quando outra sessão do mesmo agente foi executada nos 5 minutos anteriores. Um gráfico executado isoladamente custa cerca de $0,03 USD a mais com o Claude Opus 5 ou o Claude Opus 5.5 e cerca de $0,12 USD a mais com o Claude Fable 5.1. Os números de agosto são reprecificados dessa forma a partir dos registros de uso das execuções. Os custos excluem o tempo de sandbox, que acrescentou menos de 1% às execuções de agosto.
* **Claude Fable 5.1 sozinho, execuções de agosto:** As execuções do Claude Fable 5.1 sozinho são de 24 de agosto de 2026, sob as configurações de serviço de lançamento da plataforma, duas execuções por configuração; seis tentativas atingiram o limite de sessão de 15 minutos e pontuam 0, e dois gráficos por execução foram respondidos pelo Claude Opus 5 após uma recusa de segurança.
* **Claude Opus 5 com um advisor Claude Fable 5.1:** O executor Claude Opus 5 de esforço baixo com um advisor Claude Fable 5.1 foi executado duas vezes em 30 de agosto de 2026, sob as mesmas configurações (63,0 e 67,0, média 65,0, a $0,47 USD por gráfico; o advisor foi consultado em 88% das tarefas em cada execução, e 4 das suas 219 respostas vieram do Claude Opus 5 em vez dele, cada uma depois que um filtro de segurança de produção interrompeu a própria resposta do advisor). Esse pareamento igualou o Claude Fable 5.1 sozinho em `medium` dentro do ruído entre execuções (65,0 em comparação com 67,5) a cerca de 1,8 vez o custo por tarefa: uma consulta que dispara na maioria das tarefas custa mais do que executar o próprio modelo mais forte.
* **Execuções do Claude Opus 5.5:** O Claude Opus 5.5 foi executado em `low`, com o fallback no lado do servidor desativado e um classificador de segurança julgando cada chamada de ferramenta: três execuções sozinho (70, 68 e 68) e três com um advisor Claude Fable 5.1 configurado (59, 63 e 63), nas quais consultou o advisor em 1 de 300 tarefas.
* **Resultados com esforço `low`:** Neste benchmark de leitura de gráficos, o Claude Opus 5.5 em `low` pontuou 68,7 por cerca de $0,03 USD por gráfico, contra 62,5 por $0,15 USD do Claude Fable 5.1 em `low` e 49 por $0,16 USD do Claude Opus 5 em `low`.
* **Claude Fable 5.1 sozinho, execuções de outubro:** Para comparação com o pareamento do Claude Opus 5.5, o Claude Fable 5.1 sozinho em `high`, seu padrão, foi executado três vezes em 7 de outubro de 2026, com a mesma implementação e configurações de plataforma das execuções do Claude Opus 5.5: 82, 79 e 79, uma média de 80,0.
* **Taxa de consulta:** A comparação de taxa de consulta para os pareamentos anteriores vem da reexecução das mesmas configurações na Messages API com um conjunto de ferramentas de contêiner, de 10 a 11 de agosto de 2026.
14. **Avaliação de auditoria de prompts de central de suporte:**
* **O que foi medido:** Um conjunto construído pela Anthropic de 44 tickets de suporte com avaliação determinística, executado no início de agosto de 2026 e reportado em 8 de agosto de 2026, sob seis prompts do sistema, cada um adicionando ao mesmo prompt limpo um padrão comum em prompts escritos para o Claude Opus 4.8 e o Claude Sonnet 4.6.
* **O gráfico:** Cada ponto do gráfico é um de três casos (modelo mais antigo, modelo mais novo no mesmo prompt, modelo mais novo após a auditoria) em média sobre os seis prompts e 44 tickets.
* **Resultados, Claude Opus 5:** No Claude Opus 5, os prompts escritos para o Claude Opus 4.8 custaram 36% a mais por ticket do que custavam no Claude Opus 4.8, sem mudança na precisão. Após a auditoria, custaram 14% a menos no Claude Opus 5 do que antes dela (a partir das médias não arredondadas; os custos arredondados do gráfico, 3,43 e 2,93 centavos de dólar por ticket, dão 14,6%), e o Claude Opus 5 resolveu 97% dos tickets corretamente, acima dos 92%. Por tipo de padrão, no Claude Opus 5: remover "verifique duas vezes" reduziu o custo por ticket em um terço, e remover "seja o mais minucioso possível" o reduziu quase na mesma medida; remover a configuração de pensamento desativada, as regras contraditórias e o rascunho feito à mão restaurou, cada um, de 7 a 11 pontos de precisão.
* **Resultados, Claude Sonnet 5:** Na migração do Claude Sonnet 4.6 para o Claude Sonnet 5, a auditoria reduziu em 14% o custo por ticket com a mesma precisão.
* **Ressalvas:** O ganho de precisão do Opus 5 tem um intervalo de confiança de 95% de 3 a 8 pontos; as diferenças de precisão do Sonnet estão dentro do ruído.
15. **Conjunto de perguntas sobre arquivo de dados:** Um conjunto construído pela Anthropic de 25 perguntas agregadas sobre uma fatia de 1.862 linhas de um CSV público de vendas de bebidas alcoólicas, com gabarito calculado pelo pandas e avaliação por correspondência exata, executado no Claude Sonnet 5 e no Claude Opus 5 com o pensamento desativado (o braço em contexto não consegue concluir no padrão), um limite de saída de 4.000 tokens e sem cache de prompt, três execuções por configuração, executadas em 19 de agosto de 2026. O braço de arquivo faz upload do CSV pela Files API e usa a ferramenta `code_execution_20260120`. As três execuções do Claude Sonnet 5 no braço em contexto responderam corretamente 6, 7 e 7 das 25 perguntas; o rótulo do gráfico e o texto dão sua média, 6,67, arredondada para a pergunta mais próxima, e o ponto do gráfico é desenhado na média, 26,7%.
16. **Medição de duração do cache:**
* **O que foi medido:** O job de triagem de 20 issues de [Corte tokens de entrada e de contexto](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), executado no Claude Sonnet 5 em 23 de agosto de 2026, e no Claude Opus 5.5 em 19 e 20 de setembro de 2026, no seu esforço padrão (`medium`) e em `high`, na Messages API com o mesmo harness (para o Claude Opus 5.5, uma adaptação dele que envia os mesmos corpos de requisição), as células do Claude Opus 5.5 com `max_tokens` elevado para 4.096, com pausas inseridas antes de uma parcela escolhida aleatoriamente dos turnos (nenhuma, 5%, 10% e todos os turnos com 6 minutos em todas as 20 issues em ambos os modelos, mais todos os turnos com 2 minutos no Claude Sonnet 5; pausas de 20 e 45 minutos em um subconjunto de 5 issues em ambos os modelos). Os números do Claude Opus 5.5 nesta página cobrem ambos os níveis de esforço.
* **Outros modelos e datas:** Os números de keep-alive do Claude Opus 5 abaixo vêm do mesmo job em 23 de agosto de 2026, com `max_tokens` elevado para 4.096, nos mesmos cronogramas, exceto as pausas de 2 e 45 minutos. O Claude Sonnet 5.5 executou a mesma medição que o Claude Sonnet 5 (os mesmos cronogramas de pausa e três configurações de cache, três execuções por célula), com o harness portado usado para o Claude Opus 5.5, no seu esforço padrão, `high`, em 24 de setembro de 2026.
* **Como foi pontuado e precificado:** Três execuções por célula, custo calculado a partir dos campos `usage` de cada resposta a preços de tabela (para o Claude Opus 5.5, $4 USD de entrada, $5 USD de gravação de 5 minutos, $8 USD de gravação de 1 hora, $0,20 USD de leitura de cache e $20 USD de saída por milhão de tokens; o Claude Sonnet 5 foi executado em uma organização interna da Anthropic cujo uso é medido da mesma forma que o de uma organização de cliente), precisão em relação aos mesmos rótulos gold.
* **Como foi executado e precificado, Claude Sonnet 5.5:** O Claude Sonnet 5.5 definiu `max_tokens` como 4.096 nas requisições de sessão e como 1 nas requisições de keep-alive, foi executado em uma organização interna da Anthropic cujo uso é medido da mesma forma que o de uma organização de cliente, e é precificado aos seus preços de tabela atuais ($2 USD de entrada, $2,50 USD de gravação de 5 minutos, $4 USD de gravação de 1 hora, $0,10 USD de leitura de cache e $10 USD de saída por milhão de tokens). Além do `max_tokens` mais alto, que nenhum turno atingiu, uma entrada difere das execuções do Claude Sonnet 5: o único GIF animado do job foi enviado como um PNG do seu primeiro quadro, o único quadro que a API usa ([Visão](https://platform.claude.com/docs/pt-BR/build-with-claude/vision)), e os dois contam como o mesmo número de tokens de entrada.
* **Ponto de equilíbrio:** O ponto de equilíbrio é de cerca de 3,3% dos turnos no Claude Sonnet 5 e de 3,1% a 3,2% no Claude Opus 5.5: a mediana da parcela de equilíbrio de cada sessão, calculada pelo modelo de custo a partir dos tamanhos de contexto turno a turno dessa sessão, sobre todas as 45 sessões de vinte issues do Claude Sonnet 5 e as 36 sessões de vinte issues do Claude Opus 5.5 em cada nível de esforço (cada cronograma de pausa executado no job completo, sob todas as três configurações de cache, três execuções cada; as células de 5 issues não estão incluídas). O ponto de equilíbrio no Claude Sonnet 5.5 é de cerca de 3,1% dos turnos, a mediana sobre suas 45 sessões de vinte issues. O gráfico de duração do cache plota essas sessões do Claude Sonnet 5.5, três por ponto.
* **Configurações de 5 minutos e 1 hora, Claude Sonnet 5 e Claude Opus 5.5:** Na célula de 5%, as configurações de 5 minutos e 1 hora empataram no Claude Sonnet 5, porque as pausas desse sorteio caíram em prefixos pequenos; no Claude Opus 5.5 quase empataram. No Claude Sonnet 5, ao seu preço de leitura de cache de $0,20 USD por milhão de tokens, uma sessão custou $0,60 USD, $0,69 USD e $0,99 USD na configuração de 5 minutos sem pausas, com 5% e com 10% dos turnos pausados, e $0,70 USD, $0,70 USD e $0,71 USD na configuração de 1 hora.
* **Requisições de keep-alive, Claude Sonnet 5 e Claude Opus 5:** A Anthropic mediu requisições de keep-alive que renovam o cache de 5 minutos no Claude Sonnet 5 e no Claude Opus 5 em 23 de agosto de 2026, e no Claude Opus 5.5 nas execuções acima, sempre enviadas com `max_tokens: 1`. No Claude Sonnet 5, custaram 7,7% a menos do que a configuração de 1 hora com 5% dos turnos pausados e aproximadamente o mesmo com 10%; no Claude Opus 5, nenhuma diferença foi mensurável em nenhuma das parcelas; em ambos, custaram mais com uma pausa de 6 minutos ou mais antes de cada turno. Então, nesses dois modelos, a configuração a usar é a duração de 1 hora, não requisições de keep-alive.
* **Requisições de keep-alive, Claude Opus 5.5:** No Claude Opus 5.5, as requisições de keep-alive custaram de 8% a 18% a menos do que a configuração de 1 hora com 5% e 10% dos turnos pausados (8% a 13% a menos no seu esforço padrão, `medium`, e 10% a 18% a menos em `high`; cerca de 10% a 15% depois que o ruído entre sessões é removido refaturando os próprios tokens de cada sessão de keep-alive aos preços de cache de 1 hora), e mais com uma pausa antes de cada turno: 4% a 6% a mais com 6 minutos, 9% a 10% com 20 minutos e 56% a 58% com 45 minutos.
* **Requisições com `max_tokens: 0`, Claude Opus 5.5:** Os testes de API de pré-lançamento da Anthropic no Claude Opus 5.5 mostram que uma requisição com `max_tokens: 0` grava o cache e que a próxima requisição o lê; se tal requisição renova uma entrada existente não foi medido no Opus 5.5.
* **Configurações de 5 minutos e 1 hora, Claude Sonnet 5.5:** Com 5% dos turnos pausados, a configuração de 5 minutos custou 5% a mais do que a de 1 hora em média (de 2% a menos a 12% a mais entre as três execuções), o que está dentro da variação entre execuções: as pausas desse sorteio caíram em prefixos pequenos, como no Claude Sonnet 5, e refaturar os próprios tokens de cada sessão de 5 minutos aos preços de cache de 1 hora dá cerca de 1% a mais. Com 10% pausados, custou 54% a mais (36% a 73% a mais). Sem pausas, a configuração de 5 minutos custou 19% a menos do que a de 1 hora em média (3% a 32% a menos entre as três execuções; o preço de gravação mais alto da configuração de 1 hora prevê cerca de 20%), e 21% a 24% a menos em todas as execuções com pausas de 2 minutos.
* **Requisições de keep-alive, Claude Sonnet 5.5:** As requisições de keep-alive custaram 16% a menos do que a configuração de 1 hora em média com 5% dos turnos pausados (13% a 20% a menos entre as três execuções) e 8% a menos com 10% (3% a 10% a menos), e custaram mais com uma pausa de 6 minutos ou mais antes de cada turno. Com 5% e 10% dos turnos pausados, as pausas duraram de 6 a 32 minutos no Claude Sonnet 5.5 e no Claude Opus 5.5. Refaturar os próprios tokens de cada sessão de keep-alive aos preços de cache de 1 hora, como para o Claude Opus 5.5 acima, dá 15% a 16% a menos com 5% pausados e cerca de 10% a menos com 10%, e, com uma pausa antes de cada turno, 7% a mais com 6 minutos, 9% a 10% a mais com 20 minutos e 66% a 73% a mais com 45 minutos. Os números de 6 minutos deixam de fora a execução 3, na qual 2 das 39 requisições de keep-alive dessa sessão expiraram: o cache expirou antes desses dois turnos, a sessão gravou 214.000 tokens no cache contra 80.000 a 85.000 nas execuções 1 e 2, e custou 38% a mais do que a sessão de 1 hora da execução 3.
* **Requisições de keep-alive, Claude Sonnet 5.5, por execução:** Comparando, em vez disso, a sessão de keep-alive de cada execução com a sessão de 1 hora da mesma execução, o keep-alive custou de aproximadamente o mesmo a 10% a mais com 6 minutos (execuções 1 e 2; 4% a mais na média delas), de aproximadamente o mesmo a 16% a mais com 20 minutos, e de 64% a 80% a mais com 45 minutos.
* **Requisições de keep-alive, Claude Sonnet 5.5, tamanho da amostra:** Os pontos de 6 minutos do gráfico de keep-alive fazem a média das execuções 1 e 2 para todas as três configurações. Cada célula tem três sessões (duas para os números de 6 minutos acima). Sem pausas, o keep-alive não envia requisições extras e, portanto, equivale à configuração de 5 minutos, mas as duas diferiram em até 23% dentro de uma única execução, então uma diferença de alguns por cento em uma média de três execuções não é um efeito claro.
* **Cache desativado e ativado, Claude Sonnet 5:** No Claude Sonnet 5, o mesmo job foi executado com o cache desativado e com o cache ativado, três execuções cada em 19 de agosto de 2026, com `max_tokens` em 700: $3,36 USD contra $0,57 USD por sessão em média, uma economia de 83%.
* **Precificado a partir das contagens de tokens registradas, Claude Sonnet 5.5:** A Anthropic também reprecificou as contagens de tokens registradas das três sessões do Claude Sonnet 5.5 com o cache de 5 minutos e sem pausas para o número de cache em [Por que o cache vem primeiro](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#why-caching-comes-first); não fez nenhuma execução com o cache desativado no Claude Sonnet 5.5. Cada uma dessas três sessões é uma conversa de 40 requisições sobre as 20 issues do job. Aos preços de tabela de 12 de outubro de 2026, as sessões custaram $0,51 USD cada em média, a partir dos campos de uso, contra $3,70 USD com todo token de entrada ao preço de entrada e tokens de saída inalterados: uma economia de 86% (86% a 87% entre as três sessões), ou um fator de 7,3. Ao preço de leitura de cache de lançamento de $0,20 USD, a economia é de 82%, então o aumento em relação ao número do Claude Sonnet 5 vem do preço mais baixo de leitura de cache.
* **Precificado a partir das contagens de tokens registradas, Claude Opus 5.5:** Reprecificadas da mesma forma, as três sessões do Claude Opus 5.5 no seu esforço padrão, `medium`, com o cache de 5 minutos e sem pausas custaram $1,02 USD cada em média contra $6,93 USD, uma economia de 85%, ou um fator de 6,8; a Anthropic não fez nenhuma execução com o cache desativado no Claude Opus 5.5, e o modelo usou pensamento em 79% das requisições.
* **Como o pensamento foi configurado, apenas dois conjuntos de execuções:** As requisições das três sessões do Claude Sonnet 5.5 com o cache de 5 minutos e sem pausas não definiram nenhuma opção de pensamento, então o pensamento ficou no padrão do modelo, e o modelo o usou em 38% das requisições. As requisições das execuções do Claude Sonnet 5 com o cache desativado e com o cache ativado também não definiram nenhuma opção de pensamento, então o pensamento ficou no padrão do modelo, e o modelo o usou em 41 de 121 requisições com o cache desativado e em 40 de 120 com o cache ativado.
* **Latência após uma pausa:** No Claude Sonnet 5 e no Claude Opus 5, o turno após uma pausa manteve sua latência de cache aquecido na configuração de 1 hora. O tempo até o primeiro token do Claude Opus 5.5 após uma pausa não foi medido. O tempo até o primeiro token do Claude Sonnet 5.5 após uma pausa não foi medido.
17. **Participação de leitura de cache em produção:** Uso agregado de primeira parte da Claude API nos 14 dias encerrados em 23 de agosto de 2026, apenas o produto de API direta, organizações internas da Anthropic excluídas, nenhuma organização identificada. Uma organização-dia conta como um loop de agente quando suas requisições carregam definições de ferramentas e resultados de ferramentas, seus prompts contêm em média 9 ou mais chamadas de ferramentas anteriores, o cache foi usado, e ela fez pelo menos 10 dessas requisições (a API não tem identificador de conversa, então isso substitui o comprimento da conversa): 303.003 organizações-dia em 106.487 organizações, participação mediana de leitura de cache de 84,2% de todos os tokens de entrada, quartil superior de 91,7%. Os rótulos de caso de uso (o caso de uso declarado da organização ou, caso contrário, o classificado) cobrem 74% dessas organizações-dia e 99% dos seus tokens; cerca de 72% das organizações-dia de codificação leem 80% ou mais. O decil superior de organizações-dia lê 95,9% ou mais para codificação e de 94,2% a 94,8% para agentes de suporte, pesquisa, dados e outros. A divisão no nível de requisição com 25 ou mais chamadas de ferramentas anteriores vem de uma amostra de seis horas: codificação 92% leitura, 7% gravação, menos de 1% sem cache.
18. **Medições de momento de compactação e de linha de status:**
* **O que foi medido:** A variante longa do agente de triagem de [Corte tokens de entrada e de contexto](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), executada em 24 de agosto de 2026, no Claude Sonnet 5 com o cache de 5 minutos, custo a partir dos campos de uso a preços de tabela, cinco sessões por braço: um braço sem mudanças no esforço padrão do início ao fim ($0,81 USD por sessão), e dois braços que começam com esforço baixo e fazem as mesmas duas mudanças que quebram o cache, uma troca para o esforço padrão e uma ferramenta adicionada, seja no meio da sessão nas requisições 12 e 17 ($0,95 USD) ou juntas na primeira requisição após a primeira compactação ($0,75 USD).
* **Quarto braço:** Um quarto braço de seis sessões, executado em 25 de agosto de 2026, fez as mesmas duas mudanças na requisição que disparou a primeira compactação ($0,92 USD por sessão): a passagem de sumarização dessa requisição gravou o contexto de 81.000 tokens no cache em vez de lê-lo, então essa passagem custou $0,21 USD contra $0,04 USD para a mesma passagem no braço de fronteira.
* **Compactação:** As sessões compactaram pela primeira vez entre as requisições 21 e 25 (16 das 21 sessões na requisição 22), quando o prompt ultrapassou o gatilho de compactação de 80.000 tokens, e duas sessões sem mudanças compactaram uma segunda vez perto do fim. O total mais baixo do braço de fronteira em relação ao braço sem mudanças reflete suas requisições de esforço baixo antes da mudança e essas segundas compactações, e não o cache: os custos de regravação dos dois braços diferem em menos de $0,01 USD.
* **Braço de meio de sessão:** O braço de meio de sessão pagou $0,23 USD por sessão em regravações de cache; a diferença entre os braços de meio de sessão e de fronteira foi de $0,20 USD, com um intervalo de confiança de 95% de $0,11 USD a $0,29 USD. No braço de meio de sessão, a mudança de esforço e a ferramenta adicionada regravaram 39.000 e 60.000 tokens em cache. Uma de suas sessões saiu barata ($0,82 USD) depois que seu modelo chamou incorretamente a ferramenta de busca após a compactação e obteve resultados vazios; ela está incluída, e sem ela o braço tem média de $0,98 USD.
* **Precisão e leituras de cache:** A precisão teve média de 14,2 de 20 rótulos em cada braço de 24 de agosto e 14,7 no braço de 25 de agosto; as leituras de cache foram 91% dos tokens de prompt sem mudanças, 85% no meio da sessão, 91% na fronteira e 86% com as mudanças na requisição que disparou a compactação.
* **Medição separada, linha de status:** Uma medição separada no job de triagem de 20 issues de [Corte tokens de entrada e de contexto](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), executada em 18 de agosto de 2026, também no Claude Sonnet 5 com o cache de 5 minutos, precificada da mesma forma, três execuções por braço: com uma linha de status de 25 tokens no início do prompt do sistema, uma execução custou $4,24 USD em média ($4,12 USD a $4,47 USD entre as três execuções) e não leu nada do cache; com a mesma linha no fim do turno de usuário mais recente, após o último breakpoint de cache, uma execução custou $0,59 USD ($0,55 USD a $0,61 USD). O primeiro custa mais do que o mesmo job custou com o cache desativado. Uma reexecução posterior com a mesma configuração deu $4,28 USD e $0,61 USD.
19. **Medição de duração do cache no Claude Fable 5.1:** O mesmo job de triagem de 20 issues e o mesmo harness da referência 16, com `max_tokens` elevado para 4.096, executado em 23 e 26 de agosto de 2026, no snapshot de lançamento do Claude Fable 5.1 aos seus preços de lançamento ($10 USD de entrada, $12,50 USD de gravação de 5 minutos, $20 USD de gravação de 1 hora, $0,25 USD de leitura de cache, $50 USD de saída por milhão de tokens), três configurações por cronograma: o cache de 5 minutos, o cache de 1 hora e o cache de 5 minutos mantido aquecido por uma requisição com `max_tokens: 0` no prefixo inalterado a cada 4 minutos, contados a partir do início da requisição anterior (as execuções de 23 de agosto enviaram requisições de keep-alive com `max_tokens: 1`; nas células de 26 de agosto reportadas aqui, toda requisição de keep-alive respondida renovou o cache e sua resposta não reportou tokens de saída). Cronogramas: sem pausas, 10% dos turnos e todos os turnos com 6 minutos em todas as 20 issues, e pausas de 45 minutos no subconjunto de 5 issues; três execuções por célula (seis para a célula de keep-alive de 26 de agosto com pausas de 45 minutos), custo calculado a partir dos campos `usage` de cada resposta a preços de tabela, precisão em relação aos mesmos rótulos gold (12 a 18 rótulos exatos de 20). Médias por sessão em 26 de agosto para as configurações de 5 minutos, 1 hora e keep-alive: sem pausas $2,42 USD, $3,09 USD, $2,29 USD; 10% pausados $4,50 USD, $2,96 USD, $2,36 USD; todos os turnos $22,89 USD, $3,01 USD, $2,62 USD; as células de 23 de agosto concordam dentro de 6%. Os números de 45 minutos ($1,68 USD, $0,59 USD e $0,71 USD por sessão de 5 issues) são de sessões posteriores de 26 de agosto: o primeiro conjunto de sessões daquele dia foi interrompido quando sua máquina foi desligada, e o segundo foi afetado por uma falha no serviço e é deixado de lado. O terceiro conjunto dá os números de 5 minutos e 1 hora; suas três sessões de keep-alive enviaram cada requisição de keep-alive uma única vez, perderam requisições para recusas por "rate limit" (limite de taxa) e não estão na média. O número de keep-alive é a média de seis sessões adicionais que reenviaram qualquer requisição de keep-alive recusada em até dois segundos. As execuções de 23 de agosto deram $1,67 USD, $0,58 USD e $0,70 USD. O ponto de equilíbrio entre as configurações de 5 minutos e 1 hora é de 3,1% dos turnos, a mesma medida da referência 16. A leitura de cache do Claude Fable 5.1 custa 0,025x o preço de entrada, enquanto suas gravações de cache mantêm os multiplicadores padrão, então uma requisição de keep-alive que relê o prefixo é barata e o prêmio de gravação da duração de 1 hora é a conta maior, exceto com pausas de 45 minutos, em que as requisições de keep-alive custam mais do que o prêmio.
20. **Terminal-Bench 3:** as 74 tarefas do benchmark público de agentes de terminal, executadas no [Claude Managed Agents](https://platform.claude.com/docs/pt-BR/managed-agents/overview) com duas ferramentas personalizadas, um shell e um editor de arquivos que o harness de avaliação executa no próprio contêiner de cada tarefa, no lugar das ferramentas integradas da plataforma, e de resto nas configurações padrão da plataforma para contas externas, duas execuções por modelo com esforço `high`, de 27 a 28 de agosto de 2026. Essas execuções usaram a versão 3.0 do Terminal-Bench, e suas pontuações não são comparáveis com o leaderboard público do Terminal-Bench nem com os resultados do Terminal-Bench 4.0 no system card do Claude Opus 5.5, que vêm de execuções no Claude Code com esforço `max`. Os limites de tempo de cada tarefa são 2,5 vezes os do próprio benchmark, o que dá ao agente entre 75 minutos e 20 horas por tarefa (5 horas para a tarefa mediana), e cada tarefa recebe três vezes a memória que especifica, de 6 GiB a 96 GiB, com memória extra para as 12 tarefas que executam serviços auxiliares. O agente não tinha acesso geral à internet: seus contêineres podiam acessar um espelho interno de pacotes, uma lista curta de sites de download incluindo o GitHub e o Python Package Index, e alguns sites específicos de certas tarefas, e oito das tarefas não tinham nenhum acesso à rede. As pontuações são taxas brutas de aprovação sobre as 148 tentativas por modelo; execuções únicas oscilam de 5 a 11 pontos. Os custos são o que um cliente seria faturado a preços de tabela, reprecificados requisição por requisição a partir dos registros de uso das execuções com o tempo de vida de cache de 5 minutos. O Claude Opus 4.7, o Claude Opus 4.8 e o Claude Opus 5 gastam cada um de $8 USD a $15 USD por tarefa. O Claude Opus 4.7 encerrou 11 de suas 148 tentativas no seu limite de saída.
21. **DRACO:** Perplexity, "DRACO: a Cross-Domain Benchmark for Deep Research Accuracy, Completeness, and Objectivity," arXiv:2602.11685, 2026.
* **O que foi medido:** Suas 100 tarefas de pesquisa em 10 domínios são avaliadas segundo rubricas escritas por especialistas com cerca de 40 critérios ponderados cada, e a pontuação é a parcela ponderada de critérios atendidos, de 0 a 100.
* **Configurações:** Todas as configurações foram executadas na Claude API com o Claude Opus 5.5, o pensamento adaptativo padrão, os classificadores de segurança de produção ativados e `max_tokens` em 128.000 com streaming: um agente único com esforço `medium` (o padrão do modelo) e em `low`, o agente único em `medium` com a frase e o relógio, e uma equipe em `medium` com e sem eles. A equipe é um agente líder que pode iniciar agentes auxiliares do mesmo modelo por meio de uma ferramenta, sem limite para o seu número.
* **A frase:** As duas mudanças são uma frase e um relógio. A frase, "Time matters here: do not spend time that can be avoided, and the earlier a correct result is obtained, the better.", vai no fim da tarefa na primeira mensagem `user` do agente, após uma linha em branco, e no fim do briefing de cada auxiliar.
* **O relógio:** O relógio é o tempo decorrido em segundos inteiros, como `[elapsed 252s]`, adicionado antes de cada requisição, incluindo a primeira, ao fim da mensagem `user` mais recente: em seu próprio bloco de texto após a tarefa na primeira requisição, e no fim do texto do último resultado de ferramenta, após uma linha em branco, quando a mensagem carrega resultados de ferramentas. Os relógios anteriores permanecem no lugar, então o prefixo em cache ainda corresponde na próxima requisição. Todos os agentes de uma equipe leem o mesmo relógio, e o prompt do sistema não muda.
* **Nas execuções medidas:** As execuções medidas usaram essa redação e esse formato. Seu relógio começou no primeiro token da primeira resposta, e não no início da tarefa. Nas execuções de equipe medidas, o relatório de um auxiliar chegava ao líder em uma mensagem separada após o relógio, não dentro do último resultado de ferramenta.
* **Quando:** Cada configuração fez três tentativas em cada tarefa, com um limite de quatro horas por tentativa, executadas em 24 de setembro de 2026, e todas as configurações de um conjunto começaram juntas.
* **Ferramentas:** Os agentes usaram ferramentas de busca e fetch que o harness de avaliação hospeda sobre um índice web da Anthropic, e Python e um shell em um sandbox sem acesso à rede. Essas ferramentas determinam parte do tempo, e as suas serão executadas em uma velocidade diferente, então a página apresenta o tempo como uma razão entre configurações, não em minutos.
* **Como foi cronometrado:** O tempo é o tempo de relógio de uma tentativa, da sua primeira requisição ao fim da última requisição de qualquer agente, incluindo execuções de ferramentas, em média sobre as tentativas de uma tarefa. Um número de tarefa típica é a mediana, sobre as tarefas, da razão de cada tarefa entre duas configurações.
* **Como foi precificado:** O custo de cada tarefa são suas requisições precificadas aos preços de tabela públicos do Claude Opus 5.5, com o cache de prompt faturado como seria para um cliente que define um breakpoint de cache no fim de cada requisição e usa o tempo de vida de cache de 5 minutos. Cada requisição lê do cache o prompt da requisição anterior e grava o restante. A primeira requisição de uma tentativa, e qualquer requisição que comece mais de 5 minutos após a anterior, grava seu prompt inteiro. Os custos cobrem apenas tokens do modelo; as ferramentas do harness não acrescentam cobranças.
* **Como foi pontuado:** Todos os intervalos são intervalos bootstrap de 95% sobre as tarefas, e as mudanças de pontuação são diferenças pareadas sobre as tarefas. O Claude Opus 5 avalia as respostas, para que o Claude Opus 5.5 não avalie o próprio trabalho, e a pontuação de cada resposta faz a média de cinco execuções de julgamento.
* **Ressalvas:** Um classificador de segurança de produção interrompeu três tentativas em cada configuração, todas em uma mesma tarefa, e essas tentativas pontuam 0; deixar essa tarefa de fora não altera nenhuma conclusão. As execuções também passaram o uso de ferramentas de cada agente por uma verificação de segurança interna da Anthropic que as requisições de clientes não têm, o que acrescenta uma quantidade não medida de tempo a cada requisição em todas as configurações. No DRACO, o agente único sem as mudanças fez cerca do dobro de requisições, e a equipe cerca de um terço a mais, então a verificação provavelmente faz as economias de tempo do DRACO parecerem um pouco maiores.
* **Resultados, agente único:** Resultados para [Mostre ao modelo o tempo decorrido](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time): com as mudanças, o agente único levou 47% menos tempo com um custo 60% menor na tarefa típica, seu custo médio caiu de $1,13 USD para $0,44 USD por tarefa, e sua pontuação foi 4,1 pontos menor (intervalo de 95% de 2,9 a 5,2 a menos).
* **Resultados, esforço menor:** Reduzir o esforço do agente único economizou mais tempo e custo do que as mudanças, e perdeu mais pontuação. Com esforço `low`, pontuou 13,3 pontos a menos no DRACO, 3,4 no HLE e 14,0 no conjunto de física do que em `medium`, e a tarefa típica levou 84%, 30% e 47% menos tempo. Com as mudanças no esforço `medium`, pontuou 9,2, 2,5 e 11,0 pontos a mais do que em `low`, e a tarefa típica levou mais tempo do que em `low` por um fator de 1,2 a 3,2.
* **Resultados, equipe, auxiliares:** O líder da equipe raramente iniciava auxiliares. Sem as mudanças, iniciou um auxiliar em apenas 5 de 300 tentativas no DRACO, 13 de 1.479 no HLE e nenhuma de 280 no conjunto de física.
* **Resultados, equipe:** Assim, os resultados da equipe mostram principalmente o agente líder trabalhando sozinho, com as instruções e ferramentas próprias da equipe, e a Anthropic não tem nenhuma medição das mudanças em uma equipe que trabalha em paralelo. Sem as mudanças, a equipe já levava cerca de metade do tempo do agente único na tarefa típica do DRACO, e pontuou 3,3 pontos a menos (intervalo de 95% de 2,1 a 4,6 a menos). Com as mudanças, a equipe levou 17% menos tempo com um custo 20% menor na tarefa típica do DRACO, e pontuou 1,6 ponto a menos (intervalo de 95% de 0,3 a 2,8 a menos).
* **Não medido:** A Anthropic não mediu as mudanças no Claude Managed Agents.
22. **HLE:** Phan et al., "Humanity's Last Exam," arXiv:2501.14249, 2025. Perguntas escritas por especialistas com respostas exatas, avaliadas em relação às respostas de referência. Medido nas primeiras 500 perguntas da versão de 10 de setembro de 2025, imagens incluídas, com as próprias fontes do benchmark bloqueadas na busca, e a mesma configuração da referência 21. Cada configuração fez três tentativas em cada pergunta, executadas em 24 de setembro de 2026. O Claude Opus 5 compara cada resposta com a resposta de referência, usando o prompt de juiz publicado do benchmark, e vale a maioria de três julgamentos. As pontuações cobrem 493 perguntas em todas as configurações. Para cinco das outras, a requisição de avaliação ultrapassou o limite de 1M de tokens do juiz, e as outras duas ficam de fora porque a execução do agente único sem as mudanças parou antes que três de suas tentativas nelas terminassem. As razões de tempo e custo cobrem 492 perguntas para o agente único e 491 para a equipe, porque uma ou duas perguntas não têm cronometragem. Um classificador de segurança de produção interrompeu de 3% a 4% das tentativas de cada configuração, e essas tentativas pontuam 0; deixá-las de fora não altera nenhuma conclusão. Resultados para [Mostre ao modelo o tempo decorrido](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time): com as mudanças, o agente único levou 14% menos tempo com um custo 9% menor na pergunta típica. Com o juiz Claude Opus 5, sua pontuação não mostrou mudança clara (0,9 ponto a menos, intervalo de 95% de 2,5 a menos a 0,7 a mais). Com um segundo avaliador, o Claude Opus 4.6, sua pontuação foi 1,9 ponto menor (intervalo de 95% de 0,2 a 3,7 a menos). O tempo médio caiu mais do que o da pergunta típica: o tempo médio caiu 43% e o custo médio 37%, porque as mudanças encurtaram algumas perguntas muito longas. O tempo da equipe na pergunta típica mudou 3% ou menos, e sua pontuação não mudou claramente.
23. **Conjunto de física:** Um conjunto interno de 70 problemas de física de nível de pesquisa, adaptado do benchmark público CritPt: Zhu et al., "Probing the Critical Point (CritPt) of AI Reasoning: a Frontier Physics Research Benchmark," arXiv:2509.26574, 2025. Revisores especialistas corrigiram os enunciados dos problemas. O Claude Opus 4.6 avalia cada resposta com crédito parcial, usando o prompt de avaliação do conjunto, em relação a soluções de referência de especialistas que não são públicas, então as pontuações não podem ser comparadas com resultados publicados. A pontuação é a nota média sobre as tentativas de um problema, em média sobre os problemas, em pontos de 100. Medido em todos os 70 problemas, quatro tentativas por problema, executadas em 24 de setembro de 2026. Cada agente tinha uma ferramenta Python, um shell e um editor de arquivos em um contêiner sandbox sem acesso à rede, e nenhuma ferramenta de busca ou fetch. Nenhum classificador de segurança interrompeu uma tentativa no conjunto de física. De resto, a configuração é a da referência 21. Resultados para [Mostre ao modelo o tempo decorrido](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#show-the-model-elapsed-time): com as mudanças, o agente único levou 7% menos tempo com um custo 4% menor no problema típico, e sua pontuação foi 3,0 pontos menor (intervalo de 95% de 0,4 a 5,6 a menos). O tempo da equipe no problema típico mudou 3% ou menos, e sua pontuação não mudou claramente. O tempo médio do agente único caiu 14%. Toda a economia de tempo médio do agente único vem de um problema, no qual o agente sem as mudanças executou código por cerca de meia hora por tentativa; sem esse problema, seu tempo médio é aproximadamente o mesmo com e sem as mudanças.
24. **tau2-bench retail:** Barres et al., "τ²-Bench: Evaluating Conversational Agents in a Dual-Control Environment," arXiv:2506.07982, 2025.
* **O que foi medido:** As 114 tarefas do domínio de varejo foram executadas no harness público contra a Claude API, com o Claude Haiku 4.5 como usuário simulado, o Claude Sonnet 5 como juiz de linguagem natural e o cache de prompt ativado; as tarefas foram divididas em 57 de busca e 57 reservadas.
* **Quando:** As duas buscas foram executadas em 6 de setembro de 2026, conduzidas pelo comando `hillclimb` da skill Claude API. O par antes e depois do cache foi executado em 8 de setembro de 2026.
* **Como foi pontuado:** Nas buscas, os pontos de partida e a configuração confirmada são a média de três execuções reservadas, os passos mantidos foram julgados em duas execuções, e os outros candidatos foram pontuados em uma ou duas execuções. O par de cache: três execuções cada em todas as 114 tarefas com apenas os breakpoints de cache do harness alternados, a configuração que o comando `cost-optimize` produziu em uma execução anterior. Os números reservados são sobre 57 tarefas que a busca nunca leu.
* **Como foi precificado:** O custo por tarefa precifica as contagens de tokens do agente e do usuário simulado a preços de tabela (Claude Opus 5 $5 USD e $25 USD, Claude Sonnet 5 $2 USD e $10 USD por milhão de tokens de entrada e de saída, leituras e gravações de cache às suas taxas publicadas) e exclui o juiz; as variações percentuais vêm de custos não arredondados; o número mensal são apenas os tokens do agente, $0,135 USD e $0,047 USD por tarefa, vezes 10.000. Com 10.000 conversas por mês, isso dá cerca de $1.350 USD antes da primeira busca e $470 USD depois.
* **Ressalvas:** Essas medições foram executadas nos modelos Claude Opus e Claude Sonnet anteriores: o par de cache foi executado no Claude Sonnet 5, a segunda busca começou a partir do Claude Sonnet 5, e a primeira busca foi do Claude Opus 5 para o Claude Sonnet 5. O Claude Fable 5.1 não foi medido neste benchmark.
* **Par de cache:** O par foi executado no Claude Sonnet 5 no esforço padrão. O harness público, como distribuído, envia a conversa inteira sem cache a cada turno. A configuração com cache tem um breakpoint no prompt do sistema e um na mensagem mais recente. Ambas as buscas foram executadas com esse cache ativado. O custo por tarefa foi de $0,223 USD sem cache para $0,062 USD com cache, uma economia de 72%, e a taxa de aprovação de 79,2% para 76,0%. Execuções idênticas com cache dessa configuração variaram de 85 a 93 de 114 entre dias. Toda execução com cache pontuou igual ou abaixo de toda execução sem cache, mas a diferença de menos de 4 tarefas fica dentro da variação de execuções idênticas com cache, então a mudança de precisão é pequena demais para ser medida com este tamanho de amostra.
* **Como a busca foi executada.** O comando `hillclimb` faz quatro perguntas, apresenta um plano e espera aprovação antes de gastar qualquer coisa. Na primeira busca, o plano deixou inalterados o simulador de usuário, o avaliador, o cache, a temperatura e as tarefas. A última das quatro perguntas começava: `One pass over the full set is 114 cases x 1 rep on claude-opus-5, roughly 22 minutes.` A cada rodada, a busca propõe uma mudança e executa o conjunto completo. Ela mantém a mudança apenas quando o número se moveu e o mecanismo previsto aparece nos dados de uso. Ela para quando três rodadas seguidas não trazem nada, e então confirma o vencedor em execuções novas.
* **Primeira busca, resultado.** A busca reduziu o custo por tarefa em 61% mantendo a taxa de aprovação dentro de uma faixa de 2 pontos definida antes da busca: do Claude Opus 5 no esforço padrão ($0,142 USD por tarefa, 76,0% aprovadas) para o Claude Sonnet 5 em `low` com uma edição de prompt neutra em custo ($0,055 USD, 74,3%). A busca custou $179 USD em execuções de avaliação e $228 USD em seus próprios tokens.
* **Primeira busca, início: Claude Opus 5, esforço padrão.** 76,0% a $0,142 USD. Três execuções idênticas variaram de 43 a 44 de 57. A busca definiu o piso 2 pontos abaixo, em 74,0%, e o arredondou para cima para 43 de 57 (75,4%) para seus veredictos.
* **Primeira busca, passo 1, esforço para `low`: mantido.** 77,2% nas duas execuções que o mantiveram, 77,8% em uma confirmação de três execuções após a busca, a $0,119 USD, 17% mais barato. A própria linha de status da busca diz, em parte: `two runs held-out 42 and 46, mean 44.0 >= floor 43; cost mean $0.1187 <= gate $0.1208; mechanism confirmed (output tokens -34% with calls flat)`.
* **Primeira busca, passo 2, Claude Sonnet 5 em `low`: mantido.** 75,4% a $0,055 USD, 61% mais barato.
* **Primeira busca, passo 3, uma edição de prompt (consultar os pedidos do cliente após o login em vez de pedir um ID de pedido): mantida na seleção, depois não se sustentou.** 79,8% em duas execuções; 74,3% em três execuções novas. A busca a deixou como neutra em custo: o turno liberado virou outro turno de consulta.
* **Primeira busca, passo 4, uma edição de prompt (transferir para um humano apenas quando solicitado): rejeitada e revertida.** 71,9%. Corrigiu os 3 casos que visava e quebrou outros 10 com um template genérico de "diga o que você pode e não pode fazer".
* **Primeira busca, passo 5, uma edição de prompt: não executada.** Seu ganho previsto de 0,5 tarefa ficou abaixo do critério de adoção de 2 tarefas da busca.
* **Primeira busca, confirmação: Claude Sonnet 5 em `low` com o prompt do passo 3, três execuções novas.** 74,3% a $0,055 USD, dentro da faixa de 2 pontos por 0,14 de uma tarefa, 1 tarefa em 57 abaixo do início, e abaixo do piso de 43 de 57 que a busca registrou. As cinco execuções dessa configuração variaram de 42 a 46, mais amplo do que os 43 a 44 do início.
* **Primeira busca, o que mostrou.** As alavancas de esforço e de modelo produziram as economias, e o mecanismo de cada uma as confirmou. A alavanca de prompt produziu mudanças reais de comportamento, mas nenhum ganho duradouro. Nesta carga de trabalho, o número de turnos e o prefixo em cache que cada turno relê determinam o custo por tarefa, não a redação.
* **Segunda busca.** Começou a partir do Claude Sonnet 5 no esforço padrão com o cache ativado: 79,5% a $0,062 USD na metade reservada, com três execuções variando de 42 a 47 de 57, então o piso foi 45 de 57 (78,9%). Execuções idênticas de uma configuração inicial diferiram em até 5 tarefas em 57 aqui. A segunda busca não manteve nada. Esforço em `low`, duas edições de prompt e ambos juntos pontuaram cada um 77,2%, abaixo do piso, e economizaram de 10% a 14%, aquém do critério de custo de 15% da busca. Uma edição de prompt para precisão pontuou 79,8% em duas execuções e 73,7% em três execuções novas, e foi revertida. A busca levou cerca de 19 execuções de avaliação e $120 USD.
25. **Conjunto de tarefas do Claude Managed Agents:**
* **O que foi medido:** Um conjunto interno da Anthropic de 79 tarefas de agente roteirizadas em oito áreas, incluindo memória, multiagente e trabalho de contexto longo, executadas como sessões do [Claude Managed Agents](https://platform.claude.com/docs/pt-BR/managed-agents/overview) nas quais o teste responde a cada chamada de ferramenta. Cada tarefa foi executada cinco vezes por modelo.
* **Execuções:** Os números são de uma execução por modelo em 7 de outubro de 2026, avaliada naquele dia. Em mais três execuções das mesmas tarefas em 8 e 9 de outubro de 2026, o Claude Haiku 5.5 passou em 91% a 93% das tentativas, e em mais uma execução em 8 de outubro, o Claude Haiku 4.5 passou em 63%.
* **Como foi pontuado:** Uma tentativa passava apenas se o avaliador, o Claude Sonnet 4.6, avaliando uma vez, marcasse cada linha da checklist da tarefa como atendida, então as taxas de aprovação dependem do avaliador. Em todas as tarefas exceto uma, uma chamada separada, que recebia os resultados de ferramentas completos, avaliava a linha que verifica os arquivos e mensagens que o agente escreveu por meio de suas ferramentas em relação a esses resultados.
* **Como foi precificado:** Os custos são custos de tokens a preços de tabela com cache de prompt de 5 minutos, precificados requisição por requisição, e excluem o tempo de execução da sessão.
* **Resultados, preços de tokens e custo:** O Claude Haiku 4.5 não fez cache de 80% de suas requisições: cada uma tinha um prompt de cerca de 4.100 tokens ou menos, e seu comprimento mínimo de prompt armazenável em cache é de 4.096 tokens (512 para o Claude Haiku 5.5). Do Claude Haiku 4.5 para o Claude Haiku 5.5, os preços de tokens caíram até 90%, e o custo de tokens das 79 tarefas caiu cerca de 75%. O custo de tokens caiu menos do que os preços porque cerca de 5% das requisições do Claude Haiku 5.5 tinham prompts acima de 100.000 tokens, que pagam preços mais altos ([Preços de contexto longo](https://platform.claude.com/docs/pt-BR/about-claude/pricing#long-context-pricing)), e elas responderam por 73% do seu custo.
* **Pensamento:** A Anthropic definiu o esforço do Claude Haiku 5.5 como `medium` e não enviou nenhuma configuração de pensamento nem limite de saída para nenhum dos modelos, então o pensamento ficou a cargo das próprias configurações do Claude Managed Agents para cada modelo. O Claude Haiku 5.5 usou pensamento em 59% das requisições, e o Claude Haiku 4.5 em 22%. A comparação é de cada modelo como servido, não em configurações iguais.
* **Custo sem cache, precificado a partir das contagens de tokens registradas:** A Anthropic também reprecificou as contagens de tokens registradas da execução de 7 de outubro do Claude Haiku 5.5 para o fator de cache em [Por que o cache vem primeiro](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#why-caching-comes-first); não fez nenhuma execução com o cache desativado, e o Claude Managed Agents aplica o cache de prompt por conta própria, então o fator compara dois preços para as mesmas requisições, não duas configurações.
* **O fator:** O fator, 1,7, é o custo de tokens da execução com todo token de entrada ao preço de entrada, tokens de saída inalterados, dividido pelo seu custo de tokens com cada sessão precificada isoladamente: o prompt anterior de cada requisição como leitura de cache e seus novos tokens como gravação de cache de 5 minutos. Cada requisição é precificada pelo comprimento do seu próprio prompt em ambos os custos, então as 87 requisições acima de 100.000 tokens pagam os preços mais altos em ambos. Nas contagens de tokens como registradas, que os custos deste guia para a execução usam, o fator é 1,9, porque as cinco tentativas de uma tarefa foram executadas lado a lado e leram as entradas de cache umas das outras.
* **Por que o fator é baixo:** O fator é baixo porque as sessões são curtas, uma mediana de 4 requisições: a maioria dos tokens de entrada chega como resultados de ferramentas na segunda ou terceira requisição e é lida do cache apenas uma ou duas vezes. Oito tarefas de contexto longo concentram três quartos do custo. Uma segunda execução, em 8 de outubro, também dá 1,7.
26. **Medição de formato de resposta:**
* **O que foi medido:** O job de triagem de 20 issues de [Corte tokens de entrada e de contexto](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), executado no Claude Sonnet 5 com o cache de prompt ativado e nenhuma configuração de pensamento na requisição, então o pensamento ficou no padrão do modelo, sob três instruções de resposta final, três execuções por instrução.
* **Instrução de duas linhas:** A original pedia duas linhas: `4. Finish with exactly two lines: LABEL: SUMMARY: `
* **Instrução de uma linha:** A variante mais curta pedia uma: `4. Finish with exactly one line in this form: DECISION | LABEL | REASON where DECISION is one of: triage-now, needs-info, close-duplicate; LABEL is one of: bug-confirmed, needs-more-info, duplicate-candidate, feature-request, upstream-issue, perf, ui-polish; REASON is one clause under 15 words. Output nothing after that line.`
* **Instrução de memorando:** A variante mais longa pedia um memorando com seis seções com títulos: resumo do problema, evidências, verificação de duplicatas, rótulo recomendado, próximos passos e confiança.
* **Também nas instruções como enviadas:** Como enviada, a instrução de duas linhas também dizia "Be concise." e a instrução de memorando "Be thorough and explicit."
* **Quando:** As instruções de duas linhas e de uma linha foram executadas em 18 de agosto de 2026, com `max_tokens` em 700, e a instrução de memorando em 19 de agosto de 2026, com `max_tokens` em 3.000. Nenhuma resposta atingiu seu limite.
* **Como foi pontuado e precificado:** Os números são a média das três execuções aos preços de tabela do Claude Sonnet 5, e a precisão é a correspondência exata com os rótulos gold.
* **Resultados:** A resposta de uma linha usou 39% menos tokens de saída do que a original de duas linhas e custou 14% menos por execução (a partir dos custos arredondados do gráfico, $0,49 USD e $0,57 USD; as médias não arredondadas dão 13%). O memorando usou seis vezes os tokens de saída da original de duas linhas e custou 2,8 vezes a resposta de uma linha.
* **Pensamento:** Cerca de metade das respostas incluiu pensamento, e seus tokens são contados nos tokens de saída.
27. **Medição de busca de ferramentas:**
* **O que foi medido:** O job de triagem de 20 issues de [Corte tokens de entrada e de contexto](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens), executado no Claude Sonnet 5 em 19 de agosto de 2026, com o cache de prompt ativado e nenhuma configuração de pensamento na requisição, então o pensamento ficou no padrão do modelo, três execuções por configuração. O agente tinha suas próprias duas ferramentas mais definições reais de ferramentas de servidores MCP públicos, para um total de 7, 17, 52, 102, 252 ou 502 ferramentas, com todas as definições carregadas ou com as adicionadas marcadas com `defer_loading` por trás da busca de ferramentas.
* **Como foi pontuado e precificado:** Os números são a média das três execuções aos preços de tabela do Claude Sonnet 5, e a precisão é a correspondência exata com os rótulos gold.
* **Resultados:** Com todas as definições carregadas, o custo da execução subiu de $0,55 USD com 7 ferramentas para $1,02 USD com 502 ferramentas, quase o dobro. Com a busca de ferramentas, ficou entre $0,55 USD e $0,56 USD em todos os tamanhos de catálogo, 45% menos com 502 ferramentas (a partir dos custos arredondados do gráfico, $0,56 USD e $1,02 USD; as médias não arredondadas dão 45,6%). Todas as execuções responderam corretamente de 15 a 18 das 20 issues, com ou sem busca de ferramentas.
* **Ressalvas:** Nenhuma execução chamou uma ferramenta do catálogo ou a ferramenta de busca de ferramentas: as duas ferramentas próprias do agente estavam sempre carregadas, e toda chamada de ferramenta foi para uma delas. A medição mostra quanto custa carregar definições não usadas, não se a busca de ferramentas encontra uma ferramenta quando ela é necessária.
* **Medição separada:** Em uma medição separada no mesmo modelo e data, com um servidor MCP público do GitHub conectado pelo conector MCP e sem catálogo, três execuções com o conjunto de ferramentas do servidor adiado custaram 20% menos do que três execuções sem ($0,56 USD e $0,70 USD por execução), e as três execuções de cada braço responderam corretamente 17, 16 e 16 issues. As requisições nesta medição separada não incluíram nenhuma ferramenta de busca de ferramentas. Com o conjunto de ferramentas carregado, cada execução chamou uma das ferramentas do servidor, `issue_read`, 3 ou 4 vezes; com ele adiado, nenhuma execução chamou nenhuma das ferramentas do servidor.
28. **Medições de redução de entrada e de ciclo de vida do contexto:**
* **O que foi medido:** O job de triagem de 20 issues de [Corte tokens de entrada e de contexto](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#trim-input-and-context-tokens) e sua variante longa, executados no Claude Sonnet 5 em 19 de agosto de 2026 (datado em UTC), três execuções por configuração, sem nenhuma configuração de pensamento na requisição, então o pensamento ficou no padrão do modelo; cerca de 3 em cada 10 respostas incluíram pensamento.
* **O gráfico:** O gráfico em [Gerencie o ciclo de vida do contexto](https://platform.claude.com/docs/pt-BR/about-claude/models/optimizing-for-cost-and-intelligence#manage-the-context-lifecycle) compara quatro configurações em cada job: o job com cache de prompt e redução de entrada (redimensionamento de imagens e busca de ferramentas) ativados, e o mesmo com uma alavanca adicionada, que é edição de contexto, compactação ou a poda. O gráfico conta uma mudança de menos de 10% como nenhuma mudança.
* **Configurações das alavancas:** As configurações das alavancas diferiram entre os dois jobs: a edição de contexto limpava pelo menos 2.000 tokens quando o prompt passava de 20.000 no job de 20 issues, e pelo menos 40.000 quando passava de 50.000 no longo, mantendo os três usos de ferramentas mais recentes, e a compactação disparava com 50.000 tokens de entrada no job de 20 issues e 80.000 no longo.
* **Como foi precificado:** Cada custo é a média das três execuções, a partir dos campos de uso das respostas aos preços de tabela do Claude Sonnet 5, com gravações de cache a $2,50 USD e leituras de cache a $0,20 USD por milhão de tokens.
* **Resultados, redução de entrada:** Uma quinta configuração, cache de prompt sem redução de entrada, custou $0,57 USD por execução no job de 20 issues e $1,38 USD no longo, então a redução de entrada cortou 26% do primeiro e 21% do segundo. Em comparação com o mesmo job de 20 issues com o cache desativado, que custou $3,36 USD por execução (referência 16), o cache de prompt e a redução de entrada juntos economizaram 88% (as médias não arredondadas dão 87,5%).
* **Resultados, execução de 20 issues:** Na execução de 20 issues, em que o job sem alavanca custou $0,42 USD por execução, a edição de contexto custou 73% a mais, a compactação foi executada uma vez perto do fim de cada execução e custou 7% a menos, e a poda não reescreveu nada, porque nenhum resultado de busca ultrapassou seu limite de 2.000 caracteres.
* **Resultados, execução longa:** Na execução longa, em que o job sem alavanca custou $1,09 USD por execução, a poda custou 39% a menos, a compactação 32% a menos e a edição de contexto 4% a mais.
* **Leituras de cache, execuções longas:** Nas execuções longas com a poda, 89% dos tokens de prompt foram lidos do cache na primeira requisição após um limite de tarefa e 81% nas outras requisições. Ao longo de todas as execuções longas, 85% dos tokens de prompt foram lidos do cache com a poda e 85% com a edição de contexto, contra 95% sem alavanca.
## Próximos passos
O maior ganho gratuito desta página: configuração, tempos de vida e diagnósticos.
Troque inteligência por latência e custo dentro de um único modelo.
Avalie capacidade, velocidade e custo em toda a família de modelos Claude.
Coloque um limite rígido em dólares em uma sessão do Managed Agents.
Veja os preços atuais por token para cada modelo Claude.
Aplique essas alavancas uma de cada vez a um agente funcional em um notebook executável, com custo por tarefa após cada etapa.
Assista a um passo a passo dos padrões de advisor e orquestrador.