Como fazer um teste cego com os seus dados para escolher entre o Jev e outras IAs de decisão

Benchmark de vitrine não escolhe IA por você, quem escolhe são os seus dados 🙂

Fala aí, beleza? O Jev chegou chamando atenção: é o modelo de decisão da TypeSafe AI e o primeiro modelo público da classe que a empresa chama de System One

Ele saiu em early access em 15 de setembro de 2026 e, por volta de 20 e 21 de setembro, a TypeSafe anunciou que ele estava disponível pra todo mundo, sem lista de espera

Aí bate a dúvida clássica: troco o que já uso por ele ou não?

E é aqui que mora o perigo…

Quem sabe qual IA deu cada resposta tende a avaliar a favor da que já prefere, sem nem perceber

Se tu é fã do modelo X, a resposta meio torta dele vira "interpretação criativa" e a do concorrente vira "erro" haha

Então neste post te mostro como montar um teste cego com o Jev e os concorrentes usando os SEUS casos, escondendo a origem de cada resposta até o final

Por que testar o Jev com os seus próprios dados?

Antes do como, o porquê

O Jev não gera texto livre

Ele recebe um estado (texto ou JSON) e perguntas tipadas, e devolve uma resposta estruturada: uma opção de uma lista fechada, uma nota numa rubrica ou a probabilidade de sim/não, sempre acompanhada da confiança

E os números independentes que existem até agora são bons

Uma avaliação independente no arXiv mediu ECE de 0,028 em 22 datasets de escolha, somando 279.925 respostas

Que ECE?

É o erro de calibração esperado: mede o quanto a confiança que o modelo diz ter bate com o acerto de verdade

Quanto mais perto de zero, mais "honesta" é a confiança

Porém, se liga nisso: o mesmo estudo mostra que essa calibração vale no AGREGADO, não dentro de cada benchmark isolado

Ou seja, somando tudo ele vai bem, mas num conjunto específico a confiança pode escorregar

Outro teste independente, focado em classificação, viu que quando a confiança do Jev era 0,9 ou mais, ele acertava de 94% a 96% das vezes

Massa, né? 😀

Mas de novo: são os casos dos outros, não o seu

Tem também a velocidade: a TypeSafe afirma que o Jev é de 20 a 200 vezes mais rápido que LLMs de uso geral nesse tipo de tarefa

Isso é alegação do fabricante, não medição independente, então entra no teu teste como hipótese a conferir

Resumindo: o número geral é bom, mas não garante o seu caso, e quem responde isso é o teste cego

O que você precisa antes de começar o teste cego?

Nada de PC da Nasa aqui, a lista é curta:

• Casos reais do seu negócio com o rótulo correto já conhecido (a resposta certa, definida por quem entende do assunto)
• Uma pergunta que caiba nos formatos do Jev: escolha numa lista fechada, nota numa rubrica ou sim/não
• Acesso ao Jev por um dos caminhos oficiais: o console e playground em console.typesafe.ai, a API direta em POST https://api.typesafe.ai/v1/systemone com o modelo jev-latest, o Vercel AI Gateway com o ID typesafe-ai/jev ou o Cloudflare Workers AI com o ID typesafe/jev
• Acesso às IAs concorrentes que você já usa hoje pra esse tipo de decisão
• Uma planilha ou um script simples pra guardar entradas, saídas e a chave de quem é quem
• Uma segunda pessoa pra avaliar sem saber a origem das respostas

Um detalhe sobre os concorrentes:

Na prática, a comparação costuma ser com os LLMs que você já usa, rodando em modo de classificação (você pede pra ele responder só com uma das opções)

Passo a passo do teste cego com Jev e concorrentes:

Bora ver na prática? Cada passo tem a sua armadilha clássica

1. Defina a decisão e a lista fechada de respostas possíveis

Escreva a pergunta exata e todas as respostas válidas, tipo: urgente, normal, baixa prioridade

Se for nota, defina a rubrica (o que vale cada nota). Se for sim/não, defina o que é "sim"

Pra ter uma ideia de como o Jev lida com decisão entre alternativas, a demo de wikiracing mostra bem ele escolhendo entre opções fechadas

O erro comum deste passo: fazer uma pergunta aberta que só um LLM de texto livre consegue responder

Aí o teste já nasce torto, favorecendo um dos lados antes de começar

2. Monte o conjunto rotulado a partir de casos reais

Puxe casos do seu histórico (tickets, pedidos, cadastros, o que for) e registre o rótulo correto de cada um ANTES de rodar qualquer IA

Guarde isso numa coluna própria, com data, e não mexa mais

O erro comum deste passo: rotular depois de ver as respostas

Você lê a resposta da IA, acha que faz sentido e ajusta o gabarito pra bater… aí não é mais teste, é torcida

3. Escolha os casos difíceis de propósito

Aqui está o pulo do gato

Caso fácil, todo mundo acerta

Se a sua amostra só tem caso óbvio, todas as IAs vão empatar e você não aprende nada

