Um modelo de IA que não escreve uma palavra. Você manda o estado do seu sistema (um ticket, um pedido, um log) e uma lista de perguntas com tipo definido: qual equipe atende, de 1 a 5 quão irritado está o cliente, é pedido de reembolso ou não. Ele devolve as respostas de uma vez, cada uma com a probabilidade de estar certa, em 70 a 500 milissegundos, por US$ 0,042 a cada milhão de tokens. Sem chat, sem "vamos analisar", sem alucinar um campo que não existe no seu schema.

Esse é o Jev, lançado em 15 de setembro de 2026 pela TypeSafe AI, e a empresa diz que ele inaugura uma categoria: os modelos "System One". Eu li o post de lançamento, a documentação inteira e a cobertura, e este post é o que eu gostaria de ter lido antes: o que é, pra que serve, pra quem serve, como usar de verdade (com código), quanto custa com as ressalvas que a própria TypeSafe faz, e onde eu colocaria e onde não colocaria isso num sistema que paga conta.

• O que é um modelo "System One" e o que o Jev deixa de fazer de propósito

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

• Como usar: chave, SDK, endpoint e o primeiro JSON

• Confiança calibrada: o número que decide se o software age sozinho

• Preço, velocidade, ressalvas do fabricante e o que eu faria

O que é o Jev, sem marketing

O Jev é um modelo que recebe o estado do seu programa mais um conjunto de perguntas tipadas e responde a todas numa única passagem, devolvendo valores estruturados com probabilidades calibradas em vez de texto. Ele não gera frase, não gera código, não explica o raciocínio. Ele decide, e diz o quanto está seguro da decisão.

O nome da categoria vem de Daniel Kahneman: o Sistema 1 é o pensamento rápido e intuitivo, o Sistema 2 é o lento e deliberado. Um LLM de fronteira, como o GPT-6 Astra ou o Claude Fable 5.1, é Sistema 2: raciocina, escreve, demora segundos. O Jev quer ser o Sistema 1 do seu software: a parte que reconhece e classifica em milissegundos, sem deliberar. O nome do modelo vem de William Stanley Jevons, o economista da ideia de que quando o custo de algo cai, a demanda explode. A aposta declarada da TypeSafe: quando uma decisão custa quase nada, você passa a tomar milhares delas.

Por baixo, a diferença principal está no treinamento. Em vez de RLHF (aprendizado por reforço com preferência humana, o método que produz respostas que avaliadores humanos gostam), a TypeSafe usa o que chama de RLCD, Reinforcement Learning for Calibrated Decisions: as probabilidades são otimizadas contra resultados, não contra gosto. É por isso que a empresa insiste em "calibrado": a intenção é que, quando o Jev diz 84% pra uma opção, ele acerte em cerca de 84% das vezes que diz 84%. Quem fundou a empresa é Diogo Almeida, que trabalhou na OpenAI nos métodos de instrução por trás do ChatGPT; foram quatro anos de pesquisa, dois em segredo, e um seed de US$ 40 milhões liderado pela DCVC, segundo a cobertura do lançamento. O post de lançamento é curto e vale a leitura; a análise da Eigent em português é a melhor explicação de terceiros que encontrei.

LLM escreve. Jev decide. Confundir os dois é o erro que a categoria inteira existe pra evitar.

Os três tipos de pergunta

Tudo no Jev é uma pergunta de um destes três tipos, e você pode mandar várias na mesma chamada. A documentação diz que as perguntas são avaliadas em paralelo e isoladamente, então acrescentar a décima pergunta quase não muda o tempo de resposta.

Tipo	O que faz	Limites	O que devolve
choice	Escolhe uma opção de um conjunto que você define, cada uma com um critério em texto	Até 255 opções	choice, probabilities (uma por opção) e confidence
score	Posiciona o estado numa escala de níveis ordenados, descritos em palavras	De 2 a 10 níveis	score contínuo (pode ser 1,4), legend, probabilities por nível e confidence
noul	Responde se uma afirmação é verdadeira	Uma afirmação por pergunta	noul: uma probabilidade de 0 a 1

O exemplo que a própria documentação usa é um ticket de suporte: numa chamada só, "qual equipe atende" (choice entre billing, técnico e vendas), "quão grave é o bug" (score em três níveis) e "o cliente pediu reembolso explicitamente" (noul). Repare que não existe "resuma o ticket" nem "responda o cliente". Isso continua sendo trabalho de LLM.

