A tese desta página: um LLM e um System One não diferem em inteligência, diferem em forma de resposta, e quase todo o resto é consequência aritmética disso. O LLM produz uma sequência: cada token é uma passada inteira pelo modelo, a próxima só começa quando a anterior termina, e por isso a latência dele cresce com o tamanho da resposta e não com a dificuldade da pergunta. O System One não produz sequência nenhuma: o conjunto de respostas foi fechado antes da chamada, e o que volta é uma distribuição de probabilidade sobre ele. Sem laço de escrita não há tokens de saída para pagar, não há cache de chaves e valores crescendo, e não há texto para alucinar. As nove etapas seguintes calculam cada uma dessas consequências, uma por vez.
Explore cada etapa →
As contas, num só lugar
As 6 contas desta página. Clique em qualquer uma para pular direto para a etapa que a explica.
A medição que originou esta página
Mais rápido
103,8×
Mais barato
640,2×
Tokens de saída
0
Três contratos reais, revisados cláusula a cláusula duas vezes: uma no claude-opus-5, outra no jev-latest, em 19/09/2026. O trabalho não é idêntico, o LLM escreve fundamentação jurídica e o System One devolve seis decisões tipadas por cláusula, então a comparação vale para o trabalho que o System One faz, e não como empate de qualidade decidido no cronômetro. O que esta página faz é explicar de onde saem essas duas ordens de grandeza, com as contas abertas.
Honestidade, antes de começar: esta página não chama modelo nenhum e não afirma nada sobre a arquitetura interna de nenhum produto, ela não é pública. O que roda de verdade: toda a aritmética que você vê, sem exceção, softmax, entropia, ECE por faixas, Brier, a curva de risco-cobertura varrida ponto a ponto, e as contas de banda, memória, tokens e preço. O que é modelo declarado: os parâmetros de hardware e de preço são sliders com valor de referência, não medições da sua máquina; a contagem de tokens usa a aproximação de 4 caracteres por token; e a população das etapas 6 e 7 é simulada por um gerador determinístico, com a regra de sorteio impressa na própria etapa. O que é citado: os dois números do painel acima. E a fronteira que vale para a página inteira: o que se afirma aqui é ou a mecânica de um LLM, que é pública e é assunto das outras páginas da série, ou o comportamento observável de um System One, nunca um palpite sobre como ele é por dentro.
Uma chamada de LLM tem duas fases com naturezas opostas. Na primeira, ler o prompt, todos os tokens de entrada atravessam o modelo de uma vez: é uma operação paralela, e ela termina rápido. Na segunda, escrever a resposta, cada token é uma passada inteira pelo modelo, e a próxima só pode começar quando a anterior terminou, porque o token seguinte depende do anterior. É um laço serial, e ele custa uma passada por token escrito.
Leia assim:nentrada é quantos tokens o prompt tem e rprompt é quantos tokens por segundo o servidor consegue ler, na casa dos milhares, porque essa fase é paralela. Nsaída é quantos tokens a resposta tem e rtoken é a velocidade de geração, na casa das dezenas por segundo para um modelo grande. As duas taxas saem de hardware, e a etapa 2 mostra exatamente de onde. O que importa aqui é a forma: a primeira parcela divide por um número grande, a segunda por um número pequeno. O System One só tem a primeira parcela, porque não existe Nsaída: a resposta dele não é uma sequência a produzir.
Onde o relógio do LLM é gasto
O detalhe que inverte a intuição: pedir ao modelo que "pense antes de responder", raciocínio em cadeia, rascunho, justificativa, é pedir mais tokens de saída, e tokens de saída são a parcela cara do relógio. Num pipeline em que a resposta útil é "cobranca", cada token de raciocínio custa o mesmo que um token de resposta e é descartado no json.loads da linha seguinte. Não é que raciocinar seja errado: é que ele tem preço, e ele precisa estar comprando alguma coisa.
De onde sai aquela velocidade de geração de 24 tokens por segundo? Não de o modelo "pensar devagar": de uma conta de logística. Para gerar um token, o processador precisa multiplicar a entrada por todos os pesos do modelo, e cada peso é usado uma vez só nessa passada. Não há o que guardar em cache de processador: o peso é lido da memória, usado, e não volta a ser útil até o próximo token. Então o passo dura, no mínimo, o tempo de a memória entregar o modelo inteiro.
Leia assim:P é o número de parâmetros e bits é quantos bits cada um ocupa depois da quantização, os mesmos da Anatomia de um modelo. BW é a largura de banda da memória em bytes por segundo: quanto a placa consegue entregar, não quanto ela consegue calcular. FLOPpico é o teto de cálculo. O fator 2 aparece porque cada parâmetro participa de uma multiplicação e uma soma por token. As duas desigualdades são pisos independentes, e o passo dura o maior dos dois: um diz "a memória não entrega mais rápido que isso", o outro diz "o silício não calcula mais rápido que isso". Quando o primeiro ganha, comprar uma GPU com mais TFLOPs não muda nada.
Intensidade aritmética, em uma frase: quantas contas você faz para cada byte que leu. Se o número é baixo, a máquina passa o tempo esperando a memória; se é alto, ela passa o tempo calculando. Gerar um token com uma sequência só dá 1 FLOP por byte em 16 bits, duas operações por parâmetro divididas pelos dois bytes que ele ocupa, o que fica quase três ordens de grandeza abaixo do ponto de virada de uma placa de datacenter. É por isso que serviço de LLM junta requisições em lote: o lote não faz cada resposta sair mais rápido, ele faz o mesmo byte lido servir a várias respostas de uma vez. E é por isso que ler o prompt já nasce do outro lado da linha: mil tokens atravessam os mesmos pesos numa passada só.
O que isso significa para um modelo que não escreve: ele faz a fase paralela e para. Não existe laço de decodificação, então não existe aquela sequência de passadas em que cada uma relê o modelo inteiro. A decisão custa uma travessia dos pesos, do mesmo jeito que ler o prompt custa uma. É a mesma máquina, a mesma memória e a mesma banda, o que muda é quantas vezes o trajeto é percorrido.
Os pesos não são a única coisa que a memória carrega. Para não recalcular a atenção sobre todo o texto a cada token novo, o modelo guarda uma chave e um valor por token, por camada e por cabeça de atenção. É o KV cache, e ele tem duas contas: quanto ele ocupa, e quanto ele custa de banda a cada passo, porque o passo relê tudo que já foi escrito.
Leia assim: o 2 é porque são duas matrizes, a de chaves e a de valores. L é o número de camadas, hkv o número de cabeças de chave (que em GQA é bem menor que o de cabeças de consulta: é justamente essa a economia da GQA), dhead a dimensão de cada cabeça e bytes a precisão do cache. Multiplicando pelo contexto você tem o total. O detalhe que escapa: isso é por sequência. Num serviço com lote, cada requisição carrega o próprio cache, e é ele, não os pesos, que limita quantas conversas cabem ao mesmo tempo numa placa.
O cache cobra duas vezes, e a segunda é a invisível. Que ele ocupe memória todo mundo vê, porque em algum momento a placa recusa contexto. Que ele ocupe banda quase ninguém mede: como o passo de geração é limitado por bytes lidos, somar cache aos pesos deixa cada token mais lento que o anterior. A resposta começa rápida e termina arrastada, e nada mudou no modelo: mudou o tamanho do que ele precisa reler. É a mesma física da página de cache de prompt, vista do outro lado: lá o assunto é não reprocessar a entrada; aqui é o preço de carregar a saída que vai crescendo.
Numa passada única, esse objeto quase não existe. Ele é criado para ler o texto e descartado quando a resposta sai, sem nunca crescer: não há token novo sendo escrito para acrescentar linha nele. Por isso um serviço de decisão aguenta um lote muito maior na mesma placa: o que ocupa memória por requisição, no outro caso, era o cache que ia inchando enquanto o modelo escrevia.
Já sabemos que token de saída é a parcela cara. Falta olhar o que o LLM precisa escrever quando a resposta útil é um punhado de campos fechados. Ele não consegue devolver só a decisão: ele tem que devolver a decisão embrulhada, abre chave, nome do campo entre aspas, dois pontos, valor, vírgula, próximo campo. Cada caractere disso é token, e token de saída é o que custa caro.
Monte o schema
Campos do schema (clique para tirar)
O que o LLM precisa emitir
A contagem aqui é aproximada, e de propósito: 4 caracteres por token é a regra de bolso para texto latino, e o tokenizador real de cada modelo dá um número um pouco diferente, pontuação e nome de campo costumam sair pior que a média, porque ": e ", viram tokens próprios. Ou seja: a fatia de embalagem que a página mostra é, se algo, otimista.
No System One o schema não é um pedido, é a pergunta. Cada campo vira uma pergunta tipada, e as perguntas são avaliadas na mesma passada: a documentação da TypeSafe diz que acrescentar pergunta quase não muda o tempo de resposta, o que é coerente com a mecânica das etapas 1 e 2: o custo está em atravessar os pesos, e isso acontece uma vez. Um campo que o modelo não consegue expressar, um str, por exemplo, não vira resposta ruim: vira UserError antes de a requisição sair. É a diferença entre descobrir na sua máquina e descobrir na fatura.
Toda a superfície de um System One cabe em três formas de pergunta: sim ou não, escolha uma entre opções e nota numa rubrica. As três devolvem a mesma coisa por baixo, uma distribuição de probabilidade sobre as respostas que você declarou, e o que muda é a regra que transforma a distribuição em decisão.
pi = e(zi/T) ÷ Σj e(zj/T) · E[nota] = Σi i · pi
Leia assim:zi é a pontuação bruta que o modelo dá a cada opção, pode ser qualquer número, inclusive negativo. O softmax transforma essas pontuações em probabilidades: exponencia cada uma (o que torna tudo positivo e amplifica diferenças) e divide pela soma (o que faz o total dar exatamente 1). O T é a temperatura: abaixo de 1 ela concentra a distribuição na líder, acima de 1 ela achata tudo em direção ao empate. E E[nota] é a nota esperada: a média dos degraus pesada pela probabilidade de cada um, por isso ela cai entre degraus, e é informação, não defeito.
Os logits das quatro opções
A mesma distribuição, lida pelas três primitivas
noul · sim ou não
choice · escolha uma
score · nota numa rubrica
confnoul = (p − θ) / (1 − θ) se p ≥ θ · (θ − p) / θ caso contrário
Por que a confiança do sim/não mede distância até o corte, e não até a certeza: o corte é seu, não do modelo. Se você subiu θ para 0,75 porque um falso positivo é caro, então um sim a 0,80 é um sim apertado: passou por cinco centésimos. Reportar 0,80 esconderia exatamente isso. A fórmula normaliza cada lado pelo espaço que sobra nele, de modo que 0 é "em cima do corte" e 1 é "certeza total", dos dois lados. É uma escolha de projeto do pydantic-ai, documentada, e vale a pena saber que é uma escolha: o número bruto que o modelo devolve é a probabilidade.
Duas regras que mudam a qualidade e quase todo mundo ignora no primeiro dia: opção sem descrição é palavra solta, o modelo recebe o rótulo foro e não o que ele significa neste documento; e nota sem régua não é nota, é número inventado, por isso a rubrica exige um texto por degrau. Esses textos são escritos por gente, ficam no código e são apenas selecionados pelo modelo. É a diferença entre um comentário que você audita de antemão e um que aparece pela primeira vez na tela do cliente.
Um LLM "confiante" está escrevendo sobre si mesmo: você pede uma nota de certeza e ele gera um número, do mesmo jeito que geraria um adjetivo. Aqui a confiança não é escrita, é calculada a partir da forma da distribuição, e há mais de um jeito de colapsar uma distribuição num número só.
H(p) = − Σ pi · ln pi · confentropia = 1 − H(p) / ln k · confmargem = p₍₁₎ − p₍₂₎
Leia assim:H(p) é a entropia, a medida clássica de incerteza de uma distribuição. Ela vale 0 quando toda a probabilidade está numa opção só, e vale ln k, o máximo possível com k opções, quando todas empatam. Dividir por ln k normaliza para a faixa 0-1 independentemente de quantas opções existem, o que importa porque uma escolha entre treze opções tem entropia naturalmente maior que um sim/não. Subtrair de 1 inverte o sentido: incerteza vira confiança. p₍₁₎ e p₍₂₎ são a maior e a segunda maior probabilidade; a margem entre elas é outro colapso possível, mais grosseiro e às vezes mais útil.
Mas um número entre 0 e 1 não vale nada por si só. Ele só vira promessa quando é calibrado: quando o conjunto dos casos em que o modelo disse 0,70 acerta, de fato, perto de 70% das vezes. Isso não é opinião, é medição, e tem duas métricas padrão.
Leia assim: o ECE (erro de calibração esperado) agrupa as decisões em faixas de confiança, e em cada faixa compara o que o modelo prometeu (a confiança média) com o que ele entregou (a taxa de acerto real). A diferença absoluta é o desvio da faixa, e o ECE é a média desses desvios pesada pelo número de casos em cada uma. Um ECE de 0,03 quer dizer: na média, a confiança erra três pontos percentuais. O Brier é outro ângulo, o erro quadrático da probabilidade contra o resultado (que é 0 ou 1). Ele pune tanto prometer demais quanto viver em cima do muro, e por isso não dá para melhorá-lo só ficando cauteloso: um modelo que responde 0,5 para tudo tem Brier 0,25, que é ruim.
Diagrama de confiabilidade: barra é o acerto real, traço é o prometido
Calibração não é acerto. Um modelo que acerta 60% e diz "60%" é perfeitamente calibrado e nada brilhante; um que acerta 95% e diz "100%" é excelente e mal calibrado. As duas propriedades são independentes, e a segunda é a que decide se dá para automatizar: sem ela, o número da confiança não sustenta corte nenhum. É também por isso que a documentação da TypeSafe insiste que a confiança sai da distribuição e não de o modelo declarar certeza, e por que o treino por preferência humana, que otimiza resposta agradável, é conhecido por produzir o defeito oposto.
Com confiança calibrada na mão, aparece a única arquitetura que interessa: decidir sozinho onde a confiança é alta e chamar gente onde ela é baixa. O corte é um botão, e ele tem consequência mensurável: troca cobertura por erro que escapa. Esta etapa usa a mesma população da anterior, porque o corte só significa alguma coisa sobre uma distribuição cuja calibração você mediu.
cobertura(τ) = #{ ci ≥ τ } / n · custo(τ) = nhumano · preçohumano + escapam(τ) · preçoerro
Leia assim:τ é o corte de confiança. A cobertura é a fração de casos que passa sozinha: subir o corte diminui a cobertura. Escapam são os casos que passaram e mesmo assim estavam errados: são eles que você paga caro, e por isso o preço do erro é um parâmetro e não uma constante. O resto vai para a fila humana, que também tem preço. A curva de custo não é monótona: com corte baixo demais você paga erro, com corte alto demais você paga revisor, e existe um ponto de mínimo, que a página encontra varrendo o corte de 0,50 a 0,99 e comparando, porque a população é empírica e não tem fórmula fechada.
Custo total por corte: a barra clara é o corte atual, a verde é o mínimo
O mesmo mecanismo tem outro nome na literatura: abstenção, ou predição seletiva. A ideia é antiga e continua sendo a coisa mais subestimada de sistemas de IA em produção: um modelo que responde tudo com a mesma firmeza não te dá essa curva, não porque acerte menos, mas porque você não tem onde cortar. E repare no que a curva diz sobre a conversa de "acurácia": acurácia no que passou e acurácia geral são números diferentes, e é o primeiro que decide se o seu produto funciona.
Um caso concreto de como isso aparece: na revisão de contratos que originou esta página, o campo que diz sob qual regime jurídico ler o documento saiu com confiança 0,39 num contrato de adesão, e estava certo em hesitar, porque o contrato dizia que o aderente era "pessoa física ou jurídica". Esse campo muda 14 cláusulas de veredito. Com corte, a esteira parou e perguntou; sem corte, ela teria decidido sozinha e errado em silêncio. No contrato negociado, o mesmo campo saiu com 1,00. A confiança não mediu o modelo: mediu o documento.
Agora a conta que chega no cartão. Em toda tabela de preço de LLM a saída custa de três a cinco vezes a entrada, e é justamente o lado que você descarta quando só queria a categoria. Um modelo que não gera saída não tem esse lado da fatura. Descreva a sua carga e veja as duas colunas.
Leia assim:D é o número de documentos por dia, tin e tout são tokens de entrada e de saída por documento, e os preços vêm por milhão de tokens, daí a divisão por 10⁶. O tamanho da decisão por campo vem do schema que você montou na etapa 4: acrescentar um campo lá muda a fatura aqui, que é exatamente o que acontece quando alguém acrescenta um campo ao output_type em produção. A segunda fórmula é a primeira sem a segunda parcela: não porque a saída seja barata, mas porque ela não existe.
A terceira vantagem não aparece em nenhuma das duas colunas: previsibilidade. Os tokens de entrada são os mesmos toda vez, então a mesma carga custa o mesmo centavo na segunda e na sexta. A fatura de um LLM oscila com o tamanho da resposta que ele resolveu escrever naquele dia, e é por isso que orçamento de projeto com LLM é sempre uma faixa, nunca um número.
E a rede, que quase ninguém orça: o texto sobe igual nos dois casos, o documento precisa chegar lá de qualquer jeito. O que muda é o que desce. A resposta de um LLM cresce com o texto gerado; a de um System One é um punhado de números por pergunta. Em volume alto isso vira conta de egress, e em serviço próximo do cliente vira latência de transferência. Vale também o contrário, e é a armadilha mais comum de todas: uma decisão de 40 ms atrás de um ida e volta de 120 ms é uma decisão de 160 ms. O ganho de um modelo rápido só aparece inteiro quando as chamadas são concorrentes ou o serviço está perto.
Nenhum dos dois substitui o outro. Um System One não escreve, não explica, não chama ferramenta e não olha imagem; um LLM faz tudo isso. O que ele substitui é outra coisa, e é onde o dinheiro está: a chamada de LLM que existia só para preencher um campo fechado. O desenho que junta os dois é a cascata, o barato na frente, o caro atrás, e a confiança decidindo a fronteira.
Leia assim:C₁ e T₁ são o custo e a latência do modelo da frente, que roda sempre; C₂ e T₂ são os do modelo de trás, que roda só quando o da frente não resolve. p é a taxa de passagem: a fração que o barato resolve sozinho. A média melhora desde a primeira requisição desviada, mas repare na terceira fórmula. Se mais de 5% das requisições caem para trás, o percentil 95 da cascata é a soma dos dois, e não o tempo do LLM sozinho: o caso difícil paga os dois modelos. Uma cascata com taxa de passagem baixa melhora a média e piora a cauda, e cauda é o que o usuário sente.
Onde a cascata aparece na prática
Roteamento de intenção: ticket, e-mail, mensagem: para qual fila, qual handler, qual agente. O espaço de respostas é a sua lista de filas.
Triagem e prioridade: nota numa rubrica que você escreveu. Ordena a fila; quem escreve o laudo é outro.
Guarda de entrada e de saída: isso é injeção de prompt? isso vaza dado pessoal? isso é irreversível? Guarda que custa décimo de centavo não entra em discussão de orçamento.
Filtro antes do caro: vale rodar o RAG e o modelo grande neste documento? É literalmente a fórmula desta etapa.
Juiz de avaliação em escala: pontuar cem mil saídas de modelo com confiança por item, o que com LLM é caro o bastante para ninguém fazer.
Dentro do laço do agente: antes de rodar o comando: destrói dado? precisa de confirmação? É a decisão que o agente de verdade toma dezenas de vezes por execução.
Em código isso costuma ser uma linha. No pydantic-ai, FallbackModel(jev, llm) entrega ao modelo de trás a requisição inteira, com ferramentas e tudo, quando o da frente não consegue expressar a saída pedida. O ponto que a fórmula desta etapa deixa claro e o slogan esconde: a cascata compensa quando o modelo da frente acerta muito e sabe quando não acertou. A segunda metade é a confiança calibrada da etapa 6. Sem ela, a cascata vira só um jeito caro de errar duas vezes.
As nove, de um relance
Armadilhas de produção
O que quebra em escala, o que degrada em silêncio e o que só aparece depois de um milhão de decisões.
No fim: a pergunta que esta página troca é a de sempre em engenharia. Em vez de "qual modelo é melhor?", que não tem resposta, você passa a perguntar "a resposta cabe num conjunto fechado que eu consigo escrever hoje?". Se cabe, quase tudo que você paga num LLM, os tokens de saída, o laço de geração, o cache que cresce, o envelope de JSON, o raciocínio descartado, é desperdício com nome técnico. Se não cabe, nenhuma economia de banda compra a prosa que você precisa. A parte que muda o desenho do sistema não é a velocidade: é o modelo saber dizer "nessa aqui eu não tenho certeza" e o seu código ter para onde mandar esse caso.
Continue na série
Dentro de um LLM, o laço de geração token a token que esta página usa como ponto de partida
Cache de prompt, o outro lado da conta de reler o que já foi processado
Um agente de verdade, o laço onde cada decisão desta página é tomada dezenas de vezes por execução
Laya: um System One por dentro, o mesmo tipo de modelo aberto, a sequência, o encoder, o portão e a regra de treino que faz a confiança significar alguma coisa