Jev: a IA que não conversa — guia completo do System One Model da TypeSafe AI (com exemplos e uso prático)

Uma nova IA chamada Jev está chamando atenção — mas ela não foi criada para conversar com você. Enquanto ChatGPT, Claude e Gemini são feitos para gerar textos, responder perguntas, programar e raciocinar, o Jev tem uma proposta diferente: tomar decisões rápidas e estruturadas dentro de sistemas de software.

Lançado em setembro de 2026 pela TypeSafe AI, o Jev é o primeiro modelo público da categoria System One — inspirada no conceito de decisões rápidas e automáticas de Daniel Kahneman. Em vez de produzir parágrafos, ele recebe um estado (contexto) e responde a perguntas tipadas com valores estruturados e probabilidades calibradas. Seu código usa essas respostas diretamente, sem parsing de JSON, sem regex e sem rezar para o modelo respeitar o formato.

Este guia cobre o que é o Jev, como funciona por dentro, os três tipos de pergunta da API, instalação, exemplos em Python e TypeScript, integração com LangChain, casos de uso reais, limitações e onde obter acesso. Referências oficiais: anúncio da TypeSafe AI, documentação e o artigo da LangChain sobre harness com Jev.

O que é o Jev e por que ele não é um LLM

O Jev não é um LLM (modelo de linguagem grande) tradicional. Ele não gera texto, código, resumos ou respostas em prosa. A TypeSafe AI chama essa classe de modelos de System One:

System One models são modelos de IA construídos para tomar decisões rápidas e estruturadas que o software pode usar diretamente. Um System One model avalia um estado e retorna respostas tipadas e probabilidades.

A aposta por trás disso é simples: a maioria das decisões dentro de software são julgamentos do tipo “Sistema 1” — “em qual bucket isso cai?”, “isso é urgente?”, “essa ação é segura?”. Hoje, muitos sistemas alugam um LLM caro (Sistema 2) para fazer esse trabalho. O Jev foi treinado especificamente para isso.

Imagine que uma empresa recebe a mensagem: “Minha cobrança veio duplicada.” Em vez de escrever uma resposta enorme, o Jev analisa o contexto e decide:

• Departamento: Financeiro
• Urgência: Média
• Confiança: 98%

Ou seja: ele funciona mais como uma função inteligente dentro de um software do que como um chatbot. Você define previamente as opções possíveis — por exemplo, SAFE, UNSAFE e REVIEW — e o modelo escolhe uma delas com probabilidade calibrada. Isso também evita o problema clássico em que a IA deveria retornar um formato específico, mas resolve “inventar” outra resposta.

Por que isso importa: custo, latência e confiabilidade

Muitos sistemas usam modelos enormes de IA para tarefas muito simples:

• escolher qual ferramenta um agente deve usar;
• classificar mensagens de suporte;
• detectar spam ou fraude;
• definir prioridade de atendimento;
• moderar contóudo;
• encaminhar solicitações;
• tomar decisões em automações em escala.

Usar um modelo gigante para isso pode ser caro e lento. A TypeSafe AI reporta que o Jev alcança até 200x mais velocidade e 400x menor custo que LLMs comparáveis em tarefas de classificação. Os números são da própria empresa e devem ser validados no seu tráfego, mas a ordem de magnitude já explica o entusiasmo da comunidade.

Comparativo aproximado publicado pela TypeSafe e por analistas da comunidade:

• Latência: 70 ms a 500 ms (Jev) vs. 3 s a 329 s (LLMs frontier)
• Preço de entrada: US$ 0,042 por milhão de tokens (Jev) vs. US$ 0,20 a US$ 10 (LLMs)
• Preço de saída: gratuito (Jev) vs. ~5x o preço de entrada (LLMs)
• Erros de saída estruturada: 0% por construção (Jev) vs. 0,58% a 45,5% (LLMs, variando por modelo)

