Jev, a IA que decide sem escrever: eu testei contra o GPT

Desde que o ChatGPT chegou, os modelos de que todo mundo fala são chatbots: você faz uma pergunta e eles respondem escrevendo. Em 15 de setembro saiu o primeiro da sua espécie que não é. Ele se chama Jev, foi criado pela TypeSafe AI e não sabe escrever nem uma palavra: toma decisões e, ao lado de cada uma, diz o quanto tem certeza. Os criadores prometem um fluxo de trabalho 193 vezes mais rápido que um LLM de fronteira. Uma promessa dessas precisava ser conferida, e eu conferi: 105 e-mails de clientes de um sistema de gestão, seis modelos, dois idiomas e uma comparação só entre modelos que erram tanto quanto o Jev. Aqui está como foi, com o método, as tabelas e o código Delphi.

Se você já colocou um LLM dentro de um sistema de gestão, cedo ou tarde acabou usando o modelo para uma decisão pequena: para qual setor vai este e-mail, que tipo de documento acabou de chegar, se o cliente está bravo. Funciona. Só que cada decisão custa um ou dois segundos mais os tokens de saída, e com dez mil e-mails por dia o tempo e a conta viram o problema.

Em 15 de setembro a TypeSafe AI anunciou o Jev, um modelo que não consegue escrever uma palavra sequer e só devolve decisões. A página inicial deles fala em um fluxo de trabalho 193,6 vezes mais rápido e 444,6 vezes mais barato que um LLM de fronteira. Falei dele no episódio 7 do podcast “while true do;” (em italiano), onde prometi publicar aqui o método, as tabelas e o código Delphi.

O que é o Jev

Você passa um contexto, que a TypeSafe chama de state (o texto de um e-mail, um registro), e algumas perguntas tipadas. Os tipos são três:

• choice: escolher uma entre até 255 opções, cada uma descrita em palavras;
• score: posicionar o texto numa escala de 2 a 10 níveis;
• noul: uma pergunta de sim ou não, e a resposta é a probabilidade do sim.

Você nunca recebe um texto para interpretar. Recebe a opção escolhida, a distribuição de probabilidade sobre todas as opções e uma confiança. Todas as perguntas são calculadas numa única passada, então acrescentar uma quase não muda o tempo de resposta. O preço de tabela é US$ 0,042 por milhão de tokens de entrada, e você não paga pela saída.

Desde 18 de setembro o Jev também está no OpenRouter, no endpoint POST /api/v1/systemone. Foi o que eu usei: com uma única chave você chama tanto o Jev quanto os LLMs com os quais você o compara, e todos os tempos incluem a mesma passagem pelo OpenRouter.

Chamando o Jev pelo Delphi

A chamada é um POST com corpo JSON, então THTTPClient e System.JSON bastam, sem SDK. Esta é a requisição do JevTriage_en, o programa de demonstração: três perguntas sobre um e-mail, uma de cada tipo.

// The three questions for Jev: department (choice), frustration (score), urgency (noul).
function BuildJevRequest(const AModel, AEmail: string): string;
begin
  var lRoot := TJSONObject.Create;
  try
    lRoot.AddPair('model', AModel);
    lRoot.AddPair('state', AEmail);
    var lQuestions := TJSONObject.Create;
    lRoot.AddPair('questions', lQuestions);   // from here on lRoot owns it

    var lDepartments := TJSONObject.Create;
    lDepartments.AddPair('administration', 'Invoices, payments, charges, refunds');
    lDepartments.AddPair('technical support', 'Program errors, freezes and malfunctions');
    lDepartments.AddPair('sales', 'Quotes, new modules, licenses, training');
    lDepartments.AddPair('other', 'None of the above');   // always include the fallback option
    lQuestions.AddPair('department', TJSONObject.Create
      .AddPair('type', 'choice')
      .AddPair('instructions', 'Which department should handle this email?')
      .AddPair('criteria', lDepartments));

    var lLevels := TJSONArray.Create;
    lLevels.Add('Calm, states the facts');
    lLevels.Add('Annoyed but polite');
    lLevels.Add('Very angry, harsh tone');
    lQuestions.AddPair('frustration', TJSONObject.Create
      .AddPair('type', 'score')
      .AddPair('instructions', 'How frustrated is the customer?')
      .AddPair('criteria', lLevels));

    lQuestions.AddPair('urgent', TJSONObject.Create
      .AddPair('type', 'noul')
      .AddPair('instructions', 'Is the request urgent or does it have a close deadline?'));

    Result := lRoot.ToJSON;
  finally
    lRoot.Free;
  end;
end;

