Como montar um conjunto de casos rotulados para validar o Jev antes de ir para produção

Uma ou duas tentativas boas no Jev não dizem NADA sobre se ele aguenta produção

Fala aí, beleza? O Jev chegou chegando e a vontade de plugar ele direto no seu fluxo é grande, eu sei haha

Mas se liga: o Jev é um modelo da TypeSafe AI que não gera texto em linguagem natural

Ele devolve valores tipados, com probabilidades e confiança, feitos pra outro software consumir

Ele entrou em acesso antecipado limitado em 15 de setembro de 2026, junto com o anúncio de uma rodada seed de US$ 40 milhões liderada pela DCVC

E aqui tá o ponto: a documentação da TypeSafe diz que o limiar de confiança depende de cada caso de uso e precisa ser testado nos dados do próprio cliente

A integração do Jev na Pydantic AI vai na mesma linha: medir a acurácia, a taxa de repasse para revisão e qualquer limiar em exemplos rotulados próprios antes de confiar neles

Ou seja, o jeito honesto de validar o Jev é com um conjunto de casos rotulados, não com impressão 🙂

Bora montar esse conjunto passo a passo?

Pré-inscrição Curso Jev

Domine o Jev e coloque decisões de IA dentro do seu sistema

Você vai aprender a usar o Jev, o System One Model da TypeSafe AI, pra automatizar decisões com resposta tipada e confiança medida, sem depender de chat nem de alguém revisando cada passo. Entre na lista de espera para garantir a condição de lançamento!

Quero minha vaga

O que você precisa antes de começar:

Antes de anotar o primeiro exemplo, vale deixar três coisas prontas

Como acessar o Jev pela API?

O acesso direto é pela API da TypeSafe:

• Endpoint: POST https://api.typesafe.ai/v1/systemone
• Modelo: jev-latest
• SDKs oficiais em Python e JavaScript

Se você já usa gateway, tem alternativa:

• Vercel AI Gateway: typesafe-ai/jev
• OpenRouter: jev-latest e jev-1.13

Qual tipo de pergunta o seu caso usa?

O Jev tem três tipos de pergunta, e os três podem ir na mesma requisição:

• Choice: escolhe uma entre as opções que você define (até 255 opções) e devolve a probabilidade de cada opção e a confiança
• Score: posiciona a entrada numa rubrica ordenada (de 2 a 10 níveis) e devolve uma nota ponderada pela probabilidade, a distribuição completa e a confiança
• Noul: devolve a probabilidade de sim (de 0 a 1) numa pergunta de sim ou não, e NÃO tem campo de confiança

Isso importa MUITO pro rótulo: o formato da resposta certa que você anota tem que ser o mesmo formato que o Jev devolve

Exemplos reais e alguém que saiba a resposta certa

Você vai precisar de uma fonte de exemplos reais do seu produto (tickets, mensagens, formulários, o que for a entrada da decisão)

E de alguém que conheça o domínio pra anotar a resposta certa de cada um

Sem isso, o conjunto vira chute rotulado por chute… e aí não mede nada

Passo a passo para montar e rodar o conjunto de validação:

Passo 1: Defina a pergunta e o rótulo esperado no formato do Jev

Comece escrevendo a pergunta exatamente como ela vai para o Jev

No Choice, liste as opções. No Score, escreva os níveis da rubrica. No Noul, deixe claro o que é sim e o que é não

O rótulo de cada exemplo precisa ser UMA dessas opções, um desses níveis ou um sim/não

O erro comum deste passo: anotar rótulo que não bate com as opções enviadas. Se o anotador escreve reembolso e a opção no Choice é estorno, a métrica vai marcar erro onde não tem erro (ou esconder erro onde tem)

Passo 2: Colete exemplos reais e anote a resposta certa

Puxe exemplos da fila real do seu produto, não de uma lista que alguém imaginou

Pra cada exemplo, a pessoa que conhece o domínio anota a resposta certa

Se esses exemplos têm dado de cliente, vale ver antes o que anonimizar no state do Jev antes de mandar qualquer coisa pra API