Isso não significa que o Jev substitui ChatGPT ou Claude. A ideia é outra:

• GPT / Claude: pensar, conversar e criar.
• Jev: analisar e escolher rapidamente entre opções predefinidas.

Para agentes de IA e automações, essa abordagem é especialmente interessante quando existem milhares ou milhões de pequenas decisões acontecendo o tempo inteiro. A próxima evolução da IA talvez não seja apenas modelos cada vez maiores, mas modelos menores e especializados trabalhando juntos.

Como o Jev funciona: estado, perguntas e respostas tipadas

Para invocar o Jev, você envia dois elementos para a API:

• state — o contexto a ser avaliado (texto, JSON, array de mensagens ou dados estruturados);
• questions — um ou mais objetos de pergunta tipada sobre esse estado.

Exemplo mínimo em JSON, retirado da documentação oficial:

{
  "model": "jev-latest",
  "state": "Hi, I've been trying to connect my Stripe account for 3 days and it keeps failing. I'm losing sales. Please help ASAP.",
  "questions": {
    "is_urgent": {
      "type": "noul",
      "instructions": "The message conveys urgency or time-sensitivity"
    }
  }
}

A resposta vem estruturada, sem texto livre:

{
  "is_urgent": {
    "type": "noul",
    "noul": 0.999
  }
}

Isso significa 99,9% de probabilidade de que a mensagem é urgente — informação que sua aplicação usa para priorizar o ticket, sem parsing adicional.

Um recurso-chave: todas as perguntas de uma requisição são avaliadas em paralelo. Adicionar mais perguntas quase não altera o tempo de resposta; o custo extra é apenas de tokens das perguntas adicionais, que são baratos. Diferente de um LLM, o Jev não é limitado por geração sequencial de texto.

Os três tipos de pergunta: Choice, Score e Noul

Toda a API do Jev se resume a três primitivas. Isso não é uma limitação a contornar — é o design.

Choice: escolher uma opção de um conjunto

Retorna a opção escolhida (.choice), probabilidade para cada opção (.probabilities) e um score de confiança geral (.confidence). Suporta até 255 opções. É ideal para roteamento, categorização e classificação em buckets fixos.

Choice(
instructions="Which team should handle this",
criteria={
    "billing":   "Payment or subscription issues",
    "technical": "Bugs or integration problems",
    "sales":     "Pricing or account questions",
},
)

Dica prática: inclua sempre uma opção other para que o modelo possa dizer “nada se encaixa” em vez de forçar a opção mais próxima errada.

Score: posição em um espectro ordenado

Retorna um score contínuo (.score) que pode cair entre níveis (ex.: 1.035), além de distribuição de probabilidades e confiança. Use de 2 a 10 níveis descritos em palavras. A ordem do array define o índice — nível 0 é o primeiro item.

Score(
instructions="How frustrated the customer appears",
criteria=[
    "Calm, just stating facts",
    "Frustrated but civil",
    "Very angry, strong language",
],
)

Noul: sim ou não, como probabilidade

Retorna .noul, um número de 0 a 1 representando a probabilidade de que a afirmação seja verdadeira. Não há campo de confiança separado, porque o próprio número já é a crença calibrada.

Noul(instructions="The message conveys urgency or time-sensitivity")

Treinamento com RLCD: decisões calibradas, não preferências humanas

O Jev foi treinado com um método chamado RLCD (Reinforcement Learning for Calibrated Decisions). Em vez de otimizar respostas que humanos preferem ler (como no RLHF tradicional), o treinamento otimiza probabilidades contra resultados reais. Isso torna o campo confidence arquiteturalmente significativo: confiança mais alta realmente correlaciona com maior acurácia em agregado.

Consequência prática: você pode escrever limiares diferentes por ação, escalados pelo custo de errar. Uma ação de leitura (mostrar saldo) pode ter barreira baixa; uma ação que move dinheiro exige confiança acima de 0,85.

Onde baixar, como instalar e obter acesso