Esta é a versão em inglês da demo. O zip também traz o original em italiano, JevTriage, já que é em italiano que esses e-mails chegam a uma software house italiana. Se você trabalha com System.JSON e quer relembrar a API fluente e quem é dono de cada objeto, tem o guia completo de JSON no Delphi.

A resposta você lê com GetValue<T> e um caminho: answers.department.choice, answers.department.confidence, answers.urgent.noul. Depois é o código, e não o modelo, que decide o roteamento, comparando a confiança com dois limiares:

// Routing is decided by the code, not by the model: confidence is just a number to compare.
function RouteByConfidence(const ADepartment: string; AConfidence: Double): string;
begin
  if (ADepartment = 'other') or (AConfidence < HUMAN_THRESHOLD) then
    Result := 'to an operator (a person decides)'
  else if AConfidence >= AUTO_THRESHOLD then
    Result := Format('automatic to "%s"', [ADepartment])
  else
    Result := Format('to "%s" with caution (needs confirmation)', [ADepartment]);
end;

AUTO_THRESHOLD vale 0,85 e HUMAN_THRESHOLD vale 0,5. Mais adiante você vai ver que 0,85 é otimista.

Quatro e-mails, uma execução real

O JevTriage_en manda os mesmos quatro e-mails para o Jev e para o google/gemini-2.5-flash-lite, pedindo a este último um JSON com os mesmos três campos. Esta é a saída completa de uma execução real, feita hoje:

Email 1: "Good morning, this month you charged the fee for the management software twice to our company card. Could you reverse the second charge? Thanks, Marta Rossi"
  Jev (typesafe/jev-1.13-20260917) in 455 ms
    department:   administration  (confidence 1.00)
                  administration=1.00  other=0.00  technical support=0.00  sales=0.00  
    frustration:  0.04 of 2  (confidence 0.95)
                  0=0.96  1=0.04  2=0.00  
    urgent:       no  (probability of yes 0.21)
    routing:      automatic to "administration"
  LLM (google/gemini-2.5-flash-lite) in 1101 ms
    department: administration, frustration: 1, urgent: true  (no probabilities, no confidence)

Email 2: "Since this morning, whenever I print an invoice the program closes with a memory access error. I have forty invoices to send out by tonight, I don't know what to do anymore!!!"
  Jev (typesafe/jev-1.13-20260917) in 373 ms
    department:   technical support  (confidence 0.99)
                  technical support=1.00  sales=0.00  administration=0.00  other=0.00  
    frustration:  1.75 of 2  (confidence 0.62)
                  0=0.00  1=0.25  2=0.75  
    urgent:       yes  (probability of yes 0.98)
    routing:      automatic to "technical support"
  LLM (google/gemini-2.5-flash-lite) in 715 ms
    department: technical support, frustration: 2, urgent: true  (no probabilities, no confidence)

Email 3: "Hello, we are a firm with twelve workstations and we would like a quote for the warehouse module and for staff training. No rush."
  Jev (typesafe/jev-1.13-20260917) in 365 ms
    department:   sales  (confidence 1.00)
                  sales=1.00  other=0.00  administration=0.00  technical support=0.00  
    frustration:  0.00 of 2  (confidence 1.00)
                  0=1.00  1=0.00  2=0.00  
    urgent:       no  (probability of yes 0.04)
    routing:      automatic to "sales"
  LLM (google/gemini-2.5-flash-lite) in 524 ms
    department: sales, frustration: 0, urgent: false  (no probabilities, no confidence)

Email 4: "Hi, I just wanted to tell you that yesterday's course was really useful. See you soon!"
  Jev (typesafe/jev-1.13-20260917) in 401 ms
    department:   other  (confidence 0.82)
                  other=0.87  administration=0.00  technical support=0.00  sales=0.13  
    frustration:  0.00 of 2  (confidence 1.00)
                  0=1.00  1=0.00  2=0.00  
    urgent:       no  (probability of yes 0.02)
    routing:      to an operator (a person decides)
  LLM (google/gemini-2.5-flash-lite) in 575 ms
    department: other, frustration: 0, urgent: false  (no probabilities, no confidence)

Email   Jev ms   LLM ms   Jev token in/out   LLM token in/out   Jev cost       LLM cost
    1      455     1101         460 / 84            113 / 18    $0.0000193     $0.0000185
    2      373      715         467 / 82            121 / 19    $0.0000196     $0.0000197
    3      365      524         459 / 81            110 / 18    $0.0000193     $0.0000182
    4      401      575         450 / 81            104 / 18    $0.0000189     $0.0000176
Total     1594     2915                                        $0.0000771     $0.0000740

