JEV e os modelos System One

O que é o JEV

O Jev é o primeiro modelo da TypeSafe AI, lançado em setembro de 2026 em acesso antecipado. Ele não é um LLM: em vez de gerar texto token a token, recebe um estado (o contexto) e uma lista de perguntas definidas por você, e devolve respostas tipadas com probabilidades. A própria empresa resume como “uma chamada de função com inteligência de fronteira”.

O nome não é sigla: homenageia o economista William Stanley Jevons, do Paradoxo de Jevons (quando algo fica mais barato de usar, o consumo total aumenta). A aposta é que decisões de IA baratas e rápidas vão aparecer em lugares onde hoje ninguém chamaria um LLM.

Por que “System One”?

A categoria vem dos dois modos de pensamento descritos por Daniel Kahneman em Rápido e Devagar:

A ideia não é substituir o LLM, e sim tirar dele as decisões pequenas que ele toma o tempo todo.

O problema: o loop do agente

Um agente roda em loop, e cada volta costuma ter várias micro-decisões: qual modelo usar, se a ferramenta é perigosa, se o pedido é urgente, se a tarefa terminou. Quando cada uma vira uma chamada a um LLM, o loop fica lento e caro, e ainda é preciso fazer parse de uma string que pode vir fora do formato.

Os losangos em destaque são decisões System One: perguntas fechadas, com respostas previsíveis. É nelas que o JEV entra; o retângulo do meio continua sendo trabalho de LLM.

Como funciona

Você define as possíveis saídas antes da chamada. O modelo só pode responder dentro delas, então erro de tipo (um JSON quebrado, um rótulo inventado) deixa de existir por construção.

O que muda por dentro, segundo a TypeSafe:

• Amostragem paralela: todas as respostas saem de uma única passada, em vez de uma sequência de tokens. Por isso adicionar perguntas quase não aumenta o tempo de resposta.
• Treino com RLCD (Reinforcement Learning for Calibrated Decisions): o objetivo do treino é que as probabilidades sejam calibradas, ou seja, que 0,9 signifique “acerta 9 em cada 10”. Veja a nota sobre calibração.

Os três tipos de pergunta

Exemplo: a chamada crua

{
  "model": "jev-latest",
  "state": "Tento conectar minha conta do Stripe há 3 dias e falha sempre. Estou perdendo vendas, preciso de ajuda urgente.",
  "questions": {
    "is_urgent": {
      "type": "noul",
      "instructions": "A mensagem transmite urgência"
    }
  }
}

A resposta traz um valor por pergunta, mais a versão exata do modelo e o uso de tokens:

{
  "model": "jev-1.13.0",
  "answers": {
    "is_urgent": { "type": "noul", "noul": 0.999 }
  }
}

O endpoint é POST https://api.typesafe.ai/v1/systemone, com a chave no header Authorization. Há SDKs para Python (typesafe-sdk) e TypeScript (@typesafe-ai/sdk).

Na prática: decidir e saber quando não decidir

O ganho real não é só a velocidade: é poder ler a confiança e mandar os casos duvidosos para quem decide melhor (um LLM maior ou uma pessoa).

Com a integração do LangChain (pip install langchain-typesafe e a variável TYPESAFE_API_KEY):

from langchain_typesafe import Choice, Score, TypeSafeClassifier

classifier = TypeSafeClassifier()
CONFIDENCE_THRESHOLD = 0.85


def route_ticket(text: str) -> str:
    response = classifier.invoke({
        "state": text,
        "questions": {
            "team": Choice(
                instructions="Qual time deve atender este ticket?",
                criteria={
                    "infra": "Deploys, disponibilidade e incidentes.",
                    "billing": "Pagamentos, faturas e assinaturas.",
                },
            ),
            "severity": Score(
                instructions="Qual o impacto para o cliente?",
                criteria=["Cosmético.", "Degradado para alguns.", "Fora do ar."],
            ),
        },
    })

    team = response.choices["team"]
    if team.confidence < CONFIDENCE_THRESHOLD:
        return "human-triage"
    if response.scores["severity"].score >= 2:
        return f"{team.choice}-oncall"
    return team.choice

As duas perguntas usam o mesmo estado e são avaliadas na mesma requisição.

Onde ele entra no harness

O harness é todo o código em volta do modelo: o loop, as ferramentas, os middlewares. O pacote langchain-typesafe já traz dois middlewares prontos (ainda em experimental, instalados com langchain-typesafe[experimental]):

Roteamento de modelo: o JEV lê o último pedido do usuário e escolhe o modelo mais barato que dá conta.

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

router = ModelRouterMiddleware(
    choices={
        "fast": ModelChoice(model="openai:gpt-5.6-terra", criteria="Consultas diretas, extração e mudanças pontuais."),
        "powerful": ModelChoice(model="openai:gpt-6-astra", criteria="Arquitetura, causa raiz inédita e decisões críticas."),
    },
    instructions="Escolha o modelo mais barato que consiga concluir a tarefa com segurança.",
)

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

Auto Mode (guardrail de ferramentas): antes de executar uma ferramenta listada, o JEV avalia se a chamada é arriscada. Se for, a ferramenta não roda e o agente recebe um erro no lugar.

from langchain_typesafe.experimental.middleware import AutoModeMiddleware

# delete_all_backups é uma @tool comum, definida antes
agent = create_agent("openai:gpt-6-astra", tools=[delete_all_backups], middleware=[AutoModeMiddleware(tools=[delete_all_backups])])

Para outras decisões (triagem, “a tarefa terminou?”), dá para escrever um middleware próprio que chama o TypeSafeClassifier num hook como before_agent e guarda a resposta no estado do agente.

Limites e ceticismo saudável

Quase todos os números do lançamento vêm da própria TypeSafe, e ela mesma lista os vieses: os testes rodaram de notebooks, os workflows foram criados pelo time e as respostas de referência vieram de modelos da OpenAI e da Anthropic.

Restrições práticas:

• Contexto de 32 mil tokens.
• Até 255 opções por pergunta; acima disso usa um processo em duas etapas, mais lento.
• API fechada, sem pesos publicados nem opção on-premise. Acesso por lista de espera no console da TypeSafe ou pelo Cloudflare Workers AI (typesafe/jev).

Quando usar (e quando não)

Regra prática: LLM para raciocinar e escrever, JEV para as decisões no meio do caminho, sempre com um limiar de confiança e um caminho de escape.

Vídeos

• JEV Breakdown: The First AI Model Built For Code (Rob Shocks, 10 min): demo no playground com os três tipos de pergunta e uma discussão honesta sobre os números (é o vídeo embutido no topo).
• Pydantic is all you need (Jason Liu, AI Engineer Summit 2023): o contexto anterior, de saídas estruturadas com LLMs, que o JEV leva ao extremo.

Referências

• Introducing System One Models & Jev: anúncio oficial, com as ressalvas dos autores.
• Building a harness with Jev: post do LangChain com os middlewares.
• TypeSafe: quickstart e integração com LangChain.
• TypeSafe Jev review e What “System One Models” actually are: análises externas (as duas empresas vendem produtos concorrentes ou complementares, leve isso em conta).