Como usar, da chave ao primeiro JSON

O acesso está em early access: a TypeSafe diz que está liberando a fila aos poucos, e a chave sai do console em console.typesafe.ai/keys. A chave vai na variável de ambiente TYPESAFE_API_KEY. Existem SDKs em Python (pip install typesafe-sdk) e JavaScript (npm install @typesafe-ai/sdk), e por baixo é um único endpoint HTTP. O quick start oficial cabe numa tela.

Em Python, uma triagem de ticket com as três perguntas fica assim (os nomes de campo e a forma de cada primitivo são os da documentação; só o conteúdo está em português). No JavaScript o pacote expõe TypeSafeClient e as funções choice(), score() e noul() com a mesma ideia:

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

client = TypeSafeClient()  # lê TYPESAFE_API_KEY

resposta = client.system_one(
    state={
        "ticket": "Fui cobrado duas vezes este mês. Quero o estorno hoje.",
        "plano": "Pro mensal",
    },
    questions={
        "equipe": Choice(
            instructions="Qual equipe deve atender este ticket?",
            criteria={
                "financeiro": "Cobrança, pagamento ou assinatura",
                "tecnico": "Erro, bug ou integração",
                "vendas": "Preço, plano ou conta",
            },
        ),
        "frustracao": Score(
            instructions="Quão frustrado está o cliente?",
            criteria=[
                "Neutro, só quer informação",
                "Incomodado, mas cordial",
                "Irritado, ameaça cancelar",
            ],
        ),
        "pediu_estorno": Noul(
            instructions="O cliente pediu estorno de forma explícita",
        ),
    },
)

r = resposta.answers
print(r["equipe"].choice, r["equipe"].confidence)   # financeiro 0.9x
print(r["frustracao"].score)                         # 2.3, por exemplo
print(r["pediu_estorno"].noul)                       # 0.97

Sem SDK, é um POST em https://api.typesafe.ai/v1/systemone com Authorization: Bearer, corpo com state, model ("jev-latest") e questions. A resposta traz answers com o mesmo nome de cada pergunta, mais usage com tokens de entrada e saída. Os erros são os de sempre: 401 chave inválida, 422 validação, 429 limite de requisições, 529 servidor sobrecarregado.

{
  "model": "jev-latest",
  "answers": {
    "pediu_estorno": { "type": "noul", "noul": 0.97 }
  },
  "usage": { "input_tokens": 312, "output_tokens": 48 }
}

Dois detalhes práticos que a documentação deixa claros. Primeiro: o state é texto, JSON ou lista de textos; sem imagem, áudio ou vídeo por enquanto. Segundo: o modelo só sabe o que está no state. Ele não busca nada, não tem conhecimento de mundo atualizado, não lembra da chamada anterior. Se a decisão depende do histórico do cliente, o histórico tem que ir no state.

Confiança: quando o software age sozinho

A parte mais importante do Jev não é a resposta, é o confidence. A documentação separa dois conceitos: probabilities é a distribuição inteira (quanto cada opção ou nível recebeu), e confidence é essa distribuição colapsada num número de 0 a 1, feito pra você colocar um limiar sem fazer conta. Distribuição concentrada numa opção é resposta confiante; espalhada é dúvida.

A página sobre confiança propõe três faixas, e é o desenho que eu adotaria: alta, o software age sozinho; média, confirma, sinaliza pra revisão ou busca mais informação; baixa, não age, manda pra um humano ou pra outro sistema. O exemplo de código deles usa abaixo de 0,5 pra rotear a um humano e acima de 0,9 pra permitir operação destrutiva sem confirmação, com o aviso de que os limiares certos dependem do seu domínio e devem começar conservadores.

Isso muda o desenho de um agente. Hoje, quando você pede a um LLM "classifique este ticket", ele classifica com a mesma cara de certeza esteja certo ou errado, e você não tem como saber. Com uma confiança calibrada você programa a dúvida: os 80% fáceis passam sem ninguém olhar, os 20% difíceis viram fila humana ou chamada a um modelo caro. Os padrões que a documentação recomenda são todos variações disso:

• Fan-out especulativo: mande muitas perguntas de uma vez, inclusive as que talvez não use, e deixe o código decidir o que é relevante

• Roteamento por confiança: a resposta diz o quê; a confiança diz se deve agir

• Pontuação composta: quebre um julgamento complexo em scores atômicos e combine com pesos que você controla