O erro comum deste passo: usar exemplos inventados ou só os fáceis. Conjunto fácil dá número bonito e não diz nada sobre o que acontece na segunda-feira de manhã com a fila cheia

Passo 3: Escolha os casos difíceis por categoria

Uma prática recomendada pela comunidade é montar o conjunto de avaliação com cinco categorias:

• Comuns: o grosso do volume do dia a dia
• Limítrofes: casos que ficam na fronteira entre duas opções ou dois níveis
• Raros: coisas que aparecem pouco, mas aparecem
• Adversariais: frases escritas pra confundir, ambíguas ou com ironia
• Deveriam ir para revisão: casos em que o certo é o sistema NÃO decidir sozinho

Marque a categoria de cada exemplo numa coluna própria, você vai precisar dela no passo 6

O erro comum deste passo: montar um conjunto sem casos que deveriam ser repassados. Sem eles, você não tem como saber se o limiar está mandando pra revisão o que deveria

Passo 4: Separe calibração e teste intocado

Divida os exemplos em dois grupos:

• Calibração: onde você olha, erra, ajusta e escolhe o limiar
• Teste: fica guardado e só é usado no final, pra confirmar

Como referência, um teste de terceiros sobre a calibração do Jev dividiu os exemplos 60/40: 5.280 de calibração e 3.521 de teste, com o conjunto de teste intocado

Não existe tamanho mínimo oficial confirmado pela TypeSafe, então use essa divisão como referência de proporção, não como regra

E garanta que as cinco categorias apareçam nos dois grupos

O erro comum deste passo: ajustar o limiar olhando o conjunto de teste. Aí ele deixa de ser teste e vira calibração disfarçada, e o número final fica otimista demais

Passo 5: Rode o Jev sobre os casos e guarde tudo

Agora sim, bora ver na prática?

O código abaixo é um esqueleto a adaptar: o formato exato do corpo da requisição, a autenticação e os nomes dos campos da resposta vêm da documentação da TypeSafe

Por isso ele guarda a resposta crua inteira, e você extrai os campos depois

import json
import requests

URL = 'https://api.typesafe.ai/v1/systemone'
MODELO = 'jev-latest'

def cabecalhos():
    # ESQUELETO: autenticacao conforme a documentacao da TypeSafe
    raise NotImplementedError

def montar_corpo(caso):
    # ESQUELETO: monte o corpo conforme a documentacao,
    # usando MODELO, o tipo de pergunta (Choice, Score ou Noul),
    # as opcoes ou a rubrica e a entrada do caso
    raise NotImplementedError

def rodar(casos, arquivo_saida):
    with open(arquivo_saida, 'w') as saida:
        for caso in casos:
            resp = requests.post(URL, headers=cabecalhos(), json=montar_corpo(caso))
            resp.raise_for_status()
            registro = {
                'id': caso['id'],
                'categoria': caso['categoria'],
                'rotulo': caso['rotulo'],
                'resposta_crua': resp.json(),  # guarda TUDO
            }
            saida.write(json.dumps(registro) + '\n')

Depois, numa etapa separada, você extrai de resposta_crua a opção escolhida, as probabilidades e o confidence (no Choice e no Score) ou a probabilidade de sim (no Noul)

O erro comum deste passo: descartar a confiança e guardar só a resposta. Sem a confiança você não consegue escolher limiar nenhum, e vai ter que rodar tudo de novo

Passo 6: Meça acurácia e taxa de repasse para revisão

As duas métricas que a integração na Pydantic AI pede são a acurácia e a taxa de repasse para revisão

Um cálculo simples, já quebrado por categoria:

from collections import defaultdict

def resumo(resultados, limiar):
    contagem = defaultdict(lambda: {'total': 0, 'automaticos': 0, 'acertos': 0})
    for r in resultados:
        c = contagem[r['categoria']]
        c['total'] += 1
        if r['confianca'] < limiar:
            continue  # vai para revisao
        c['automaticos'] += 1
        if r['resposta_jev'] == r['rotulo']:
            c['acertos'] += 1
    for categoria, c in contagem.items():
        repasse = 1 - c['automaticos'] / c['total']
        acuracia = c['acertos'] / c['automaticos'] if c['automaticos'] else None
        print(categoria, 'acuracia:', acuracia, 'repasse:', round(repasse, 3))