O Jev está em early access desde 15 de setembro de 2026. Não há download local do modelo — é um serviço de API na nuvem, como a maioria dos LLMs comerciais.

Passo 1 — Obter chave de API:

• Entre na lista de espera em typesafe.ai
• Após aprovação, crie a chave em console.typesafe.ai/settings/keys
• Alternativa: use o Vercel AI Gateway com o model ID typesafe-ai/jev (mesmo preço de US$ 0,042/MTok)

Passo 2 — Configurar a variável de ambiente:

export TYPESAFE_API_KEY="sk-..."

Passo 3 — Instalar o SDK:

Python 3.10+:

pip install typesafe-sdk
# ou: uv add typesafe-sdk

JavaScript / TypeScript (Node 20+):

npm install @typesafe-ai/sdk

Integração LangChain (middleware e classificador):

pip install langchain-typesafe

Endpoint único da API:

POST https://api.typesafe.ai/v1/systemone
Authorization: Bearer $TYPESAFE_API_KEY
Content-Type: application/json

O modelo padrão é jev-latest (atualmente resolve para jev-1.13.0). Para produção, recomenda-se fixar a versão: TypeSafeClient(model="jev-1.13.0").

Primeira chamada com curl (sem SDK)

curl -s https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
"model": "jev-latest",
"state": "Hi, my Stripe connection keeps failing. Losing sales. Help ASAP.",
"questions": {
  "department": {
    "type": "choice",
    "instructions": "Which team should handle this",
    "criteria": {
      "billing": "Payment or subscription issues",
      "technical": "Bugs or integration problems",
      "sales": "Pricing or account questions"
    }
  },
  "is_urgent": {
    "type": "noul",
    "instructions": "The message conveys urgency or time-sensitivity"
  }
}
  }'

A resposta inclui model (versão que respondeu), answers (chaves exatamente como você definiu) e usage com input_tokens e output_tokens (saída é gratuita).

Exemplo completo em Python

Cenário real: ticket de suporte com cobrança duplicada, múltiplas perguntas em uma única chamada.

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

client = TypeSafeClient()

response = client.system_one(
state={
    "ticket": {
        "subject": "Duplicate charge",
        "messages": [
            {
                "from": "customer",
                "text": "I was charged twice for order A-104. Please refund the duplicate.",
            },
        ],
    },
    "order": {
        "id": "A-104",
        "charges": [
            {"amount_usd": 49, "status": "captured"},
            {"amount_usd": 49, "status": "captured"},
        ],
    },
    "refund_policy": "Duplicate charges are eligible for a refund.",
},
questions={
    "department": Choice(
        instructions="Which team should handle this",
        criteria={
            "billing": "Payment or subscription issues",
            "technical": "Bugs or integration problems",
            "sales": "Pricing or account questions",
        },
    ),
    "frustration": Score(
        instructions="How frustrated the customer appears",
        criteria=[
            "Calm, just stating facts",
            "Frustrated but civil",
            "Very angry, strong language",
        ],
    ),
    "refund_requested": Noul(
        instructions="The customer is explicitly asking for a refund"
    ),
    "policy_supports": Noul(
        instructions="The stated refund policy covers this situation"
    ),
},
)

dept = response.answers["department"]
print(f"Departamento: {dept.choice} (confiança: {dept.confidence:.2f})")
print(f"Frustração: {response.answers['frustration'].score:.2f}")
print(f"Pediu reembolso: {response.answers['refund_requested'].noul:.2f}")
print(f"Política cobre: {response.answers['policy_supports'].noul:.2f}")

O state pode ser texto simples, objeto JSON ou array de mensagens. Use objeto quando houver mais de um pedaço de contexto. Apenas texto — sem imagens, áudio ou vídeo (transcreva ou descreva antes).

Limites de contexto (diferentes de um LLM, porque o estado é ingerido uma vez e as perguntas rodam em paralelo):

