Dá para trocar o Sonnet pelo Claude Haiku 5.5? Como testar o downgrade nas suas tarefas antes de cortar custo

Fala aí, beleza? Teu pipeline de alto volume roda no Sonnet 5.5 (claude-sonnet-5-5), lançado em 28 de setembro de 2026, e a fatura no fim do mês já começou a pesar, né?

Em 7 de outubro de 2026 a Anthropic soltou o Haiku 5.5, e a pergunta mudou de lado: em vez de subir de modelo, dá pra DESCER sem quebrar o que já funciona?

O método é direto: tarefas reais, critério de acerto e custo lado a lado

Só que aqui ele serve pra cortar custo, não pra migrar pro modelo mais forte 🙂

O que você precisa antes de testar o Haiku 5.5 no lugar do Sonnet

São quatro coisas, e nenhuma delas é exótica:

• Acesso a um provedor com o Haiku 5.5: a Claude API da Anthropic, o Amazon Bedrock, o Google Cloud ou o Microsoft Foundry/Azure. O identificador é claude-haiku-5-5 na Claude API, no Google Cloud e no Foundry, e anthropic.claude-haiku-5-5 no Bedrock
• O SDK da Anthropic: é por ele que tu chama o método count_tokens, que vai ser peça central do teste. Se liga: todo o passo a passo abaixo (o anthropic.Anthropic() e o endpoint https://api.anthropic.com/v1/messages/count_tokens) é da Claude API. Se tu acessa o Haiku 5.5 pelo Bedrock, pelo Google Cloud ou pelo Foundry, a forma de chamar muda, então confere na documentação do teu provedor antes de adaptar os exemplos
• Um gabarito: um conjunto de entradas reais do teu pipeline com a resposta certa já conhecida
• O código atual que chama o Sonnet 5.5: o teste é trocar uma peça e comparar, então tu precisa do ponto de partida funcionando

Sem gabarito não tem teste, tem impressão

E impressão de modelo barato costuma enganar pros dois lados…

Passo a passo para testar o downgrade do Sonnet para o Haiku 5.5

Os exemplos de código abaixo são didáticos, pra tu adaptar ao teu projeto: não são resultado de teste executado

1. Escolha as tarefas candidatas e separe uma por uma

A própria Anthropic indica o Haiku 5.5 pra trabalho de alto volume e sensível a latência: classificação, roteamento, extração e tarefas de subagente

Então começa por aí: liste as tarefas do pipeline que são classificação, extração ou resumo e trate cada uma como um teste separado

Se tua tarefa principal é separar registros em categorias, o post sobre classificar registros em volume com o Haiku 5.5 complementa bem este passo

Exemplo didático de gabarito em JSONL, uma linha por caso:

{"tarefa": "classificacao", "entrada": "Quero meu dinheiro de volta, o produto veio quebrado", "esperado": "reembolso"}
{"tarefa": "extracao", "entrada": "Pedido 4821, cliente Ana Souza, data 12/09", "esperado": {"pedido": "4821", "cliente": "Ana Souza", "data": "12/09"}}

Resultado esperado: um arquivo de casos por tarefa, com entradas tiradas do tráfego real

O erro comum deste passo: avaliar o pipeline inteiro como um bloco e sair com um número só. A classificação pode passar lisa enquanto o resumo afunda, e a média esconde isso

2. Defina o critério de acerto e a taxa mínima antes de rodar

Pra cada tarefa, decide DUAS coisas: o que conta como acerto e quantos acertos são o mínimo aceitável

Na classificação, acerto pode ser a categoria idêntica à do gabarito

Na extração, todos os campos batendo

No resumo, uma lista de pontos que precisam aparecer

A taxa mínima não tem número padrão: ela sai do custo do erro no teu negócio. Errar a categoria de um ticket de suporte custa uma coisa, errar um valor extraído de nota fiscal custa outra bem diferente

Resultado esperado: uma linha por tarefa com critério e taxa mínima escritos

O erro comum deste passo: escolher o limiar depois de ver o resultado. Aí o teste vira justificativa da decisão que tu já queria tomar haha

3. Reconte os prompts com o count_tokens nos dois modelos

Por que recontar? Porque o Haiku 5.5 usa o tokenizer mais novo, o mesmo dos modelos Claude 4.7 em diante

Segundo a Anthropic, o mesmo texto gera cerca de 30% mais tokens do que no Haiku 4.5, e o Simon Willison mediu algo em torno de 1,25 vez. Se tu quer o panorama completo, tem o post sobre o que muda no Haiku 5.5

E com o Sonnet 5.5? Não assuma que a contagem é igual: conta nos dois

O endpoint de contagem de tokens conta antes de enviar, pelo método count_tokens do SDK ou por POST em https://api.anthropic.com/v1/messages/count_tokens. Ele aceita system prompt, tools, imagens e PDFs, e todos os modelos ativos têm suporte

Exemplo didático:

import anthropic

client = anthropic.Anthropic()

SYSTEM = "Classifique o ticket em: reembolso, duvida, reclamacao"
entrada = "Quero meu dinheiro de volta, o produto veio quebrado"

for modelo in ["claude-sonnet-5-5", "claude-haiku-5-5"]:
    r = client.messages.count_tokens(
        model=modelo,
        system=SYSTEM,
        messages=[{"role": "user", "content": entrada}],
    )
    print(modelo, r.input_tokens)

Resultado esperado: uma contagem de entrada por modelo, pra cada prompt do gabarito

O erro comum deste passo: mandar pra contagem algo que ela não aceita. Server tools (web search, web fetch, code execution, tool search), MCP connector e blocos de imagem ou documento com fonte url ou file retornam invalid_request_error. Caso este erro apareça, confere se não tem um desses no request

4. Cheque o degrau de preço acima de 100 mil tokens

Aqui mora a pegadinha do Haiku 5.5, se liga

Até 100 mil tokens de prompt, ele custa US$ 0,10 por milhão de entrada e US$ 0,50 por milhão de saída

Quando o prompt passa de 100.000 tokens, a requisição INTEIRA passa a ser cobrada a US$ 0,50 de entrada e US$ 2,50 de saída por milhão, ou seja, 5 vezes mais, cache reads incluídos

E isso é exceção: na tabela de preços, os modelos Claude 4.6 e posteriores têm a janela de 1M tokens a preço padrão, sem adicional por contexto longo, menos o Haiku 5.5. O Sonnet 5.5, por exemplo, fica em US$ 2 de entrada e US$ 10 de saída por milhão em toda a janela de 1M

Na tabela, por milhão de tokens, a vantagem do Haiku encolhe de 20 vezes pra 4 vezes quando cruza a linha

O perigo real é o prompt que no Sonnet parecia confortável, com RAG ou histórico de conversa, e que depois do tokenizer novo passa dos 100 mil

Exemplo didático pra marcar os casos de risco:

LIMITE_DEGRAU = 100_000

def cruza_degrau(contagem_haiku: int) -> bool:
    return contagem_haiku > LIMITE_DEGRAU

Resultado esperado: cada caso do gabarito marcado como abaixo ou acima do degrau, usando a contagem do Haiku

O erro comum deste passo: projetar o custo só pela tabela de até 100 mil. Tome cuidado, porque é exatamente nos prompts mais longos que a conta muda

5. Adapte a chamada para o Haiku 5.5

O guia de migração lista o que muda: trocar o ID pra claude-haiku-5-5, recontar os prompts (já feito no passo 3), mudar a configuração de thinking de enabled pra adaptive, selecionar os blocos da resposta pelo type e remover temperature, top_p e top_k

Por que remover? Porque no Haiku 5.5 o temperature só pode ser 1 e o top_p só pode ser 0,99 (o padrão). Qualquer outro valor, qualquer top_k ou mandar temperature e top_p juntos devolve erro 400

E tem outro detalhe: o adaptive thinking vem ligado por padrão, então a resposta pode começar com um ou mais blocos de thinking mesmo sem tu pedir

Exemplo didático:

resp = client.messages.create(
    model="claude-haiku-5-5",
    max_tokens=1024,
    thinking={"type": "adaptive"},
    system=SYSTEM,
    messages=[{"role": "user", "content": entrada}],
)

# pega só os blocos de texto, ignorando os de thinking
texto = "".join(b.text for b in resp.content if b.type == "text")

Resultado esperado: a mesma chamada do teu pipeline, agora apontando pro Haiku 5.5, sem erro 400 e com a resposta lida do bloco certo

O erro comum deste passo: ler resp.content[0] como resposta. Se o primeiro bloco for thinking, tu vai comparar o raciocínio do modelo com o gabarito e marcar erro onde talvez nem tenha 😛

6. Ajuste o effort antes de dar o veredito

O Haiku 5.5 é o primeiro Haiku com o parâmetro effort e com adaptive thinking

O effort troca qualidade da resposta por velocidade e custo, nos níveis low, medium, high, xhigh e max

Na prática: se a nota de uma tarefa ficou raspando no limite, roda a mesma tarefa em mais de um nível antes de decidir. A forma exata de passar o parâmetro está na documentação do modelo

Resultado esperado: pra tarefa no limite, uma nota por nível de effort testado

O erro comum deste passo: julgar o modelo por um único nível. Às vezes a tarefa só precisava de um degrau a mais de effort, às vezes dá pra descer e economizar ainda mais

7. Rode lado a lado e calcule o custo por mil chamadas

Agora sim, roda o gabarito nos dois modelos e registra, por tarefa:

• nota contra o gabarito
• tokens de entrada e de saída reais, os que voltam no usage da resposta
• latência de cada chamada
• custo por mil chamadas

A fórmula do custo é simples: tokens médios x preço por milhão x 1.000 / 1.000.000, somando entrada e saída

Exemplo didático com os preços da tabela:

import time

# US$ por milhão de tokens: (entrada, saída)
PRECOS = {
    "claude-sonnet-5-5": (2.00, 10.00),
    "claude-haiku-5-5": (0.10, 0.50),  # prompt de até 100 mil tokens
}
HAIKU_ACIMA_100K = (0.50, 2.50)

def chamar_e_medir(modelo, **kwargs):
    inicio = time.perf_counter()
    resp = client.messages.create(model=modelo, **kwargs)
    latencia = time.perf_counter() - inicio
    return resp, latencia, resp.usage.input_tokens, resp.usage.output_tokens

def custo_por_mil(modelo, media_entrada, media_saida, acima_100k=False):
    p_in, p_out = PRECOS.get(modelo)
    if modelo == "claude-haiku-5-5" and acima_100k:
        p_in, p_out = HAIKU_ACIMA_100K
    return (media_entrada * p_in + media_saida * p_out) * 1000 / 1_000_000

Dois ajustes que podem mudar a conta:

• Message Batches API: cobra 50% do preço padrão. Pra tarefa que não é sensível a latência, vale calcular as duas versões
• Cache no Haiku 5.5: leitura a US$ 0,01 por milhão e escrita de cache de 5 minutos a US$ 0,125 por milhão, valores que viram US$ 0,05 e US$ 0,625 acima de 100 mil tokens. O preço de cache do Sonnet 5.5 tu confere na página de preços antes de comparar

Resultado esperado: números de nota, tokens, latência e custo por tarefa e por modelo, todos vindos das tuas chamadas

O erro comum deste passo: comparar preço por milhão de tokens em vez de custo por tarefa. O mesmo texto pode virar mais tokens no Haiku 5.5, então só o custo por tarefa (ou por mil chamadas) mostra a economia de verdade

Checagem final:

No fim tu precisa ter uma planilha com uma linha por tarefa e por modelo, com estas colunas:

• tarefa
• modelo (e nível de effort, se testou mais de um)
• nota e taxa mínima definida no passo 2
• casos acima de 100 mil tokens
• latência média
• custo por mil chamadas

Com isso na mão, a decisão fica quase mecânica 😀

Regra de decisão: quando manter o Sonnet 5.5 e quando trocar pelo Haiku 5.5

A regra é por tarefa, nunca pelo pipeline inteiro

Vai pro Haiku 5.5 a tarefa que atingiu a taxa mínima E teve o custo por mil chamadas caindo de verdade, já com o tokenizer novo e o degrau de 100 mil considerados

Fica no Sonnet 5.5 a tarefa que falhou no critério, ou que só passa com prompt acima de 100 mil tokens a ponto de anular a economia

Pipeline misto é normal: classificação e extração no Haiku, resumo pesado no Sonnet, e por aí vai

E um cuidado com os números de marketing: a Anthropic declara preço nominal 90% menor que o do Haiku 4.5 em requisições de até 100 mil tokens e custo médio de execução cerca de 75% menor, já descontado o tokenizer

Essa comparação é contra o Haiku 4.5, não contra o Sonnet, e é uma média, não garantia pro teu caso

Quem decide é a tua planilha 🙂

O Haiku 5.5 em ação

Se tu quer ver o Claude Haiku 5.5 gerando coisa de verdade antes de botar ele no teu pipeline, tem um vídeo no canal sobre o lançamento, com um jogo 3D, um sistema com login e uma landing page, cada um feito num prompt

Próximo passo: rode o teste com uma tarefa antes de mexer no pipeline

Não precisa testar tudo de uma vez

Pega a tarefa de maior volume e mais simples, geralmente classificação ou extração, e monta o gabarito dela com entradas reais

Conta os tokens com o count_tokens nos dois modelos, roda o comparativo lado a lado e só então troca o ID em produção

E antes de bater o martelo, reconfere preços e recursos: tudo o que está aqui é da documentação da Anthropic em outubro de 2026, e tabela de preço muda

Bons testes e até o próximo post!

Quer aprender mais sobre inteligência artificial e programação na prática? Conheça o canal Hora de Codar no YouTube e acompanhe os próximos vídeos.