Então vai atrás dos casos chatos: ambíguos, raros, de borda, e principalmente aqueles que já geraram discussão interna no time (se até gente discordou, é ótimo candidato)

Marque cada caso com uma coluna dificil (1 ou 0) pra poder separar na análise depois

O erro comum deste passo: montar uma amostra só com casos óbvios e sair achando que as IAs são todas iguais

4. Padronize a entrada pra todas as IAs

Mesmo estado (o mesmo texto ou o mesmo JSON) e a mesma pergunta pra todo mundo

Pros concorrentes de texto livre, peça de forma explícita que respondam só com uma opção da lista, sem explicação

Se o pessoal do time já chama o Jev de dentro do editor, vale padronizar o Jev no Claude Code antes da rodada, pra ninguém mudar a entrada por conta própria

O erro comum deste passo: dar contexto extra pra uma das IAs (um exemplo a mais no prompt, uma dica no system prompt) e não pras outras

Já vi muita comparação "vencida" por causa disso

5. Rode e guarde as saídas brutas

Salve tudo exatamente como veio, antes de qualquer tratamento

Pro Jev, registre a resposta (a opção, a nota ou o sim/não) e a probabilidade que ele devolveu, em colunas separadas

Abaixo fica só a estrutura do script: o endpoint e o modelo são os oficiais, mas o corpo da requisição você monta seguindo a documentação da TypeSafe (não vou chutar campo de JSON aqui 😛)

import csv

JEV_ENDPOINT = 'https://api.typesafe.ai/v1/systemone'
JEV_MODEL = 'jev-latest'


def chamar_jev(estado, pergunta, opcoes):
    # Monte a requisição conforme a documentação oficial da TypeSafe
    # Retorne (resposta, confianca)
    raise NotImplementedError


def chamar_concorrente(nome, estado, pergunta, opcoes):
    # Chame a IA que você já usa, pedindo só uma opção da lista
    # Retorne a resposta crua
    raise NotImplementedError


def rodar(casos, pergunta, opcoes, concorrentes):
    with open('respostas_brutas.csv', 'w', newline='', encoding='utf-8') as f:
        w = csv.DictWriter(f, fieldnames=['caso_id', 'ia', 'resposta', 'confianca'])
        w.writeheader()
        for caso in casos:
            resposta, confianca = chamar_jev(caso['estado'], pergunta, opcoes)
            w.writerow({'caso_id': caso['id'], 'ia': 'jev',
                        'resposta': resposta, 'confianca': confianca})
            for nome in concorrentes:
                resposta = chamar_concorrente(nome, caso['estado'], pergunta, opcoes)
                w.writerow({'caso_id': caso['id'], 'ia': nome,
                            'resposta': resposta, 'confianca': ''})

O erro comum deste passo: jogar fora a saída bruta e guardar só a versão "limpa"

Se algo der errado na análise, você não tem como voltar e conferir

6. Anonimize as respostas

Antes de anonimizar, normalize: tudo em minúsculo, sem pontuação, sem explicação extra, mapeado pra uma das opções da lista

Por quê? Porque o formato entrega quem é quem

Se uma IA responde urgente e outra responde "Com base na análise, classifico como Urgente.", o avaliador descobre a origem em dois segundos haha

Depois roda este script, que embaralha as respostas, troca o nome da IA por um código (A, B, C…) sorteado por caso e guarda a chave num arquivo separado

import csv
import json
import random
import string
from collections import defaultdict

# respostas_normalizadas.csv: caso_id, ia, resposta, confianca
por_caso = defaultdict(list)
with open('respostas_normalizadas.csv', newline='', encoding='utf-8') as f:
    for linha in csv.DictReader(f):
        por_caso[linha['caso_id']].append(linha)

avaliacao = []
chave = {}

for caso_id, respostas in por_caso.items():
    random.shuffle(respostas)
    for codigo, r in zip(string.ascii_uppercase, respostas):
        avaliacao.append({'caso_id': caso_id, 'codigo': codigo,
                          'resposta': r['resposta']})
        chave[f'{caso_id}:{codigo}'] = {'ia': r['ia'],
                                         'confianca': r['confianca']}

random.shuffle(avaliacao)

with open('avaliacao_cega.csv', 'w', newline='', encoding='utf-8') as f:
    w = csv.DictWriter(f, fieldnames=['caso_id', 'codigo', 'resposta'])
    w.writeheader()
    w.writerows(avaliacao)

with open('chave_NAO_ABRIR.json', 'w', encoding='utf-8') as f:
    json.dump(chave, f, ensure_ascii=False, indent=2)

Repara que a confiança do Jev vai pra chave, não pro arquivo de avaliação

Se ela aparecesse ali, só o Jev teria essa coluna e pronto, adeus teste cego

O erro comum deste passo: pular a normalização e achar que trocar o nome por "A" já basta

7. Avalie às cegas com uma rubrica fixa