• 64k tokens para estado + todas as perguntas juntas;
• 32k tokens para estado + a pergunta individual mais longa.

Exemplo em TypeScript

import { choice, noul, TypeSafeClient } from "@typesafe-ai/sdk";

const client = new TypeSafeClient();

const response = await client.systemOne({
  state: { document: "I was charged twice. Please fix this ASAP." },
  questions: {
category: choice("What is this ticket about?", {
  billing: "Payment or subscription issues",
  technical: "Bugs or integration problems",
  other: "Anything else",
}),
urgent: noul("The message conveys urgency"),
  },
});

console.log(response.answers.category.choice);
console.log(response.answers.urgent.noul);

Os tipos de resposta são inferidos automaticamente a partir das perguntas que você define.

Integração com LangChain

A LangChain expõe o Jev via TypeSafeClassifier e middlewares experimentais para agentes. Isso encaixa o Jev no loop de agentes sem substituir o LLM principal — ele complementa decisões rápidas ao longo do caminho.

Classificador básico:

from langchain_typesafe import Noul, TypeSafeClassifier

classifier = TypeSafeClassifier()

response = classifier.invoke(
state=(
    "The deploy failed twice and customers are seeing 500s. "
    "Can someone look now?"
),
questions={
    "urgent": Noul(
        instructions="Does this need attention right now?"
    ),
},
)

urgency = response.nouls["urgent"].noul
print(f"Urgência: {urgency:.3f}")

O state aceita texto, dados estruturados ou mensagens LangChain, facilitando chamadas a partir de nós ou hooks de middleware com o contexto que o agente já possui.

Model Router — escolher o LLM certo por tarefa:

from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import (
ModelChoice,
ModelRouterMiddleware,
)

router = ModelRouterMiddleware(
choices={
    "fast": ModelChoice(
        model="openai:luna",
        criteria="Direct lookups, extraction, and localized changes.",
    ),
    "powerful": ModelChoice(
        model="openai:sol",
        criteria="Architecture and high-stakes decisions.",
    ),
},
instructions="Choose the least costly model that can complete the task.",
)

agent = create_agent("openai:gpt-5.6-luna", middleware=[router])

O roteador seleciona o modelo a partir da última mensagem do usuário e o usa durante toda a execução. Probabilidades e confiança ficam disponíveis no estado do agente.

Auto Mode — guardrail para ações perigosas:

Harnesses de codificação como Claude Code, Codex e Cursor já classificam ações perigosas antes de executá-las. Até agora, esse classificador ficava em partes fechadas do harness. Com o Jev barato e rápido, o mesmo padrão pode ser adotado em qualquer agente:

from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import AutoModeMiddleware

guardrail = AutoModeMiddleware(tools=["bash"])

agent = create_agent("openai:gpt-5.6-luna", middleware=[guardrail])

O AutoModeMiddleware usa Jev para verificar chamadas de ferramenta em busca de decisões arriscadas e bloqueia a execução antes que a ferramenta rode.

Cinco padrões arquiteturais que valem a pena copiar

1. Fan-out especulativo

Como as perguntas rodam em paralelo, a décima pergunta custa tokens, mas quase nenhum tempo. Inverta o instinto de fazer uma chamada barata primeiro: pergunte tudo de uma vez e deixe o código decidir o que foi relevante.

response = client.system_one(
state=ticket,
questions={
    "category": Choice(
        instructions="Broad category of this ticket",
        criteria={
            "bug_report": "Something is broken or erroring",
            "billing": "Charges, invoices, refunds",
            "feature_request": "Asking for new functionality",
            "account": "Login, permissions, security",
        },
    ),
    "bug_severity": Score(
        instructions="How severe is the reported issue",
        criteria=[
            "Cosmetic; no impact",
            "Degraded feature; workaround exists",
            "Blocking; no workaround",
        ],
    ),
    "has_repro": Noul(
        instructions="The user describes steps to reproduce"
    ),
    "refund_wanted": Noul(
        instructions="The user explicitly asks for a refund or credit"
    ),
},
)