Costs come from OpenRouter's usage.cost field (in credits, 1 credit = 1 USD).
Timings include the hop through OpenRouter.

O primeiro e-mail é uma cobrança em duplicidade, escrita com calma. Para o Flash Lite o cliente está irritado e o pedido é urgente. O Jev diz que o cliente está calmo e que o pedido não é urgente, e diz isso com as probabilidades ao lado.

O quarto e-mail é um agradecimento, e aqui os dois concordam: other, calmo, não urgente. O Jev escolhe other com confiança 0,82, e o código manda o e-mail para um atendente, como faz com todo other, seja qual for a confiança.

Quanto ao custo, com três perguntas o Jev custa o mesmo que o Flash Lite, até um pouco mais: a requisição ao Jev tem uns 460 tokens de entrada, a do LLM uns 110. A vantagem de preço do Jev está na saída gratuita, e com três respostas curtas há pouca saída para economizar. Só que quatro e-mails não provam nada, e o Flash Lite é o modelo mais barato da lista: por isso escrevi o JevBench.

O benchmark: 105 e-mails, seis modelos

O benchmark faz o mesmo trabalho em escala, com estas regras:

• 105 e-mails de clientes de uma software house que faz software de gestão: cobranças em duplicidade, notas fiscais rejeitadas pelo SDI (o sistema italiano de troca de notas fiscais eletrônicas), holerites que o sistema não calcula, pedidos de orçamento, cancelamentos, spam, phishing. 61 são difíceis de propósito: sarcasmo, frustração contida, negações (“não é urgente, mas até amanhã de manhã…”), um pedido escondido no PS de uma newsletter;
• 25 perguntas por e-mail (setor, módulo da aplicação, frustração, urgência, pedido de reembolso, ameaça de trocar de fornecedor, dados sensíveis e assim por diante), feitas em grupos de 3, 10 e 25 por chamada;
• seis modelos via OpenRouter: Jev 1.13, Gemini 2.5 Flash Lite, GPT-5.6 Luna, GPT-5.6 Terra, Gemini 3.1 Pro, DeepSeek V4 Pro. As mesmas instruções para todos, sem ajuste de prompt;
• acurácia balanceada como métrica principal, com intervalos de confiança bootstrap de 95%. A acurácia simples premia um modelo que sempre responde “não”: aqui, um modelo que sempre dissesse a classe mais frequente teria 84% de acurácia simples e 41% de acurácia balanceada;
• primeiro a qualidade, depois os tempos: comparo velocidade e custo só entre o Jev e o LLM mais barato que erra tanto quanto o Jev, ou menos. Um modelo dez vezes mais barato que erra um e-mail em cada três não serve para substituir o Jev.

Não há nenhum modelo da Anthropic, e não é por implicância: as respostas esperadas foram escritas e revisadas pelo Claude Opus 5, e um modelo da mesma família sairia na frente nos casos-limite. As regras de rotulagem fui eu que defini, e o caso mais disputado fui eu que decidi; os outros casos disputados foram decididos pelo mesmo modelo em meu nome, e ninguém conferiu de novo todos os rótulos à mão.

O teste principal é em inglês, porque a TypeSafe diz que o Jev funciona melhor em inglês e eu não queria colocá-lo em desvantagem sem avisar. Depois rodei tudo de novo em italiano.

Quem entende mais

Cada célula diz quanto um modelo entendeu dos 105 e-mails em inglês, com aquele número de perguntas por chamada. As colunas não são três rodadas do mesmo teste: “3 decisões” são as três primeiras perguntas (setor, frustração, urgência), “10” as dez primeiras, “25” todas. Cada coluna acrescenta perguntas novas, algumas mais difíceis, e é por isso que o Jev cai de 97,2 para 94,8: com 25 entra também o impacto do problema no cliente, onde o Jev para em 68%.

O número é a acurácia balanceada, em porcentagem. Para cada pergunta, cada resposta possível é avaliada separadamente: para “urgente”, você pega a fração de e-mails urgentes que o modelo reconheceu como urgentes e a fração de não urgentes que reconheceu como não urgentes, e calcula a média das duas. Depois calcula a média de todas as perguntas. Assim uma resposta rara pesa tanto quanto uma comum. Um modelo que sempre responde “não” a “urgente” acerta 88 e-mails de 105, mas aqui fica com 50. Dar sempre a resposta mais frequente a cada pergunta dá 34,4 com 3 decisões, 39,4 com 10 e 41,4 com 25: é com esse piso que você deve comparar os números da tabela.

