O Jev não veio substituir o LLM: veio tirar dele um trabalho que nunca foi dele
Um modelo que não escreve uma palavra revisou 22 cláusulas de contrato em 2,7 segundos, por US$ 0,0015. A mesma revisão no Opus 5 levou 298 segundos e US$ 1,21.
Base: o projeto LEARN-4-JEV, um revisor de contratos rodando no Jev, o modelo System One da TypeSafe, medido contra a mesma revisão feita pelo Claude Opus 5. Números de 19/09/2026, medidos na minha máquina, com as ressalvas no fim.
Rápido e barato todo mundo já entendeu. O que quase ninguém entendeu é a pergunta que vem depois: isso substitui o LLM ou soma com ele? A resposta curta é que a pergunta está errada, e vale ver por quê, porque no meio dela está uma conta que provavelmente está aberta no seu cartão agora: a quantidade de chamadas de LLM que você faz em produção que nunca precisaram de um LLM.
1 · Sistema 1 e sistema 2 não competem
Daniel Kahneman separou o pensamento em dois. O sistema 1 é rápido, automático e não usa palavras: você não delibera se a chaleira está quente, você tira a mão. O sistema 2 é lento, deliberado e verbal: é ele que escreve o relatório, monta o argumento, explica.
Os dois não competem dentro da sua cabeça. Eles se revezam, e é o sistema 1 quem decide, milhares de vezes por dia, quando vale a pena acordar o sistema 2.
O LLM que você usa hoje é sistema 2 puro. Ele pensa escrevendo. É excelente nisso, e é isso que você paga.
O problema é que a maior parte do que você pede a ele em produção não é sistema 2. É "esse ticket é de cobrança ou de suporte?", "esse texto tem dado pessoal?", "de 0 a 3, quão grave é isso?". São reflexos. E você está pagando um redator premiado para apertar um botão.
2 · O que é um System One Model
A TypeSafe define assim: uma classe de modelos "feitos para tomar decisões rápidas e estruturadas que o software consegue usar direto", que devolvem "respostas tipadas e probabilidades, em vez de texto gerado".
Traduzindo para o que muda no seu código: você não manda um prompt e recebe uma string. Você manda um estado e uma pergunta tipada, e recebe a decisão e a probabilidade dela. O prompt some e no lugar dele entra a declaração da pergunta, o PRINT 02 põe os dois lado a lado.
# o que você faz com um LLM hoje
resposta = llm.chat("Classifique o ticket. Responda APENAS com JSON: ...")
dados = json.loads(limpar_crases(resposta)) # e reza
# o que você faz com um System One
resposta = client.system_one(
state={"document": "Fui cobrado duas vezes. Resolvam isso já."},
questions={"categoria": Choice(
instructions="Do que trata este ticket?",
criteria={"cobranca": ..., "tecnico": ..., "outro": ...},
)},
)
resposta.choices["categoria"].choice # "cobranca"
resposta.choices["categoria"].confidence # 0.93
Some dali: o responda apenas com JSON, o json.loads dentro do try, a limpeza de crase, o retry de quando ele resolveu explicar antes, o temperature=0 que você colocou torcendo, e a categoria inventada que não estava na lista. Não some porque alguém validou melhor. Some porque não existe texto para dar errado: a resposta só pode ser um dos valores que você declarou.
No meu projeto isso aparece como um UserError que chega antes de sair qualquer chamada, e que lista no próprio texto as únicas formas de saída que o modelo aceita: um bool, um Literal de duas ou mais opções, um float entre 0 e 1, uma lista de opções, ou uma rubrica de inteiros com uma descrição por degrau.
UserError: Output field 'risco' is not supported by this model. Use `bool`,
a `Literal` or `Enum` of two or more strings, a `float` bounded with `ge=0`
and `le=1`, a `list` of a `Literal` or `Enum`, a rubric of whole numbers
from 0 with a description per level in its schema, or a model of these.
Pedir um campo de texto não dá resposta ruim. Dá erro de digitação no seu código, na sua máquina, de graça.
3 · Por que é rápido, e não é "porque é menor"
Aqui está a parte que vale entender de verdade, porque ela explica todo o resto.
Um LLM responde escrevendo. Mesmo quando a resposta é "sim", ele produz essa resposta pedacinho por pedacinho: {, ", nu, la, ":, true… Cada pedacinho é uma passada inteira pelo modelo, e a próxima só começa quando a anterior termina. Fila indiana. Se o veredito tem 300 tokens entre raciocínio e JSON, são 300 passadas em sequência.
A consequência prática é contraintuitiva: a latência de um LLM cresce com o tamanho da resposta, não com a dificuldade da pergunta. Um "sim" bem fundamentado demora mais que um "sim" seco, e o fundamento você joga fora no json.loads.
O Jev não escreve. O espaço de respostas foi fechado antes da chamada: você declarou que a resposta é true/false, ou uma entre treze opções, ou um degrau de 0 a 3. Não há o que produzir em fila: há o que distribuir probabilidade sobre. A resposta sai inteira, de uma vez, e o tamanho dela não depende de quantas palavras a explicação teria.
E tem a segunda metade, que está escrita com todas as letras na documentação deles: as perguntas são avaliadas em paralelo e isoladas umas das outras, e "acrescentar perguntas quase não muda o tempo de resposta". Seis decisões por cláusula custam o mesmo relógio que uma.
Na demonstração do próprio site deles, a mesma decisão sai em 0,114 s contra 8,566 s de um LLM. Esse número é deles; o meu está na tabela logo abaixo.
A arquitetura exata a TypeSafe não publica. O comportamento, sim, e comportamento se mede.
O que eu medi, nos três contratos da baseline:
- representacao · 4.016 caracteresOpus 5: 298,3 s e US$ 1,2131Jev: 2,73 s e US$ 0,001535
- saas-adesao · 4.736 caracteresOpus 5: 320,4 s e US$ 1,3363Jev: 3,06 s e US$ 0,001978
- servico-b2b · 7.366 caracteresOpus 5: 338,8 s e US$ 1,3751Jev: 3,65 s e US$ 0,002617
- os três juntosOpus 5: 957,4 s e US$ 3,9245Jev: 9,23 s e US$ 0,00613
103,8x mais rápido. 640,2x mais barato. Mediana de 3 rodadas. Por chamada: p50 de 360 ms, p95 de 766 ms, com concorrência 8.
4 · Por que é barato: são três razões empilhadas
Primeira: saída não é cobrada. Abra qualquer tabela de preço de LLM: a saída custa de três a cinco vezes a entrada. É o lado caro da fatura, e é justamente o lado que você joga fora quando só queria a categoria. O Jev não tem saída para cobrar, e repare que ele até reporta tokens de saída (4.829 na rodada dos três contratos), e cobra zero por eles.
Segunda: a entrada é de outra ordem de grandeza. US$ 0,042 por milhão de tokens de entrada: US$ 42 por bilhão. A comparação é do site deles: 238x mais barato na entrada que o Claude Fable 5.1.
Terceira, e a que ninguém coloca na planilha: o custo não varia. Os tokens de entrada são os mesmos toda vez, então a mesma revisão custa o mesmo centavo na segunda e na sexta. Fatura de LLM oscila com o humor da resposta; essa não oscila.
Empurrando para uma escala que dói: mil contratos:
- tempo, na mesma sequência de chamadasOpus 5: ~88,6 horasJev: ~51 minutos
- custoOpus 5: US$ 1.308Jev: US$ 2,04
O ponto não é o desconto. É que a 88 horas e US$ 1.300 aquele produto não existe, e a 51 minutos e US$ 2 ele existe. Preço não é só preço: preço é a lista de coisas que dá para fazer.
5 · Ele só responde três formas de pergunta
Toda a API cabe em três primitivas. Essa pobreza é o recurso.
- noulpergunta de sim ou nãovolta a probabilidade do sim, de 0 a 1
- choiceescolha uma entre as opçõesvolta a opção escolhida e a probabilidade de cada uma
- scorenota numa rubricavolta o degrau e a probabilidade de cada degrau
Duas regras que mudam a qualidade e quase todo mundo ignora no primeiro dia:
- Opção sem descrição é palavra solta. "foro" é uma palavra; o que ela significa dentro deste contrato é o que decide a escolha.
- Nota sem régua não é nota, é número inventado. O Jev exige um texto por degrau da rubrica. No meu projeto esse texto é a única prosa do sistema: escrita por um humano, no código, e apenas selecionada 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.
A quarta forma, que é a mais subestimada
Uma lista de opções vira uma pergunta sim/não por opção, todas no mesmo pedido. A TypeSafe chama isso de fan-out, e é como eu detecto omissão num contrato: o que falta não está escrito em parágrafo nenhum para ser achado, então a lista do que se espera vem do código e o modelo responde uma por uma, numa chamada só.
No contrato de adesão faltavam as oito previsões. No negociado, nenhuma. Mesmo preço de relógio que uma pergunta só.
6 · A confiança calibrada é o produto, o resto é consequência
Se você tirar uma coisa só deste texto, tire esta.
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. A confiança do Jev não é escrita: ela sai da forma da distribuição de probabilidade entre as opções. Distribuição concentrada, confiança alta. Distribuição espalhada, confiança baixa. Não há introspecção no meio.
E ela é calibrada contra resultado: quando ele diz 0,7, a intenção é que acerte perto de 70% das vezes.
No meu contrato assimétrico isso apareceu de um jeito que eu não teria programado:
- regime = empresarialconfiança 0,39
- adesao = Trueconfiança 0,86
Menos de 0,5 num campo que muda 14 cláusulas de veredito. E o modelo está certo em hesitar: o contrato diz que o aderente é "pessoa física ou jurídica identificada no ato do aceite eletrônico". Não dá para saber. Ele não finge que dá, e o sistema para e pergunta para o humano, em vez de decidir sozinho e errado. No contrato negociado, o mesmo campo sai com confiança 1,00.
A confiança não mede o quanto o modelo é bom. Mede o quanto o documento é claro.
e é exatamente por isso que ela é útil
Daí sai a única arquitetura que interessa: três faixas. Confiança alta, decide sozinho. Confiança média, decide e confirma. Confiança baixa, chama quem sabe. É a triagem do pronto-socorro, e é o que um sistema de IA em produção precisa ter e quase nunca tem.
7 · Então ele substitui o LLM? Não. Ele substitui o Literal[...]
Ele não escreve, não explica, não redige cláusula, não gera código, não chama ferramenta, não olha imagem. Um LLM faz tudo isso. Não há substituição possível.
O que o Jev substitui é outra coisa, e é onde o dinheiro está: ele substitui a chamada de LLM que você fez só para preencher um campo fechado. Aquela que tinha um Literal[...] no schema e um "responda apenas com JSON" no prompt. Nessa chamada, tudo que o LLM tem de melhor, a prosa, a criatividade, o raciocínio aberto, era desperdício que você pagou e descartou.
E ele melhora o LLM que fica, de três maneiras:
- Na frente, como porteiro. Só o que passa da triagem chega ao modelo caro. No
pydantic-aiisso é literalmente uma linha:FallbackModel(jev, llm): o Jev responde o que consegue expressar e entrega ao LLM, com ferramentas e tudo, só o que ele não consegue. Você paga LLM apenas pelo que exigiu LLM. - Atrás, como guarda. O LLM escreveu; o Jev decide em 300 ms se aquilo vaza dado pessoal, se responde à pergunta, se pode ir ao cliente. Guardrail que custa três décimos de centavo não é debate de orçamento.
- Ao lado, como juiz. Avaliar 100 mil saídas com LLM-as-judge é caro e lento o bastante para você não fazer. Com um System One você faz, e ainda ganha confiança calibrada em cima de cada nota.
8 · As funções onde ele entra hoje
Todas têm a mesma assinatura: o espaço de respostas é fechado e o valor está na decisão, não na prosa.
- Roteamento de intenção: ticket, mensagem, e-mail, chamada: para qual fila, qual handler, qual agente.
- Triagem e prioridade: nota numa rubrica que você escreveu. Ordena a fila; não escreve o laudo.
- Guardrail de entrada e de saída: isso é injeção de prompt? isso vaza dado pessoal? isso é irreversível?
- Filtro antes do caro: vale rodar o RAG, o Opus, a busca de 40 mil tokens nesse documento? Decide quem gasta.
- Extração de campo fechado: categoria, sentimento, regime jurídico, idioma, país, produto.
- Detecção de omissão (fan-out), o que deveria estar aqui e não está.
- Juiz de avaliação em escala: comparar, pontuar, rotular saída de modelo, com confiança por item.
- Decisão dentro do loop do agente: antes de rodar o comando: destrói dado? precisa de confirmação? é o que o usuário pediu?
Um jeito rápido de encontrar os seus: procure no código todo prompt que termina em "responda apenas com JSON". Cada um é um candidato. Normalmente eles são a maioria das chamadas e a minoria do valor.
9 · O que ele não faz, e por que isso é bom
- Não gera texto, nem uma palavra. Nem explicação, nem justificativa, nem redação sugerida.
- Não executa ferramenta. Quando percebe que o texto pede uma, ele propõe, e quem chama é o modelo atrás dele.
- Só texto na entrada: nada de imagem, áudio ou vídeo.
- No máximo 255 opções numa pergunta. A 256ª é um 400 da API.
- Configuração de amostragem (
temperaturee parentes) não se aplica. Não existe criatividade a regular. - E o mais importante: tudo isso é recusado antes de sair a requisição, como erro de programação. Você descobre na sua máquina, não na fatura e não na tela do cliente.
No projeto anterior (LEARN-3), minha defesa contra alucinação era conferir a citação depois: o modelo escrevia "Art. 49 do CDC" e o código ia ver se aquele artigo estava mesmo no texto entregue. Aqui essa classe inteira de erro deixa de existir, porque não há texto gerado para conferir. O que sobra para validar é outra coisa: se a decisão foi tomada com confiança suficiente para valer sem um humano olhar.
10 · A prova: 22 cláusulas, 2,7 segundos, e uma coisa que eu não programei
O projeto é um revisor de contratos. Ele recorta o documento em cláusulas (isso não tem IA nenhuma: 10 ms de expressão regular), classifica a relação jurídica antes de julgar qualquer cláusula, e só então julga cada uma, seis decisões por cláusula, em paralelo.
A ordem importa, e é o achado que dá nome ao projeto. As mesmas 22 cláusulas, o mesmo modelo, o mesmo texto; muda só o regime informado na instrução:
- cláusulas nulasjulgado como consumo: 14 de 22julgado como empresarial: 2 de 22
- foro de eleição (7.4)como consumo: nula, gravidade 3como empresarial: válida, gravidade 1
- rescisão só no fim do prazo (5.3)como consumo: nulacomo empresarial: válida
Nenhuma vírgula do contrato mudou. "Renúncia prévia a indenização" é nula numa relação de consumo e é negociação legítima entre duas empresas do mesmo porte. Julgar a cláusula sem saber o regime é chutar qual das duas, e é por isso que a classificação vem primeiro, sozinha, e por isso que aquela confiança de 0,39 para a esteira.
Depois vem a triagem. A confiança de um veredito vale pelo elo mais fraco entre os campos que movem alguma coisa (nula e gravidade), e é ela que separa o que vale sozinho do que vai para a mesa do advogado:
- cláusulas julgadasassimétrico: 22equilibrado: 21
- gravidade médiaassimétrico: 1,41equilibrado: 0,14
- decididas sem humanoassimétrico: 4 a 7 de 22equilibrado: 16 a 17 de 21
- previsões faltandoassimétrico: 8 de 8equilibrado: 0 de 8
Ninguém programou essa diferença. Ela cai fora da calibração: o contrato ruim consome revisor humano, o contrato bom passa quase todo sozinho. O produto é a fila, não o veredito.
As três ressalvas, porque senão o número mente
- Os dois não fazem o mesmo trabalho. O Opus escreve 31 comentários com fundamento legal, tese de defesa e redação sugerida. O Jev devolve seis decisões por cláusula e não escreve nada. A medição compara o preço em segundo e em dólar do trabalho que o Jev faz: não é empate de qualidade decidido no cronômetro.
- A baseline já era paralela. Somar o tempo das cinco chamadas do Opus dá 576 s, mas o relógio de parede foi 298 s. Não é paralelo contra serial.
- O preço do Jev é anotado, não medido. US$ 0,042/milhão em 19/09/2026, colhido à mão: a biblioteca de preços do
pydantic-aiainda nem conhece o provedor. Confira antes de citar.
11 · Jev ou LLM? A árvore cabe em três perguntas
- A resposta cabe num conjunto fechado que você consegue escrever hoje? Se não cabe, é LLM. E se você não consegue escrever o conjunto, talvez o problema ainda não esteja definido.
- Alguém vai ler a resposta, ou só o software? Se um humano vai ler prosa, é LLM. Se é o
ifda linha seguinte que vai ler, é System One. - Você sabe o que fazer quando o modelo não tiver certeza? Se não sabe, comece por aí: é a pergunta mais importante das três, e a única que a confiança calibrada responde de graça.
12 · O que eu faria na segunda-feira
- Grep em "responda apenas com JSON". Cada ocorrência é uma chamada de LLM que provavelmente é sistema 1 disfarçado.
- Separe a fatura em duas. Quanto você gasta gerando texto que alguém lê, e quanto gasta decidindo coisa que só o código lê. A segunda pilha é a que muda de modelo.
- Escreva o espaço de respostas antes do prompt. As opções com descrição por opção, e a rubrica com um texto por degrau: escritos por gente, versionados, auditáveis antes de irem para a tela.
- Não invente o corte de confiança. Meça em exemplos rotulados, e saiba o que acontece abaixo dele antes de subir para produção.
- Deixe o LLM atrás, não fora.
FallbackModel(jev, llm): o barato responde o que consegue, o caro recebe só o que sobrou, e a fatura passa a ter forma. - Publique a ressalva junto com o número. "640x mais barato" sem a nota de que os dois não fazem o mesmo trabalho é marketing, não medição.
Rápido e barato já é motivo suficiente para olhar. Mas o que muda o desenho do sistema é o modelo saber dizer "nessa aqui eu não tenho certeza" e o seu código ter para onde mandar essa cláusula.
Projeto LEARN-4-JEV · modelo jev-latest (TypeSafe) contra claude-opus-5 · medições de 19/09/2026 · documentação em docs.typesafe.ai.