Onde o Jev entra na arquitetura de um agente de IA?

Num agente de IA, nem toda etapa precisa de texto

Muita coisa ali dentro é só decisão: qual ferramenta chamar, se já dá pra parar, se o resultado de uma etapa passou ou não

Fala aí, beleza? A TypeSafe AI lançou o Jev, um modelo que não escreve nada: ele recebe o contexto e devolve uma decisão tipada com probabilidade (a tal confiança) e pronto 🙂

Ele saiu em acesso antecipado em 15 de setembro de 2026, e a pergunta que fica é: onde isso encaixa no loop de um agente?

É isso que a gente vai mapear aqui, ponto por ponto, com foco em desenho de arquitetura e não num caso isolado

Bora?

O que é o Jev e por que ele é diferente de um LLM?

A TypeSafe chama a categoria do Jev de System One Models, uma referência ao pensamento rápido do Kahneman (aquele modo automático, que decide sem ficar ruminando)

E, segundo a própria empresa, o Jev é o primeiro modelo público dessa classe

Tá, mas o que muda na prática?

Um LLM recebe texto e devolve texto, aí você tem que ler, parsear, validar, torcer pra ter vindo no formato certo e por aí vai

O Jev funciona diferente: recebe um estado (texto ou JSON) e uma ou mais perguntas, e devolve uma decisão tipada com confiança, SEM texto nenhum

Se você já brigou com LLM respondendo "Claro! Aqui está o JSON solicitado:" antes do JSON de verdade, já entendeu por que isso existe haha

A confiança é treinada com um método chamado RLCD (Reinforcement Learning for Calibrated Decisions), que otimiza probabilidades honestas

A TypeSafe afirma que confiança maior se correlaciona com acurácia maior

Guarda essa ideia, porque ela é a base de quase tudo que vem a seguir 😉

Os três tipos de decisão: Choice, Score e Noul

Pensa nesses três tipos como blocos de montar

Toda decisão que você quiser tirar do LLM e passar pro Jev vai ter que caber em um deles, então vale conhecer bem cada um antes de desenhar o agente

Choice: escolher entre opções

O Choice escolhe entre opções que você define, até 255 opções, e devolve a distribuição de probabilidade entre elas

Ou seja, não vem só a resposta vencedora: vem o quanto o modelo pende pra cada alternativa

Score: avaliar numa escala

O Score avalia algo em níveis ordenados, de 2 a 10 níveis, e devolve um valor contínuo

Serve pra perguntas do tipo "quão bom está isso?" ou "quão completo está isso?"

Noul: sim ou não com probabilidade

O Noul é o sim/não, só que com a probabilidade de a afirmação ser verdadeira

É o bloco mais simples e, em arquitetura de agente, provavelmente o que mais aparece

Várias perguntas numa chamada só:

Se liga nesse detalhe: várias perguntas (Choice, Score ou Noul) são respondidas em paralelo numa única chamada

Isso muda o desenho, porque dá pra agrupar decisões do mesmo momento do loop em vez de fazer uma chamada pra cada

Com esse vocabulário na mão, bora pros pontos do loop

Ponto 1: escolher qual ferramenta o agente vai chamar

A seleção de ferramenta é o encaixe mais óbvio do Jev em agentes de IA

Por quê? Porque o conjunto de ferramentas é conhecido e fechado: busca, leitura de arquivo, chamada de API, envio de mensagem e etc

Isso é literalmente uma pergunta Choice sobre o estado atual do agente

O desenho fica assim:

• O LLM continua planejando: entende o pedido, quebra em etapas, decide o que precisa ser feito
• O Jev recebe o estado daquele momento e decide QUAL ferramenta, entre as conhecidas, atende a etapa

É como ter um recepcionista que sabe exatamente pra qual sala mandar cada pessoa, sem precisar escrever um parágrafo explicando o motivo

E como a saída do Choice é uma distribuição, você enxerga quando a escolha está apertada entre duas ferramentas

Nesse caso, uma forma de desenhar é devolver a decisão pro LLM ou pedir mais contexto, em vez de seguir no escuro

Variação: roteamento de modelo

A mesma lógica serve pra escolher QUAL modelo vai trabalhar naquela etapa

O post da LangChain sobre o Jev mostra um middleware experimental que chama o Jev pra rotear entre um modelo barato e um mais capaz, conforme critérios definidos

Tarefa simples vai pro modelo barato, tarefa cabeluda vai pro modelo parrudo, e quem decide é uma pergunta delimitada, não um prompt gigante

Ponto 2: decidir se o agente continua ou para

Saber a hora de parar é um dos problemas mais chatos de agente

Quem nunca viu um agente dando voltas e voltas numa tarefa que já estava pronta? Ou o contrário, parando no meio achando que terminou 😅

Aqui a decisão também é delimitada, então dá pra modelar de dois jeitos:

• Noul pra "a tarefa está concluída?"
• Score pra "qual o grau de completude da tarefa?", numa escala que você define

E onde a probabilidade entra nisso?