• Roteamento de intenção: classifique a entrada e mande cada uma pro melhor tratador: lógica determinística, um LLM especialista ou uma pessoa

Uma ressalva que a TypeSafe faz e que eu repito porque é o tipo de coisa que some no entusiasmo: calibração é propriedade do conjunto, não da resposta. Em muitas previsões, os 84% batem com a realidade. Uma resposta específica ainda pode estar errada. O Jev erra; ele só avisa com honestidade estatística com que frequência.

A confiança calibrada não deixa o modelo mais certo. Deixa o seu sistema mais honesto sobre quando não sabe.

Quanto custa e quão rápido, com as ressalvas

Preço de tabela: US$ 0,042 por milhão de tokens de entrada, saída gratuita ("barata demais pra medir", nas palavras deles). Latência declarada de 70 a 500 milissegundos de ponta a ponta, contra 3 a 329 segundos dos LLMs de fronteira nas mesmas tarefas. Nas avaliações de fluxo de trabalho da própria TypeSafe, o Jev saiu 193,6 vezes mais rápido e 444,6 vezes mais barato. A demonstração mais vistosa é o modelo jogando Doom a partir do estado do jogo em texto, a 10 consultas por segundo, por cerca de US$ 7 por hora.

Modelo	Entrada (por 1M tokens)	Saída (por 1M tokens)	Latência típica
Jev (jev-latest)	US$ 0,042	grátis	70 a 500 ms, segundo o fabricante
GPT-6 Astra	US$ 10,00	US$ 50,00	segundos a minutos, conforme o raciocínio
Claude Fable 5.1	US$ 10,00	US$ 50,00	segundos a minutos, conforme o raciocínio

É a conta de "238 vezes mais barato que o Fable 5.1 na entrada" que a TypeSafe estampa no site, e ela bate: 10 dividido por 0,042. Os preços do Astra e do Fable estão nos meus posts sobre Astra contra Fable 5.1 e sobre o cache do Fable 5.1; e sobre velocidade pura, o Ultrafast da OpenAI mostra que os LLMs também estão correndo atrás de latência, só que gerando texto.

Agora as ressalvas, e aqui eu dou crédito à TypeSafe por publicá-las no próprio anúncio em vez de deixar pra gente descobrir. As avaliações rodaram dos laptops da equipe na Costa Oeste dos Estados Unidos, perto do serviço. Os fluxos de trabalho testados foram criados pela própria equipe de capacidades do modelo, e eles admitem que "pode existir viés". A referência de resposta certa é a média do GPT-6 Astra e do Fable 5.1, o que favorece os dois. O "0% de alucinação" não é medição empírica: é que o schema é garantido por construção, então o modelo não inventa campo; ele pode escolher a opção errada. E sobre o preço: "não conseguimos provar que não é subsidiado". Nenhum número de terceiros existe ainda. Trate tudo como afirmação do fabricante até você medir no seu dado.

Pra quem serve, e pra quem não serve

Serve pra quem já tem, ou vai ter, um volume grande de decisões pequenas dentro de um sistema. Triagem de ticket de suporte, roteamento de intenção no chat, moderação de conteúdo, extração de campos de um texto, priorização de fila, pontuação de lead, e um uso que eu acho o mais interessante: guardrail barato na saída de outro modelo ("esta resposta do LLM contém promessa de prazo?", noul, 0,03). Se hoje você paga um LLM pra responder "sim ou não" ou "qual das cinco", você está pagando Sistema 2 pra fazer trabalho de Sistema 1.

Não serve pra chat, pra gerar código, pra escrever e-mail, pra explicar por que decidiu, nem pra qualquer coisa que precise de conhecimento que não está no state. Não serve pra imagem, áudio ou vídeo. E não serve pra quem toma dez decisões por dia: a essa escala, o custo do LLM já é irrelevante e a complexidade de mais um fornecedor não paga. O Jev é pra quem tem milhares.

No golber.net eu tenho decisões desse tipo hoje resolvidas com LLM e prompt. A mais clara: agrupar as perguntas que chegam no chat do site em pautas e marcar quais já têm post. Isso é classificação com confiança, não redação. Se o Jev entregar a calibração que promete, é o primeiro lugar em que eu trocaria, com o LLM continuando como fallback quando a confiança cair. O mesmo raciocínio que aplico em agentes em looping infinito: o problema nunca foi a velocidade do agente, foi ele agir com certeza quando não tinha.

Vale a pena? O que eu faria

