Pular para o conteúdo principal

Tokens Normalizados

O que você vai aprender
  • Por que o AutoTalk normaliza tokens de IA antes de cobrá-los
  • Como o peso por modelo é calculado a partir dos preços dos fornecedores
  • Como os tokens normalizados se acumulam nos medidores tokens_in e tokens_out

O AutoTalk trabalha com muitos modelos de linguagem diferentes de muitos fornecedores diferentes, e cada fornecedor cobra um preço diferente por token. Se simplesmente contássemos tokens brutos, usar um modelo barato seria exatamente igual a usar o mais caro na sua fatura -- o que seria injusto para todos.

Para manter a cobrança justa e consistente entre fornecedores, cada token é convertido em um token normalizado antes de tocar os medidores tokens_in e tokens_out do seu plano. A normalização não muda os tokens que o modelo realmente consumiu -- apenas os repondera para que tokens caros contem mais do que tokens baratos.

A ideia em uma frase​

1 token normalizado = 1 token bruto × quão caro o modelo é comparado à nossa referência.

Se a entrada de um modelo é exatamente tão cara quanto a referência, 1 token de entrada bruto é 1 token de entrada normalizado. Se o modelo custa o dobro, 1 token de entrada bruto é 2 tokens de entrada normalizados. Se custa metade, 1 token de entrada bruto é 0,5 token de entrada normalizado.

A referência​

O AutoTalk fixa um preço de referência interno usado para definir o que "1x" significa. Esses valores são mantidos internamente e usados apenas para ponderação -- não são os preços que você vê na sua fatura.

ReferênciaValor
Entrada por 1K tokens$0,005 (equivalente a $5 / 1M)
Saída por 1K tokens$0,015 (equivalente a $15 / 1M)

Um modelo cuja entrada custa $0,005 por 1K recebe um peso de entrada de 1,0. Um modelo cuja entrada custa $0,0025 por 1K recebe um peso de 0,5. Um modelo cuja entrada custa $0,010 por 1K recebe um peso de 2,0.

A fórmula​

Para cada modelo, o AutoTalk calcula dois pesos -- um para entrada, um para saída:

weight_in  = model_input_price_per_1K  / baseline_input_price_per_1K
weight_out = model_output_price_per_1K / baseline_output_price_per_1K

Então os tokens normalizados são:

normalized_in_tokens  = raw_prompt_tokens     * weight_in
normalized_out_tokens = raw_completion_tokens * weight_out

Esses são os números que se acumulam nos seus medidores tokens_in e tokens_out toda vez que um agente de IA é executado.

Limites de segurança​

Preços de fornecedores ocasionalmente mudam, e ocasionalmente contêm outliers ou falhas temporárias. Para proteger tanto você quanto o AutoTalk de uma fatura surpresa causada por um feed de preços ruim, cada peso calculado é limitado a uma faixa segura:

LimiteValor
Peso mínimo0,05 (nenhum modelo conta por menos de 5% de um token de referência)
Peso máximo8 (nenhum modelo conta por mais de 8× um token de referência)

Se o preço de um modelo estiver faltando ou for desconhecido, seu peso assume o padrão de 1,0 (tratado como referência).

Um exemplo prático​

Suponha que uma chamada de agente de IA consuma 1.000 tokens de entrada brutos e 500 tokens de saída brutos usando gpt-4o, cujo preço é $0,0025 / $0,01 por 1K (entrada/saída).

Calcule os pesos:

weight_in  = 0,0025 / 0,005  = 0,5
weight_out = 0,01   / 0,015  ≈ 0,667

Aplique-os:

normalized_in_tokens  = 1000 * 0,5   = 500
normalized_out_tokens = 500  * 0,667 ≈ 333

O agente conta 500 contra seu limite de tokens_in e 333 contra seu limite de tokens_out -- não os 1000 / 500 brutos que ele realmente consumiu.

A mesma chamada com gpt-4o-mini (preço $0,00015 / $0,0006 por 1K) consumiria apenas 30 e 20 tokens normalizados respectivamente -- refletindo o quanto esse modelo é mais barato.

Relatório de excedente​

Ao final de cada período de cobrança, o AutoTalk agrega os contadores tokens_in e tokens_out para cobrança de excedente. Para manter os números gerenciáveis, os tokens normalizados são reportados em unidades de 1.000 (uma unidade de cobrança = 1.000 tokens normalizados).

Por que isso importa para você​

  • Seu workflow mais barato permanece barato. Executar um agente em gpt-4o-mini consome uma fração pequena de um token normalizado por token bruto, então seu limite mensal rende muito mais.
  • Seu workflow mais caro é cobrado de forma justa. Executar um agente em um modelo top-tier consome mais tokens normalizados por token bruto, o que corresponde ao custo real do AutoTalk para servir esse modelo.
  • Trocar de modelos é previsível. Como cada modelo é precificado em relação à mesma referência, você pode raciocinar sobre a capacidade do plano sem memorizar tabelas de preços de fornecedores.

Próximos passos​