Entre colchetes está o intervalo de confiança de 95%. Eu o calculei reamostrando aleatoriamente os 105 e-mails 2.000 vezes (bootstrap): com outra amostra de e-mails parecidos, o resultado cairia quase sempre dentro dessa faixa. Quanto mais largo o intervalo, menos preciso o número, e com 3 perguntas ele é largo porque cada erro pesa mais. Para decidir se um LLM é melhor ou pior que o Jev, porém, não basta olhar se os intervalos se sobrepõem: comparei cada modelo com o Jev e-mail por e-mail, nas mesmas reamostragens, e só contam as diferenças cujo intervalo não passa pelo zero.

Com 3 e com 10 decisões por chamada nenhum LLM faz melhor que o Jev por uma margem que se distinga do ruído. Com 25, só o Gemini 3.1 Pro o supera, por 2,3 pontos [0,9; 3,7]. O Flash Lite é pior em todos os níveis, então o tropeço dele nos quatro e-mails do início não foi azar.

Nenhum modelo devolveu JSON quebrado nas 2.835 chamadas do benchmark, 1.890 em inglês e 945 em italiano. Com os modelos de hoje, erros de schema são raros, então você precisa de outros motivos para escolher o Jev.

Quanto mais rápido, quanto mais barato

O Jev responde em cerca de um terço de segundo e leva o mesmo tempo com 3 perguntas ou com 25: 320, 341 e 337 ms em média. Os LLMs, por outro lado, precisam escrever cada resposta, e ficam mais lentos: o GPT-5.6 Terra vai de 1.397 para 2.338 ms, o Gemini 3.1 Pro de 4.625 para 7.151.

Esta tabela, da execução em inglês, compara o Jev com o LLM mais barato cuja acurácia empata com a do Jev em cada nível:

Calculei a razão de custo com os preços de hoje do OpenRouter, então ela muda assim que um preço mudar. Os tempos incluem a ida e volta até o OpenRouter, que daqui custa entre 20 e 30 ms (mediana de 20 ms na execução em inglês, 28 na italiana).

Se em vez disso você comparar o Jev com um modelo de fronteira, os números crescem. Mil e-mails com 25 perguntas custam US$ 0,08 com o Jev, US$ 2,17 com o GPT-5.6 Terra e US$ 11,82 com o Gemini 3.1 Pro, que, além disso, leva 21 vezes mais tempo que o Jev. Vinte e uma vezes continua longe de 193, mas mostra de onde vêm os números da TypeSafe: eles comparam o Jev com modelos de fronteira.

Em italiano

Em italiano rodei o teste de novo com o Jev e os dois modelos da OpenAI:

A qualidade do Jev se mantém no nível do inglês. A única diferença estatisticamente significativa aparece com 3 decisões, 1,9 ponto [0,6; 3,7]. Os LLMs, porém, ficam mais lentos em italiano, porque o mesmo e-mail consome mais tokens: com 25 decisões o GPT-5.6 Luna vai de 1.886 para 2.864 ms, enquanto o Jev vai de 337 para 348.

Os e-mails em inglês são uma tradução feita por LLM de originais em italiano escritos por um LLM. Uma diferença entre os idiomas também pode vir da tradução. O script build_en.py confere se cada e-mail traduzido mantém as respostas esperadas do original, mas não tem como conferir o estilo.

Confiança: “não pode alucinar”?

A TypeSafe diz que o Jev não pode alucinar. Isso vale para a forma: ele não devolve um campo que você não pediu nem uma opção que não existe. Os erros de julgamento continuam existindo. Se você perguntar algo que o texto não diz, ele não tem como responder “não sei”: distribui a probabilidade entre as opções que você forneceu e escolhe uma. Por isso a opção other no código acima não é opcional.

O que protege você é a confiança. A tabela mostra as respostas do Jev às perguntas choice e score, com 25 decisões, agrupadas pela confiança declarada:

(O número de respostas e a confiança média são da execução em inglês.)

Acima de 0,95 a confiança se sustenta. Na faixa do meio o Jev é otimista: quando diz 0,90, acerta um pouco mais de três vezes em quatro. A confiança sobe junto com a acurácia, então ela serve, mas o limiar você precisa medir nos seus próprios dados. Com esses números, o 0,85 do JevTriage_en deixaria passar no automático um bom número de respostas erradas: nos meus dados, o limiar razoável para agir sem confirmação é 0,95.

O que o teste não prova

O teste vale para uma única tarefa: e-mails de clientes de um sistema de gestão italiano, as mesmas instruções para todos. Ele não diz como os modelos se saem em outros domínios, o que os LLMs conseguiriam com um prompt bem trabalhado ou alguns exemplos, nem quanto o resultado varia de uma execução para outra, porque há uma execução só. Os e-mails difíceis estão sobrerrepresentados de propósito, então as porcentagens absolutas são mais baixas do que você veria no tráfego real. E as respostas esperadas foram escritas por um LLM, não por uma equipe de pessoas com café e muita paciência.

