Prompts mais curtos custam menos, deixam mais da janela de contexto para o trabalho de verdade e costumam devolver o primeiro token mais cedo. Mas “encurte o prompt” é um conselho vago. Este post mede cortes comuns num prompt realista de um bot de atendimento, com os tokenizers reais de quatro modelos abertos e com o o200k_base da OpenAI, para você ver quais edições valem o seu tempo.
Se você usa um agente de código, o orçamento de tokens de um agente cobre esse loop. Este post é sobre prompts de aplicação: chatbots, classificadores e jobs de extração.
Como medimos?
Todas as contagens abaixo são nossas, feitas em 15 de novembro de 2026:
- Tokenizers. Os arquivos
tokenizer.jsonoficiais do DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B e do Gemma 4 26B A4B do Google, cada um numa revisão fixa do Hugging Face (veja as Fontes), carregados comtokenizers0.23.3 do Hugging Face. Mais oo200k_basedotiktoken0.14.0, para comparar com os modelos GPT. Tokens especiais não foram adicionados. - Prompts renderizados. Para DeepSeek, GLM e Qwen, também renderizamos requisições completas com o
chat_template.jinjapublicado de cada modelo (sandbox do Jinja2), com prompt de sistema, ferramentas, histórico e pergunta, e contamos o resultado. Isso fica perto do que um servidor tokeniza, mas um provedor pode usar outro template, então a palavra final é ousage.prompt_tokensda API. - Texto. Um bot de atendimento sintético para uma operadora de telefonia fictícia: um prompt de sistema de 261 palavras, 10 ferramentas, 8 exemplos few-shot, 40 linhas de pedidos, um histórico de 20 turnos e um parágrafo em árabe de 31 palavras. Um prompt é um único dado. A sua economia vai ser diferente; o método continua valendo.
O Gemma 4 VL 26B da BroadNet é baseado no modelo do Google, então a contagem dele é uma estimativa. Os outros usam os arquivos dos próprios modelos.
Quais cortes economizam mais tokens?
Texto cru, antes → depois, com a parcela economizada:
| Mudança | DeepSeek V4.1 Flash | GLM 5.3 | Qwen3.8 27B | Gemma 4 | GPT o200k |
|---|---|---|---|---|---|
| Prompt de sistema: 261 palavras → 66 palavras | 295 → 88 (70%) | 294 → 89 (70%) | 297 → 95 (68%) | 297 → 96 (68%) | 293 → 86 (71%) |
| Few-shot: 8 exemplos → 3 | 157 → 69 (56%) | 157 → 69 (56%) | 156 → 71 (54%) | 156 → 71 (54%) | 152 → 69 (55%) |
| 40 linhas: JSON indentado → JSON minificado | 2.446 → 1.606 (34%) | 2.460 → 1.581 (36%) | 3.180 → 1.980 (38%) | 3.210 → 2.010 (37%) | 2.446 → 1.567 (36%) |
| 40 linhas: JSON minificado → CSV | 1.606 → 948 (41%) | 1.581 → 960 (39%) | 1.980 → 1.359 (31%) | 2.010 → 1.382 (31%) | 1.567 → 946 (40%) |
| 10 ferramentas: descrições prolixas → curtas | 1.224 → 806 (34%) | 1.214 → 797 (34%) | 1.225 → 806 (34%) | 1.252 → 827 (34%) | 1.202 → 796 (34%) |
| 10 ferramentas prolixas → 3 curtas | 1.224 → 258 (79%) | 1.214 → 257 (79%) | 1.225 → 266 (78%) | 1.252 → 276 (78%) | 1.202 → 255 (79%) |
| Parágrafo em árabe: totalmente vocalizado → simples | 193 → 74 (62%) | 267 → 78 (71%) | 151 → 62 (59%) | 180 → 64 (64%) | 218 → 62 (72%) |
Para prosa em inglês, as porcentagens são parecidas entre os tokenizers, então um corte que ajuda num modelo ajuda nos outros. Duas linhas quebram esse padrão. Os dados de pedidos custaram ao Qwen e ao Gemma de 23 a 46% mais tokens que ao DeepSeek e ao GLM em todos os formatos, porque os tokenizers deles quebram números em dígitos individuais: 100200 são 6 tokens no Qwen e 2 no DeepSeek. E os diacríticos árabes pesam muito mais em alguns tokenizers que em outros.
Como fica uma requisição inteira?
O texto cru não inclui o chat template. Renderizado pelo template de cada modelo, com a mesma pergunta do cliente, o prompt completo medido fica assim:
| Requisição | DeepSeek V4.1 Flash | GLM 5.3 | Qwen3.8 27B |
|---|---|---|---|
| A. Prompt de sistema prolixo + 10 ferramentas prolixas | 1.677 | 1.535 | 1.797 |
| B. Prompt de sistema enxuto + 10 ferramentas curtas | 1.052 | 913 | 1.176 |
| C. Prompt de sistema enxuto + 3 ferramentas curtas | 574 | 443 | 636 |
| D. Prompt de sistema enxuto, sem ferramentas | 136 | 121 | 174 |
| C + 20 turnos anteriores completos | 2.374 | 2.243 | 2.693 |
| C + resumo de 3 linhas + últimos 4 turnos | 979 | 849 | 1.103 |
Ir de A para C cortou cerca de 65 a 71% de cada requisição (64,6% no Qwen, 71,1% no GLM). A maior parte veio das ferramentas. Renderizadas com o prompt de sistema prolixo, as 10 ferramentas prolixas adicionavam 1.334 tokens no DeepSeek, 1.209 no GLM e 1.421 no Qwen; as 3 ferramentas curtas de C adicionavam de 322 a 462 em relação a D. Schemas de chamada de ferramentas vão em toda requisição, quer o modelo use as ferramentas ou não.
Em volume, isso soma. No Qwen3.8 27B, ir de A para C economiza 1.161 tokens por requisição. Com 100.000 requisições por mês, são cerca de 116 milhões de tokens de entrada, ou 116 × $0.175 por mês pelo preço padrão de entrada.
Como enxugar um prompt de sistema sem quebrá-lo?
Nosso prompt de 261 palavras e o de 66 palavras carregam as mesmas sete regras. Os cortes foram todos do mesmo tipo:
- Corte a cortesia com o modelo. “It is very important that you always remain polite and courteous at all times” (É muito importante que você seja sempre educado e cortês o tempo todo) virou nada: a linha do papel já implica isso.
- Uma regra por linha. Tópicos substituem frases do tipo “Please make sure that you always…” (Por favor, certifique-se de sempre…).
- Junte duplicatas. Três frases sobre idioma viraram “Reply in the customer’s language (Arabic or English), briefly.” (Responda no idioma do cliente, árabe ou inglês, de forma breve.)
- Apague comportamentos padrão repetidos. “Remember to always be helpful!” (Lembre-se de sempre ajudar!) não muda nada.
Depois, teste. Um prompt mais curto que perde uma regra custa mais do que economiza. Rode as duas versões nas mesmas 50 a 100 entradas reais e compare, como em avaliar um LLM antes de trocar.
De quantos exemplos few-shot você precisa?
Menos do que a maioria dos prompts carrega. Cada exemplo few-shot é pago em toda chamada. Mantenha os que corrigem um erro que o modelo comete sem eles, como um exemplo em dialeto para um classificador de árabe, e tire os que ele já acerta. Nosso corte de 8 para 3 economizou de 54 a 56% do bloco de exemplos. Se 3 bastam para a sua tarefa é uma questão de acurácia, não de tokens, então confira no seu conjunto de teste.
Vale enviar ferramentas, dados e histórico de outro jeito?
Ferramentas. Envie só as ferramentas que o passo atual pode usar. Uma pergunta sobre a fatura precisa de get_account, get_bill e create_ticket, não de order_esim. Encurte as descrições para o que o modelo precisa para escolher e preencher a ferramenta. A indentação não importa aqui: todos os templates que renderizamos reserializam o array tools com tojson, então um array de ferramentas formatado custa o mesmo que um minificado.
Dados nas mensagens. Os dados que você cola numa mensagem vão do jeito que estão. No mínimo, minifique o JSON. Para registros planos, CSV ou TSV eliminam as chaves repetidas: de 31 a 41% menos tokens que o JSON minificado no nosso teste. Dados aninhados continuam em JSON. Confira se o modelo ainda lê as colunas corretamente.
Histórico. Cada turno passado é reenviado. Trocar 16 turnos antigos por um resumo de três linhas, mantendo os últimos quatro turnos literalmente, reduziu o prompt do Qwen de 2.693 para 1.103 tokens. Um resumo perde detalhes que o usuário pode citar de novo, e reescrevê-lo muda o prefixo, o que quebra o cache. Gerenciamento de contexto em agentes de longa duração explica quando compactar.
Diacríticos árabes. A maior parte do árabe é escrita sem vogais curtas. Se a sua entrada é totalmente vocalizada, vinda de um dicionário, livro didático ou fonte religiosa, remover os sinais (de U+064B a U+0652) cortou nosso parágrafo de 59 a 72%. Mantenha-os quando a tarefa depende deles, como ensino ou poesia. Normalização de texto em árabe cobre os outros caracteres que vale normalizar, e tokens por palavra em árabe a diferença maior em relação ao inglês.
Onde entra o cache?
O cache não encolhe o prompt. Ele barateia a parte repetida. O guia de caching da OpenAI diz que “the entire rendered prefix” (tradução: todo o prefixo renderizado) precisa coincidir e recomenda colocar as instruções estáveis primeiro. A página de preços da BroadNet descreve a entrada em cache como “usually the repeated start of recent requests, such as a long system prompt” (tradução: normalmente o início repetido de requisições recentes, como um prompt de sistema longo), sem nada a configurar, e a documentação dela informa os acertos em usage.prompt_tokens_details.cached_tokens.
Então a ordem é: encurte primeiro e depois torne estável o prefixo encurtado. Prompt de sistema e ferramentas primeiro, idênticos byte a byte em toda chamada; depois o histórico, só com acréscimos; a mensagem nova por último. No Qwen3.8 27B, a entrada em cache custa $0.0435 por 1M contra $0.175. Estrutura de prompt para cache traz o layout e um teste que prova que o prefixo é reaproveitado. Tokens em cache continuam contando na janela de contexto.
Como medir o seu próprio prompt?
Comece pela conta. Registre usage.prompt_tokens por ponto de chamada durante um dia e encontre o maior. Depois compare versões localmente com este script, que imprime as contagens antes e depois para dois arquivos:
# pip install tokenizers tiktoken huggingface_hub
import json, sys
import tiktoken
from huggingface_hub import hf_hub_download
from tokenizers import Tokenizer
def hf(repo, rev):
return Tokenizer.from_file(hf_hub_download(repo, "tokenizer.json", revision=rev))
COUNTERS = {
"Qwen3.8 27B": hf("Qwen/Qwen3.8-27B", "37561816e66b5b9153b1b64c10968c18c1e6f4a0").encode,
"GPT o200k": tiktoken.get_encoding("o200k_base").encode,
}
def n(enc, text):
out = enc(text)
return len(out.ids if hasattr(out, "ids") else out)
def diff(before, after):
for name, enc in COUNTERS.items():
a, b = n(enc, before), n(enc, after)
print(f"{name:12} {a:6} -> {b:6} saved {a - b} ({100 * (a - b) / a:.0f}%)")
if __name__ == "__main__":
diff(open(sys.argv[1], encoding="utf-8").read(), open(sys.argv[2], encoding="utf-8").read())
Rodado nos nossos dois prompts de sistema, ele imprimiu:
Qwen3.8 27B 297 -> 95 saved 202 (68%)
GPT o200k 293 -> 86 saved 207 (71%)
Adicione os repositórios dos outros modelos da lista de Fontes para comparar os quatro. Para uma checagem rápida no navegador, o comparador de tokens de prompt compara duas versões lado a lado, e o contador de tokens conta uma. Depois do deploy, confirme a economia em usage.prompt_tokens, que inclui o template.
Onde a BroadNet Inference se encaixa
O BroadRouter é o site da BroadNet. A BroadNet Inference cobra os tokens do prompt pelo preço de entrada de cada modelo e lê prefixos repetidos do cache pelo preço de entrada em cache quando o modelo tem um, então tanto prompts mais curtos quanto prefixos estáveis baixam a conta. O Gemma 4 VL 26B tem contexto de 32.768 tokens, em que enxugar importa para caber, além do custo. Nos planos do DeepSeek V4.1 Flash não há medidor de tokens, mas o contexto de 1.048.576 tokens continua valendo, e um prompt mais curto continua respondendo mais cedo. Os prompts não são retidos depois de cada requisição.
