O Jev é um novo modelo de IA criado para assumir as pequenas decisões repetitivas que deixam os sistemas agênticos mais lentos e caros, deixando o LLM principal cuidar do raciocínio e da geração.
Veja o que você precisa saber sobre o Jev, como usá-lo e onde ele se encaixa em sistemas de IA agênticos.
O Jev é um modelo de IA especializado, desenvolvido pela TypeSafe AI, que toma decisões rápidas e estruturadas em vez de gerar texto. Ele foi criado para ajudar agentes de IA a tomar decisões rotineiras sem chamar repetidamente um modelo de linguagem de grande porte (LLM).
LLMs tradicionais geram texto token por token, mesmo quando você faz uma pergunta simples como “Este ticket de suporte é urgente?” O Jev funciona de outro jeito: você fornece um contexto, chamado state, e uma ou mais perguntas, e ele devolve respostas estruturadas e probabilidades, como 99,9% de chance de o ticket ser urgente.
O Jev pode melhorar o harness de um agente — o software ao redor que gerencia execução, ferramentas, permissões e decisões. Ele é especialmente útil em duas aplicações:
A TypeSafe AI relata inferência até 200 vezes mais rápida e custo mais de 400 vezes menor do que LLMs comparáveis em alguns fluxos de classificação.
A TypeSafe AI chama o Jev de modelo System One: um modelo feito para tomar decisões rápidas que o software pode usar diretamente.
Toda requisição ao Jev tem duas partes:
Digamos que um cliente relate uma integração de pagamento com falha, e você queira saber se a mensagem é urgente e qual equipe deve cuidar dela:
{
"model": "jev-latest",
"state": "My payment integration has failed three times. Customers cannot complete purchases. Please fix this immediately.",
"questions": {
"is_urgent": {
"type": "noul",
"instructions": "The customer needs immediate assistance."
},
"team": {
"type": "choice",
"options": ["billing", "technical_support", "sales"],
"instructions": "Which team should handle this request?"
}
}
}O Jev recebe um único state e avalia duas perguntas diferentes sobre ele.
O Jev não gera texto. Ele prevê valores para as perguntas especificadas, e a saída fica restrita aos tipos de resposta que cada pergunta permite. Para a pergunta de urgência acima, o Jev poderia devolver:
{
"is_urgent": {
"type": "noul",
"noul": 0.999
}
}O 0.999 é uma probabilidade estimada de 99,9% de que a afirmação seja verdadeira. O Jev produz uma previsão, e a sua aplicação decide que ação tomar.
Um agente de IA normalmente opera em um loop:
O Jev pode ser inserido em certos pontos desse loop para tomar decisões sem acionar o LLM principal.
Por exemplo, se um agente de programação quiser rodar rm -rf ./project, o harness pode primeiro perguntar ao Jev se o comando é arriscado e bloqueá-lo se for.
O Jev suporta três tipos de pergunta, cada um pensado para um tipo diferente de decisão.
Choice é usado quando você tem um conjunto fixo de respostas possíveis e quer que o Jev identifique a mais adequada. Ao ser perguntado qual equipe deve cuidar da mensagem sobre o Stripe acima, o Jev escolhe billing com probabilidade de 0.84.
O Jev devolve uma probabilidade para cada opção, junto com um valor geral de confiança que pode decidir se é preciso revisão humana. As opções são categorias distintas: Billing não vale mais nem menos que Sales.
Score é usado quando as respostas possíveis têm uma ordem com significado, como calm, frustrated e very angry. Para a mesma mensagem, o Jev posiciona o cliente em 1.035 nessa escala, bem em “frustrated”.
O Score devolve uma pontuação contínua, uma distribuição de probabilidade entre os níveis ordenados e um valor de confiança. É útil para avaliar risco, complexidade, urgência, relevância ou gravidade.
O Noul é o mais simples dos três. Ele avalia uma afirmação de sim ou não e devolve a probabilidade de ela ser verdadeira, como o valor de urgência 0.999 acima. Seu código decide como interpretar isso: por exemplo, escalar um ticket acima de 0.95 e mandar os casos incertos para revisão humana.
| Tipo | Pergunta | Resultado |
|---|---|---|
| Choice | Qual destas opções? | Probabilidade para cada opção e confiança |
| Score | Onde isto fica numa escala ordenada? | Pontuação contínua, distribuição e confiança |
| Noul | Esta afirmação é verdadeira? | Probabilidade de ser verdadeira |
Um LLM gera a resposta token por token, e até uma saída em JSON continua sendo geração de linguagem. O Jev devolve uma probabilidade estruturada sem gerar uma explicação.
| Capacidade | LLM tradicional | Jev |
|---|---|---|
| Operação principal | Gera tokens de texto | Prevê respostas estruturadas |
| Saída | Texto, código ou dados estruturados | Previsões tipadas e probabilidades |
| Raciocínio aberto | Sim | Não é o objetivo |
| Classificação | Sim | Feito especificamente para isso |
| Explicações livres | Sim | Não |
| Várias perguntas | Responde todas numa única resposta gerada | Avalia as perguntas em paralelo |
| Papel típico num agente | Raciocínio e execução de tarefas | Roteamento, classificação e apoio à decisão |
O Jev foi feito para trabalhar ao lado de LLMs tradicionais em sistemas agênticos, mas não substitui o modelo principal: sua força está em tomar decisões bem definidas sem o custo de uma chamada completa a um modelo generativo.
A Browser Use publicou um agente de navegador real movido pelo Jev, o jev-ultrafast. É um bom ponto de partida porque já implementa o loop de observação, decisão e execução no navegador:
O espaço de ações é montado dinamicamente a partir da página atual. Um pequeno LLM generativo só é chamado quando o agente precisa produzir texto para digitar num campo.
Você vai precisar de Python 3.12 ou mais recente, uv, Chrome e credenciais de API para o Jev e para o modelo de geração de texto.
git clone https://github.com/browser-use/jev-ultrafast.git
cd jev-ultrafast
uv sync
cp .env.example .envAdicione TYPESAFE_API_KEY e TEXT_MODEL_API_KEY ao arquivo .env (a configuração de exemplo usa uma chave do OpenRouter para a geração de texto). Depois rode uv run jev e abra http://127.0.0.1:8766. O inspetor da demo mostra os elementos observados no navegador, as previsões do Jev e as ações executadas. Para pular a interface da demo, importe a classe Agent do projeto no seu próprio script e passe a ela uma URL inicial e um objetivo.
O Stagehand expõe primitivas de automação de navegador como act, extract, observe e agent. Você pode usar o Jev como uma camada externa de decisão que define qual primitiva invocar ou qual ação observada executar. O padrão é: o Stagehand observa → o Jev decide → o Stagehand age → repete.
npm install @browserbasehq/stagehand @typesafe-ai/sdk dotenv
npm install -D tsx typescriptDepois adicione TYPESAFE_API_KEY e OPENAI_API_KEY ao ambiente do servidor. A chave da OpenAI é usada nas operações generativas de navegador do Stagehand.
Suponha que você queira abrir a primeira notícia do Hacker News. O Stagehand observa a página, enquanto o Jev escolhe entre um pequeno conjunto de ações permitidas:
import "dotenv/config";
import { Stagehand } from "@browserbasehq/stagehand";
import { TypeSafeClient, choice } from "@typesafe-ai/sdk";
const jev = new TypeSafeClient();
const stagehand = new Stagehand({ env: "LOCAL", model: "openai/gpt-4.1-mini" });
async function main() {
await stagehand.init();
try {
const page = stagehand.context.pages()[0];
await page.goto("https://news.ycombinator.com");
// Stagehand observes the current browser page.
const observations = await stagehand.observe("Find the first story link on the page.");
// Jev selects a bounded next action.
const result = await jev.systemOne({
state: JSON.stringify({ goal: "Open the first Hacker News story", observations }),
questions: {
nextAction: choice("Which action should be performed next?", {
openStory: "Open the first story link.",
inspectPage: "Inspect the page again.",
stop: "Stop without taking an action.",
}),
},
});
// Ordinary application code executes the decision.
switch (result.answers.nextAction.choice) {
case "openStory":
await stagehand.act("Click the first story title link.");
break;
case "inspectPage":
console.log(await stagehand.observe("List the available story links."));
break;
case "stop":
console.log("No browser action selected.");
}
} finally {
await stagehand.close();
}
}
main().catch(console.error);O Jev devolve openStory, inspectPage ou stop, e não código de navegador executável. Sua aplicação traduz essas decisões em chamadas suportadas do Stagehand.
Este exemplo executa um único ciclo de decisão. Para transformá-lo em um agente autônomo, coloque a observação, a decisão do Jev e a execução do Stagehand dentro de um loop limitado, passando o estado atualizado da página e o histórico de ações para cada decisão. Mantenha as escolhas do Jev limitadas a ações válidas no navegador, para que uma string gerada pelo modelo nunca vire JavaScript arbitrário ou um comando de shell.
O LangChain tem uma integração dedicada, langchain-typesafe, que expõe o Jev por meio do TypeSafeClassifier, além de um middleware experimental para roteamento de modelos e verificação de chamadas de ferramenta. Há três formas de usá-la.
Instale os pacotes e defina sua chave de API da TypeSafe:
pip install langchain langchain-typesafe langchain-openai
export TYPESAFE_API_KEY="your_typesafe_api_key"Depois crie um classificador:
from langchain_typesafe import Noul, TypeSafeClassifier
classifier = TypeSafeClassifier()
response = classifier.invoke({
"state": (
"The production deployment failed twice. "
"Customers are seeing HTTP 500 errors."
),
"questions": {
"urgent": Noul(
instructions="Does this issue require immediate attention?"
),
},
})
if response.nouls["urgent"].noul >= 0.95:
print("Escalate to the incident response team")O state pode ser texto simples, dados estruturados ou mensagens do LangChain. Você pode invocar o classificador dentro de um nó do LangGraph, de uma ferramenta do LangChain ou de um middleware de agente personalizado.
Agentes costumam usar o mesmo modelo caro para todas as tarefas, independentemente da dificuldade. O ModelRouterMiddleware permite que o Jev classifique uma solicitação e escolha entre modelos predefinidos:
from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import (
ModelChoice,
ModelRouterMiddleware,
)
router = ModelRouterMiddleware(
choices={
"fast": ModelChoice(
model="openai:gpt-4.1-mini",
criteria="Simple lookups, classification, extraction, and straightforward tasks.",
),
"powerful": ModelChoice(
model="openai:gpt-4.1",
criteria="Complex reasoning, architecture, and difficult debugging tasks.",
),
},
instructions="Choose the least costly model capable of completing the request.",
)
agent = create_agent("openai:gpt-4.1-mini", middleware=[router])O roteador avalia a última mensagem do usuário e seleciona um modelo para a execução do agente, mantendo as probabilidades e a confiança do roteamento no estado do agente.
O AutoModeMiddleware usa o Jev para inspecionar chamadas de ferramenta selecionadas antes da execução:
from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import AutoModeMiddleware
guardrail = AutoModeMiddleware(tools=["bash"])
agent = create_agent("openai:gpt-4.1-mini", middleware=[guardrail])Aqui, bash precisa corresponder a uma ferramenta registrada no agente. Num agente de navegador, aplique o mesmo padrão a ferramentas que enviam formulários, alteram dados ou fazem transações.
Desde o lançamento, em 15 de setembro de 2026, desenvolvedores vêm testando o Jev em agentes de navegador, assistentes de programação, jogos com IA, simulações de trading, busca semântica e automação de desktop. O padrão em comum é que o Jev toma uma decisão pequena e estruturada, enquanto um software comum ou outro modelo de IA faz o trabalho.
Para ver o que as pessoas estão criando, confira o Made with Jev. É um diretório da comunidade com projetos feitos com o Jev, e cada item traz o link para a fonte e o custo e a velocidade informados pelo autor.
| Projeto | O que o Jev faz |
|---|---|
| Jev Codex Router | Classifica os turnos de um agente de programação para escolher o modelo e o esforço de raciocínio |
| Fast Jev Compaction | Julga quais chamadas de ferramenta e resultados vale a pena manter no contexto de um agente de programação |
| Jev Review | Avalia mudanças no código-fonte e produz avaliações estruturadas de code review |
| Blink | Ajuda um agente de navegação em código a decidir quais diretórios e arquivos explorar |
| Canny | Adiciona verificações semânticas quando um agente afirma ter concluído uma tarefa |
A compactação de contexto é um exemplo interessante. Em vez de pedir a um LLM que resuma uma resposta grande de uma ferramenta, o Jev classifica quais partes são relevantes, e assim o código exato e as mensagens de erro sobrevivem em vez de se perderem num resumo gerado.
Um aplicativo de busca de imóveis poderia recuperar mil anúncios e perguntar ao Jev quais parecem recém-reformados ou ficam perto de grandes avenidas. Outros projetos o usam para avaliar registros de dados de treinamento ou para escolher qual relação seguir num grafo do Neo4j.
Para mais implementações, código-fonte e demos, veja o awesome-typesafe-jev, uma coleção de projetos com o Jev mantida de forma independente.
Aqui estão respostas rápidas para as dúvidas mais comuns sobre o Jev.
Não. O Jev não gera texto: ele devolve respostas tipadas com probabilidades. A TypeSafe AI o chama de modelo System One.
No lançamento, a TypeSafe AI definiu o preço dos tokens de entrada em US$ 0,042 por milhão, e os tokens de saída são gratuitos. Por enquanto, o acesso é feito por um programa de acesso antecipado.
Não sozinho. O Jev pode escolher em qual campo clicar ou qual ação tomar em seguida, mas não gera texto. No jev-ultrafast, um pequeno LLM escreve o texto que o agente digita no campo.
O post de lançamento da TypeSafe AI não lista os idiomas suportados.