Há duas coisas a decidir antes mesmo de testar. Hoje o Jev é só uma API na nuvem, em acesso antecipado, sem pesos publicados e sem instalação on-premise: os e-mails dos seus clientes saem da sua infraestrutura e vão para uma startup que saiu do modo stealth há uma semana, depois de dois anos trabalhando em sigilo. E a configuração fixa typesafe/jev-1.13, não o alias jev-latest, porque os limiares de confiança valem para uma versão específica.

Baixe e experimente

O código está aqui: jev-delphi-demo.zip. Dentro você encontra a demo em inglês (JevTriage_en) e em italiano (JevTriage), o JevBench, o dataset em italiano e em inglês, os resultados completos com os CSVs e o bench/METODOLOGIA.md, que explica cada escolha com muito mais detalhe do que este artigo.

Você precisa do Delphi 13 (deve funcionar também no 12 e no 11, mas não testei), do código-fonte do DelphiMVCFramework por causa do MVCFramework.DotEnv, que lê o arquivo .env, e de uma chave do OpenRouter com algum crédito. Copie .env.example para .env, coloque sua chave e compile:

call "C:\Program Files (x86)\Embarcadero\Studio\37.0\bin\rsvars.bat"
msbuild JevTriage_en.dproj /p:Config=Debug /p:Platform=Win64
JevTriage_en.exe

O JevTriage_en custa menos de um centavo de dólar. Com seis modelos o JevBench faz 1.890 chamadas por idioma e leva uma hora e pouco. A execução em inglês custou uns US$ 3,50; a italiana, com três modelos e 945 chamadas, uns US$ 0,90. Antes de rodá-lo, experimente JevBench.exe --selftest, que gera todos os relatórios a partir de resultados fictícios sem chamar nenhum modelo. Qualquer argumento desconhecido faz o programa parar, assim um erro de digitação não dispara uma execução paga.

Para a parte opinativa, onde eu colocaria o Jev num sistema de gestão e onde não colocaria, ouça o episódio 7 do “while true do;” (em italiano). O paradoxo de Jevons, que dá nome ao Jev, é o tema dos episódios 4 e 5. A documentação oficial do Jev está em docs.typesafe.ai.

Perguntas frequentes

O que é o Jev da TypeSafe AI? O Jev é um modelo que a TypeSafe AI chama de “System One”: não gera texto, recebe um contexto e algumas perguntas tipadas (choice, score, noul) e devolve para cada uma a resposta, a distribuição de probabilidade sobre as opções e uma confiança. Foi anunciado em 15 de setembro de 2026 e é usado via API, direto na TypeSafe ou pelo OpenRouter.

O Jev é mesmo 200 vezes mais rápido que um LLM? No benchmark de Daniele Teti com 105 e-mails de clientes de um sistema de gestão, o Jev foi de 4 a 8 vezes mais rápido que o LLM mais barato com a mesma acurácia, e cerca de 20 vezes mais rápido que o Gemini 3.1 Pro. Os 193x divulgados pelo fabricante vêm de fluxos de trabalho escolhidos pela TypeSafe e comparam o Jev com modelos de fronteira.

O Jev erra menos que o GPT e o Gemini? Com 3 e 10 decisões por chamada nenhum dos LLMs testados supera o Jev em acurácia balanceada. Com 25 decisões só o Gemini 3.1 Pro é melhor, por cerca de 2 pontos. O Gemini 2.5 Flash Lite é pior em todos os níveis.

A confiança declarada pelo Jev corresponde à realidade? No topo, sim: acima de 0,95 o Jev acertou 96,5% das vezes. Na faixa do meio ele é otimista demais: quando declara cerca de 0,90, acerta 77,6% das vezes. Por isso o limiar para encaminhar um caso a uma pessoa precisa ser ajustado com os seus próprios dados.

Como chamar o Jev no Delphi? Com um POST JSON para o endpoint /api/v1/systemone do OpenRouter, usando THTTPClient e System.JSON da RTL. O código completo, incluindo o benchmark, está disponível para download em danieleteti.it.

Quem escreveu as respostas esperadas do benchmark? As respostas esperadas foram escritas e revisadas pelo Claude Opus 5. Daniele Teti definiu as regras e decidiu o caso mais disputado; os outros casos disputados foram decididos pelo mesmo modelo em nome dele, e ninguém conferiu de novo todos os rótulos à mão. Por isso não há nenhum modelo da Anthropic na comparação.