Vale a pena testar, não vale a pena migrar. A arquitetura é uma ideia forte e a documentação é a mais honesta que eu li num lançamento de IA neste ano. Mas é versão 0.01, em early access, de uma empresa com dois anos de vida, com benchmark interno, preço que a própria TypeSafe não garante sustentável, sem opção de rodar no seu servidor e com primitivos proprietários. Quem construir a lógica do negócio em cima de choice, score e noul fica preso a um fornecedor que pode não existir em 2028, ou que pode custar dez vezes mais quando o subsídio acabar.

Então o caminho que eu seguiria, e que serve pra qualquer sistema pequeno ou médio:

1. Escolha uma decisão que hoje é LLM e não é crítica. Triagem, categorização, priorização. Nada que mova dinheiro ou dado sensível na primeira rodada.

2. Monte um conjunto rotulado seu. Duzentos ou trezentos exemplos com a resposta certa dada por gente. Sem isso você vai confiar no benchmark do fabricante, e ele já avisou que é enviesado.

3. Meça a calibração, não só o acerto. Agrupe as respostas por faixa de confiança e veja se os "90%" acertam perto de 90%. Se acertam, o número serve pra rotear. Se não, é só mais um classificador.

4. Programe o fallback pela confiança. Abaixo do seu limiar, chama o LLM ou uma pessoa. A economia real vem daí: os fáceis a US$ 0,042, os difíceis ao preço de sempre.

5. Isole o fornecedor. Uma função sua, decidir(estado, perguntas), na frente do SDK. Se o Jev sumir ou triplicar de preço, você troca a implementação e a lógica de negócio não sabe.

6. Olhe pra onde o dado vai. O state é o seu dado, e ele vai pra um servidor nos Estados Unidos. Ticket com CPF, nome e endereço é dado pessoal sob a LGPD; anonimize antes ou não mande.

Se você tem um sistema com fila de decisões repetidas e quer saber se isso é caso de Jev, de um LLM barato ou de uma regra simples que ninguém escreveu ainda, é o tipo de diagnóstico que eu faço numa sessão de consultoria técnica: a gente abre o fluxo, separa o que é Sistema 1 do que é Sistema 2 e monta a medição antes de você assinar mais um fornecedor. E se o seu caso é o de um agente que precisa usar o seu site, o post sobre WebMCP no Next.js é o outro lado da mesma moeda: decisão rápida de um lado, ação segura do outro.

Perguntas frequentes

O que é um modelo System One?

Uma classe de modelo de IA feita pra decisões rápidas e estruturadas dentro de software, em vez de conversa. O nome vem do Sistema 1 de Kahneman (pensamento rápido e intuitivo). O Jev, da TypeSafe AI, é o primeiro modelo público dessa classe.

O Jev substitui o ChatGPT ou o Claude?

Não. Ele não gera texto, código nem explicação. Ele responde perguntas tipadas (escolha, nota, sim ou não) com probabilidade calibrada. O desenho recomendado é usar o Jev pras decisões rápidas e manter o LLM pra escrita, raciocínio e pros casos em que a confiança do Jev fica baixa.

Quanto custa o Jev?

US$ 0,042 por milhão de tokens de entrada e saída gratuita, segundo a tabela da TypeSafe. É 238 vezes mais barato que a entrada do GPT-6 Astra e do Claude Fable 5.1. A própria empresa avisa que não pode provar que o preço não é subsidiado.

Como começar a usar o Jev?

Pedir acesso (está em early access), gerar a chave em console.typesafe.ai/keys, definir TYPESAFE_API_KEY e instalar o SDK: typesafe-sdk no Python ou @typesafe-ai/sdk no JavaScript. A chamada é systemOne com state e questions, ou um POST direto em api.typesafe.ai/v1/systemone.

O Jev alucina?

Ele não inventa campo nem formato: a saída é garantida pelo schema. Mas pode escolher a opção errada. A diferença é que ele devolve a probabilidade de cada resposta e uma confiança de 0 a 1, e a TypeSafe diz que essa confiança é calibrada no conjunto, não garantida em cada resposta individual.

Os benchmarks do Jev são confiáveis?

São afirmações do fabricante: avaliações internas, fluxos criados pela própria equipe, referência de resposta certa baseada na média do Astra e do Fable 5.1, e ainda sem medição independente. A TypeSafe publica essas ressalvas. O certo é medir no seu próprio conjunto de dados antes de decidir.