No Noul, troque confianca pela sua regra em cima da probabilidade de sim, já que ele não tem campo de confiança

O erro comum deste passo: olhar só o número geral. Uma acurácia geral alta pode esconder que o Jev erra quase todos os adversariais, porque os comuns inflam a média

Como ler os acertos por categoria e por faixa de confiança

Com o resumo rodando, você monta duas leituras: por categoria e por faixa de confiança

Acerto por categoria: o que observar em cada uma?

A categoria de revisão é a mais reveladora: ela mostra se o roteamento funciona, não só se a resposta está certa

Confiança e probabilidade são a mesma coisa?

Não! E essa confusão é clássica

No Choice e no Score, a confiança vai de 0 a 1 e é calculada pelo formato da distribuição, ou seja, pelo quanto ela está concentrada

Já a probabilidade da opção escolhida é outra coisa: é a estimativa de que aquela resposta esteja certa

Na sua tabela, guarde as duas em colunas separadas e faça as faixas pela confiança

Por que a faixa de confiança importa tanto?

O mesmo teste de terceiros mostra isso bem com o Noul:

Na faixa baixa, o acerto ficou abaixo de cara ou coroa. Na faixa alta, acertou tudo

A média geral esconde completamente essa diferença, por isso a leitura por faixa é o que te mostra onde dá pra automatizar

Lembrando que, no seu próprio conjunto, o Noul não tem campo de confiança: a leitura dele é pela probabilidade de sim

E o recado mais importante: a confiança serve pra rotear, mas a taxa de acerto precisa ser medida em dados rotulados representativos do seu caso

Como escolher o limiar de confiança para produção:

Aqui é onde o conjunto rotulado se paga

Esse é o coração de como validar as decisões do Jev antes de automatizar qualquer coisa:

1. No conjunto de calibração, rode o resumo com vários limiares e veja como acurácia e taxa de repasse mudam
2. Escolha o limiar que dá a acurácia que o seu negócio aguenta com uma taxa de repasse que o seu time consegue absorver
3. Rode UMA vez no conjunto de teste intocado pra confirmar que o número se sustenta
4. Em produção, automatize só o que fica acima do limiar e mande o resto pra um humano ou pra um LLM mais lento

A TypeSafe é clara: o limiar depende do caso de uso e deve ser testado nos seus dados

O erro comum deste passo: copiar o limiar de outro caso de uso (ou de um post na internet). Um limiar que funciona pra triagem de ticket pode ser péssimo pra classificação de risco, tome cuidado!

E vale ser honesto sobre o que o Jev entrega

Em gráficos de confiabilidade, ele fica com 0% de erro em saída estruturada e em chamada de ferramenta, ou seja, o formato não quebra

Porém os LLMs de ponta ainda levam vantagem de 5 a 6 pontos em acurácia em tarefas de baixo volume

Então quem decide se o Jev serve pro SEU caso não é o hype nem o benchmark, é o seu conjunto rotulado

Próximo passo: validar antes de automatizar

Recapitulando: decisão de produção se toma com número do seu próprio conjunto rotulado, não com a impressão de duas tentativas que deram certo

O caminho é definir o rótulo no formato do Jev, coletar exemplos reais, cobrir as cinco categorias, separar calibração e teste, guardar resposta, probabilidade e confiança, e ler o acerto por categoria e por faixa

O próximo passo concreto: separa hoje exemplos das cinco categorias da sua fila real e roda a primeira medição, mesmo que pequena

E tem um detalhe que ajuda: o preço de tabela do Jev é US$ 0,042 por milhão de tokens de entrada, com saída gratuita, então rodar a validação inteira tende a sair barato

Muito melhor descobrir onde ele erra no seu conjunto do que na fila de produção, né? 😀

Até o próximo post!