cat = response.answers["category"]
if cat.choice == "bug_report":
if response.answers["bug_severity"].score > 1.5:
    escalate_to_engineering(ticket_id)
elif cat.choice == "billing" and response.answers["refund_wanted"].noul > 0.7:
start_refund_flow(ticket_id)

2. Roteamento com limiar de confiança

action = response.answers["intent"]

if action.confidence < 0.5:
route_to_human(user_message)
elif action.choice == "check_balance":
show_balance(account_id)
elif action.choice == "approve_transfer":
if action.confidence > 0.85:
    approve_transfer(account_id)
else:
    ask_user_to_confirm("Approve this transfer?")
else:
route_to_human(user_message)

3. Score composto

Quebre um julgamento fuzzy em dimensões independentes, pontue cada uma atomicamente e combine com pesos que você controla no código.

response = client.system_one(
state=resume_text,
questions={
    "python_depth": Score(
        instructions="Depth of Python experience shown",
        criteria=["None", "Mentioned", "Used in projects", "Primary language", "Deep expertise"],
    ),
    "team_leadership": Score(
        instructions="Experience leading engineering teams",
        criteria=["None", "Informal mentorship", "Led a small team", "Managed direct reports"],
    ),
},
)

a = response.answers
composite = (
0.40 * (a["python_depth"].score / 4) +
0.60 * (a["team_leadership"].score / 3)
)

4. Cascata: Jev classifica, código executa, LLM resolve o difícil

O Jev não substitui Opus ou GPT-5. Ele decide quais requisições merecem um. Em um milhão de tickets, usar Jev para triagem pode reduzir custo de ~US$ 30.400 para ~US$ 6.480, com a maioria respondida em menos de meio segundo.

def handle(message):
r = client.system_one(
    state=message,
    questions={
        "intent": Choice(
            instructions="Primary intent of this message",
            criteria={
                "order_status": "Asking about an existing order",
                "product_question": "Asking about a product",
                "return_exchange": "Wants to return or exchange",
                "complaint": "Unhappy, wants resolution",
            },
        ),
        "complexity": Score(
            instructions="How complex is this to resolve",
            criteria=[
                "Simple lookup or standard procedure",
                "Requires judgment or multiple steps",
                "Unusual edge case, escalation needed",
            ],
        ),
    },
)
intent = r.answers["intent"]

if intent.confidence < 0.5:
    return route_to_human(message)
if intent.choice == "order_status":
    return lookup_order(message)  # código puro, zero LLM
if intent.choice == "product_question":
    return handle_with_llm(message, PRODUCT_SPECIALIST)
if intent.choice == "complaint":
    if r.answers["complexity"].score > 1:
        return route_to_human(message)
    return handle_with_llm(message, COMPLAINT_RESOLUTION)

5. Recuperar, depois julgar

O Jev não tem conhecimento do mundo além do estado que você entrega. A qualidade do que monta o state define o teto de tudo depois. Padrão recomendado: busque dados com precisão (RAG, API, banco) e use Jev para filtrar ou classificar antes de enviar ao LLM caro.

Onde o Jev se encaixa no loop de agentes

Agentes rodam em loop: um LLM decide o que fazer, uma ferramenta executa, o modelo avalia o resultado e continua até concluir a tarefa. Dois primitivos tornaram isso viável — tool calling e structured outputs —, mas o loop ainda é lento e caro porque cada decisão exige outra chamada ao LLM.

O Jev entra nas decisões intermediárias:

• qual ferramenta chamar;
• se a ação é segura ou arriscada;
• qual modelo usar para a próxima etapa;
• se o ticket é urgente;
• se o conteúdo passa na moderação.

Use o LLM para raciocínio aberto e geração; use o Jev para decisões rápidas e estruturadas no caminho.