Entregue só o avaliacao_cega.csv e o gabarito pra outra pessoa, de preferência alguém que não montou o teste

A rubrica é simples: acertou ou errou contra o rótulo

Em pergunta de escolha ou sim/não isso é quase mecânico, mas em nota numa rubrica (ou em resposta que ficou no limite) o julgamento humano entra, e é aí que o cego faz MUITA diferença

O erro comum deste passo: mudar a rubrica no meio da avaliação

Se percebeu que a rubrica tem buraco, anota, termina a rodada com a regra antiga e ajusta só na próxima

8. Revele a chave e compare

Agora sim, abre o chave_NAO_ABRIR.json, junta com as notas do avaliador e olha três coisas:

Um script curto resolve:

import pandas as pd

# resultado_revelado.csv: caso_id, ia, acertou (0/1), dificil (0/1), confianca
df = pd.read_csv('resultado_revelado.csv')

print('Acerto geral por IA')
print(df.groupby('ia')['acertou'].mean())

print('Acerto nos casos difíceis')
print(df[df['dificil'] == 1].groupby('ia')['acertou'].mean())

jev = df[df['ia'] == 'jev'].copy()
jev['faixa'] = pd.cut(jev['confianca'], bins=[0, 0.5, 0.7, 0.9, 1.0])
print('Jev: acerto por faixa de confiança')
print(jev.groupby('faixa', observed=True)['acertou'].agg(['count', 'mean']))

Na faixa de confiança alta, o acerto real deveria ficar perto da confiança que o Jev declarou

Se ficar bem abaixo, a calibração não está se sustentando no seu caso (lembra que o estudo independente só garante isso no agregado?)

E olha a coluna count: faixa com poucos casos não diz quase nada

O erro comum deste passo: olhar só a média geral e declarar vencedor

Duas IAs podem empatar no geral e uma delas desabar justamente nos casos que mais importam pro seu negócio

9. Use custo e tempo como desempate

Se a qualidade ficou parecida, aí entra o bolso e o relógio

O preço do Jev é US$ 0,042 por 1 milhão de tokens de entrada, com tokens de saída gratuitos, e a latência informada fica entre 70 e 500 milissegundos (número divulgado, não medição sua, então também entra como hipótese a conferir)

Pros concorrentes, use o preço e o tempo que você paga e mede hoje, na sua conta

E a tal alegação de 20 a 200 vezes mais rápido? Mede o tempo de cada chamada no próprio script e tira a dúvida com os seus números 😉

O erro comum deste passo: decidir só pelo preço antes de olhar a qualidade nos casos difíceis

Barato que erra justo no caso crítico sai caro depois…

Exemplos de casos difíceis para colocar no seu conjunto de teste

Os três tipos de pergunta do Jev cobrem bastante coisa, então seguem exemplos genéricos, cada um com a sua versão "fácil" e a versão que realmente testa

Triagem com categoria fechada (escolha):

Pensa num ticket de suporte que precisa cair em cobrança, bug, dúvida de uso ou cancelamento

O caso fácil é "não consigo pagar o boleto"

O difícil é o cliente que reclama de um erro na tela de pagamento e no fim diz que vai cancelar se não resolver: é bug, cobrança ou cancelamento?

Coloca vários desses, que ficam no limite entre duas categorias

Nota de qualidade numa rubrica (nota):

Aqui o exemplo é dar nota de 1 a 5 pra qualidade de uma descrição de produto, seguindo uma rubrica

O difícil é o texto bem escrito mas com informação faltando, ou o texto completo mas confuso

São justamente os casos em que dois avaliadores humanos costumam dar notas diferentes

Aprovar ou não um item (sim/não):

Tipo decidir se um cadastro pode seguir pra aprovação automática

O difícil é o cadastro com um campo vazio que talvez não seja obrigatório, ou com um dado que parece estranho mas é válido

Dado faltando e dado esquisito são ouro pro seu conjunto de teste, porque é ali que a confiança do modelo deveria cair

E se cair, ótimo: confiança baixa em caso difícil é exatamente o comportamento que você quer ver

Conclusão: decida com dados, não com a marca

Recapitulando: no estudo independente, a calibração do Jev é boa quando você soma tudo, com ECE de 0,028 em 22 datasets

Mas o próprio estudo avisa que isso não vale dentro de cada benchmark isolado, então só o teu teste cego mostra como ele se sai no seu caso

O roteiro é: rótulo antes, casos difíceis de propósito, entrada igual pra todos, respostas normalizadas e anonimizadas, avaliação por outra pessoa, e só no fim a revelação

Próximo passo concreto: separa hoje de 30 a 50 casos reais com rótulo, metade deles difíceis, e roda a primeira rodada pelo playground em console.typesafe.ai antes de partir pra API

Se o resultado for promissor, aí sim vale automatizar com os scripts acima

E se a sua IA atual ganhar, beleza também: agora você sabe por quê, e não por gosto de marca =)

Até o próximo post!