System One

o modelo que não escreve · leitura de 11 min Cards do carrossel

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.

PRINT 00 capa: a frase-âncora jev-cards.html → card 00 · 4:5 · baixar png

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.

PRINT 01 os dois sistemas, lado a lado jev-cards.html → card 01

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.

PRINT 02 string contra decisão tipada jev-cards.html → card 02

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.

PRINT 03 cadeia de tokens contra passe único jev-cards.html → card 03 · o print mais importante do artigo

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.

PRINT 04 o relógio: 298 s contra 2,7 s em escala real jev-cards.html → card 04

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.

PRINT 05 anatomia do preço: entrada paga, saída não cobrada jev-cards.html → card 05

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.

PRINT 06 mil contratos: o número que dói jev-cards.html → card 06

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.
PRINT 07 as três primitivas, com a distribuição de cada uma jev-cards.html → card 07

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ó.

PRINT 08 fan-out: oito perguntas, uma chamada jev-cards.html → card 08

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.

PRINT 09 duas distribuições, três destinos jev-cards.html → card 09

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:

  1. Na frente, como porteiro. Só o que passa da triagem chega ao modelo caro. No pydantic-ai isso é 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.
  2. 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.
  3. 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.
PRINT 10 o porteiro e o escritório, o grafo da arquitetura jev-cards.html → card 10

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.

  1. Roteamento de intenção: ticket, mensagem, e-mail, chamada: para qual fila, qual handler, qual agente.
  2. Triagem e prioridade: nota numa rubrica que você escreveu. Ordena a fila; não escreve o laudo.
  3. Guardrail de entrada e de saída: isso é injeção de prompt? isso vaza dado pessoal? isso é irreversível?
  4. Filtro antes do caro: vale rodar o RAG, o Opus, a busca de 40 mil tokens nesse documento? Decide quem gasta.
  5. Extração de campo fechado: categoria, sentimento, regime jurídico, idioma, país, produto.
  6. Detecção de omissão (fan-out), o que deveria estar aqui e não está.
  7. Juiz de avaliação em escala: comparar, pontuar, rotular saída de modelo, com confiança por item.
  8. 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.

PRINT 11 as oito funções jev-cards.html → card 11

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 (temperature e 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.

PRINT 12 o muro das recusas jev-cards.html → card 12

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.

PRINT 13 22 cláusulas, dois destinos jev-cards.html → card 13

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-ai ainda nem conhece o provedor. Confira antes de citar.

11 · Jev ou LLM? A árvore cabe em três perguntas

  1. 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.
  2. Alguém vai ler a resposta, ou só o software? Se um humano vai ler prosa, é LLM. Se é o if da linha seguinte que vai ler, é System One.
  3. 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.
PRINT 14 a árvore de decisão jev-cards.html → card 14

12 · O que eu faria na segunda-feira

  1. Grep em "responda apenas com JSON". Cada ocorrência é uma chamada de LLM que provavelmente é sistema 1 disfarçado.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.

PRINT 15 segunda-feira + fechamento jev-cards.html → card 15

Projeto LEARN-4-JEV · modelo jev-latest (TypeSafe) contra claude-opus-5 · medições de 19/09/2026 · documentação em docs.typesafe.ai.