Com texto livre, você depende de o LLM escrever algo como "tarefa finalizada" e de o seu código interpretar isso direito

Com uma probabilidade, você define um limiar: abaixo dele o loop segue, acima dele o agente para

O critério de parada vira uma regra explícita no seu código, e não uma interpretação de frase

Tome cuidado! A calibração é uma afirmação da TypeSafe, então o limiar certo pro SEU agente só aparece validando com os seus próprios casos

Isso é desenho, não garantia de resultado

Ponto 3: verificar o resultado de uma etapa antes de seguir

O terceiro encaixe é a checagem entre uma etapa e outra

O LLM gerou uma saída? Antes de passar ela adiante, o Jev pode responder perguntas como:

• A saída atende ao que foi pedido? (Noul)
• Qual a qualidade dela? (Score)
• A resposta é segura pra entregar? (Noul)

Verificação da saída de LLM e checagem de segurança da resposta estão entre os usos típicos do Jev

E lembra que várias perguntas saem numa chamada só? Dá pra checar qualidade e segurança no mesmo passo

Bloqueando ferramenta arriscada antes de executar:

Aqui entra a parte mais interessante do lado LangChain

Aquele mesmo middleware experimental da LangChain também usa o Jev pra bloquear chamadas de ferramenta arriscadas ANTES da execução

Ele se pendura nos hooks do ciclo de vida do agente, ou seja, naqueles momentos em que o framework te deixa interceptar o que o agente vai fazer

Pensa nos rm -rf da vida: o agente decidiu apagar uma pasta, e antes disso acontecer uma pergunta delimitada avalia se aquilo é arriscado

Só reforçando: é um middleware experimental, então trate como referência de padrão de arquitetura, não como peça pronta de produção

Onde o Jev não entra: o que continua sendo trabalho do LLM

Beleza, então é só trocar tudo pelo Jev? Não!

O Jev não gera texto, e isso define a fronteira na hora

Continua sendo trabalho do LLM:

• Planejar a tarefa e quebrar em etapas
• Escrever código, resposta, resumo, e-mail
• Raciocinar em aberto, quando a resposta não é uma escolha fechada
• Conversar com pessoas, seja no chat ou num workspace com humanos e agentes

O padrão que aparece nas fontes é bem direto: o LLM planeja e escreve, o Jev toma as decisões delimitadas dentro do loop (qual ferramenta usar, se a resposta é segura e quando parar)

O critério prático:

Se a saída que você precisa cabe numa pergunta Choice, Score ou Noul, ela é candidata ao Jev

Se precisa de texto, explicação ou criatividade, fica com o LLM

Só como referência, fora do loop do agente o Jev também aparece em roteamento de tickets, filtro de spam, lead scoring e classificação em larga escala

Tudo decisão fechada, repara 🙂

Custo e latência: por que isso muda o desenho do loop

Agora a parte que explica por que isso é mais que uma curiosidade

Traduzindo a tabela: são US$ 0,042 por milhão de tokens de entrada, a saída não é cobrada, a latência reportada fica entre 70 e 500 ms de ponta a ponta e a TypeSafe fala em até 400x mais barato que LLMs líderes em tarefas estreitas de decisão

Faz sentido a saída não ser cobrada: o Jev não gera texto, então a resposta é só a decisão

E atenção: a latência e a comparação com LLMs vêm da própria TypeSafe, não de benchmark independente

O que isso significa pra arquitetura?

Hoje, cada ponto de decisão feito por LLM custa tempo e token, então a tendência é colocar poucos checkpoints no loop

Se os números da TypeSafe se confirmarem no seu cenário, dá pra colocar MUITO mais pontos de decisão sem o agente ficar lento ou caro

Checar ferramenta, checar parada e checar resultado em toda volta do loop deixa de ser luxo

Isso vale independente de onde o agente roda, seja pra quem prefere rodar agentes em VPS ou numa máquina local

Mas, de novo, meça no seu caso antes de redesenhar tudo em cima desses números, beleza?

Por onde começar a desenhar seu agente com o Jev?

Recapitulando os três encaixes:

1. Escolher a ferramenta: pergunta Choice sobre o estado atual, com o LLM ainda planejando
2. Decidir se continua ou para: Noul ou Score com um limiar definido por você
3. Verificar o resultado: checar qualidade e segurança da saída antes de seguir, e até bloquear ferramenta arriscada antes da execução

O próximo passo é simples: pega o seu agente e lista todas as decisões que ele toma

Marca as que cabem numa pergunta fechada, escolhe UMA delas e testa com o Jev no lugar do LLM

Não precisa refazer o agente inteiro, começa por um ponto e compara

O que dá pra citar de concreto: a API responde em POST https://api.typesafe.ai/v1/systemone e existem SDKs oficiais pra Python e JavaScript, além da API HTTP

Lembrando que o Jev está em acesso antecipado, então é bom acompanhar a documentação oficial antes de apostar alto nele

E aí, qual decisão do seu agente você tiraria do LLM primeiro? 😀

Até o próximo post!