Projetos reais da comunidade (primeiras 48 horas)

Alguns projetos que surgiram logo após o lançamento (trate como artefatos de launch week, não estudos de produção):

• 1.018 papers classificados por US$ 0,08 — 1kpapers.com: DeepSeek resume, Jev classifica em 24 tópicos; resumos US$ 3,99 vs. classificações US$ 0,08.
• Agente de browser em 7,1 segundos — browser-use/jev-ultrafast: Jev escolhe operação e alvo; LLM só roda para digitar texto.
• Computer use a US$ 0,0002 por passo — OCR lê a tela, Jev escolhe a ação; ~160x mais barato que Opus por decisão.
• Market maker a cada ~300 ms — Jev lê order book e decide buy/sell a cada bloco.
• Triagem de e-mail em escala — Ryan Vogel usa Jev para classificar caixas de entrada massivas.

O padrão comum: loop, segurança e aritmética ficam em código comum; Jev cuida do julgamento estreito no meio que código acha difícil formular.

Limitações e modos de falha (leia antes de colocar em produção)

A TypeSafe publica uma página de “jaggedness” com o que o Jev não faz bem. Pontos críticos:

• Leitura literal: responde a pergunta que você escreveu, não a que você quis dizer. Negações e condições implícitas caem ao pé da letra.
• Não é calculadora: não conta de forma confiável. Itere em código e pergunte um Noul por item.
• Datas são texto: comparar qual veio primeiro ou se cai numa janela é unreliable. Extraia datas com regex e deixe ordenação para código.
• Context rot: acurácia cai quando o estado enche de material irrelevante. Recupere e filtre antes.
• Estado não é tratado como hostil: prompt injection no state pode mover a resposta. Trate conteúdo controlado pelo usuário como threat model.
• Não gera nada: sem texto, código ou resumos. Extraia candidatos com regex ou LLM e deixe o Jev escolher.

Regra meta da documentação: evite pedir ao modelo algo que código calcula exatamente; evite esconder vários julgamentos dentro de uma pergunta.

Sobre “não alucina”: o Jev não pode retornar um valor fora do seu schema — mas pode retornar o valor válido errado. Calibração de confiança ajuda, mas não elimina erro semântico.

Notas operacionais

• Rate limits (jev-1.13): 250.000 tokens/segundo e 1.200 requisições/minuto; acima disso retorna 429.
• Fixar versão: jev-latest muda quando houver release novo; limiares ajustados podem quebrar.
• Cobrança: apenas tokens de entrada; saída é gratuita.
• Skill para agentes de código: npx skills add typesafe-ai/skills --skill typesafe-ai

Quando usar e quando não usar

Sim: roteamento e triagem, moderação, filtro de relevância antes de context window caro, scoring de saída de LLM, guardrails de ferramentas, tagging em volume que antes era inviável economicamente, qualquer decisão sub-segundo dentro de um request handler.

Não: gerar qualquer texto, aritmética/contagem/matemática de datas, decisões que exigem justificativa escrita para auditor, raciocínio complexo one-off, espaços de resposta genuinamente abertos.

Conclusão

O Jev não é um LLM mais barato. É um primitivo diferente: uma chamada de função que acontece de ser inteligente, retorna um tipo e diz quanto confiar nela. Para quem constrói agentes, automações e pipelines de decisão em escala, isso abre um caminho que antes dependia de parsing frágil de saída de LLM ou de modelos caros para tarefas triviais.

A combinaível é clara: LLM para pensar e criar, Jev para decidir e rotear. Com SDKs em Python e TypeScript, integração LangChain, API REST simples e preço agressivo, vale pilotar em uma decisão barata de verificar no seu próprio tráfego antes de escalar.

Links úteis para começar:

• TypeSafe AI — site e lista de espera
• Console — chaves de API
• Documentação oficial
• LangChain: Building a Harness with Jev
• awesome-typesafe — ecossistema e projetos da comunidade