Jev e outra IA em comitê: quando usar as duas em vez de escolher uma?

Fala aí, beleza? Escolher um único modelo de decisão nem sempre é a melhor arquitetura, e às vezes a resposta certa é: usa os dois 🙂

Se liga no contexto

O Jev é o modelo de decisão da TypeSafe AI, lançado em setembro de 2026, e a versão atual é a jev-1.13.0 (Jev 1.13)

Ele NÃO gera texto: responde perguntas tipadas sobre um estado com valores estruturados, ou seja, escolhas, scores, probabilidades e confiança

E é justamente isso que abre a porta pro comitê

Se a saída é estruturada, dá pra colocar o Jev e outra IA respondendo à MESMA pergunta e comparar voto com voto, sem ficar interpretando parágrafo de chatbot

Neste post tu vai ver quando o comitê compensa, como montar e como desempatar quando as duas discordam

Modelo único, escalonamento ou comitê: qual a diferença?

Antes de montar qualquer coisa, vale separar três arquiteturas que parecem iguais mas não são

O ponto que mais confunde é a linha do meio

Os decision fallbacks do Vercel AI Gateway permitem usar o Jev como primário e configurar outro modelo pra reavaliar respostas incertas

Mas quando a condição é atendida, o Gateway roda de novo o estado original e todas as perguntas no modelo de fallback, e o resultado dele SUBSTITUI o do Jev

Isso é escalonamento, não votação

O voto do Jev não fica preservado nesse resultado, então não dá pra chamar isso de comitê 😛

Em quais casos o comitê de duas IAs compensa?

O comitê custa duas chamadas e duas esperas

O Jev sozinho responde entre 70 e 500 ms, porque toda a saída sai em uma única passada paralela, e a segunda IA soma a latência dela em cima disso

Então a pergunta é: o caso de borda paga essa conta?

Alguns critérios pra decidir:

• Erro caro ou difícil de reverter: se uma decisão errada gera prejuízo, retrabalho grande ou algo que não volta atrás, a segunda camada faz sentido
• Confiança baixa recorrente: a confiança do Jev vai de 0 a 1 e existe só em Choice e Score, ela mede o quanto a distribuição está concentrada (toda a massa em uma opção dá 1.0, distribuição uniforme dá 0). Pergunta que vive perto do zero é candidata natural ao comitê
• Trilha auditável: quando alguém vai perguntar depois "quem decidiu isso e por quê?", ter os dois votos gravados vale MUITO

Se ainda tá mapeando onde o Jev faz sentido dentro do seu software, começa por aí antes de pensar em comitê

Agora o contraponto, beleza?

Em casos claros e de alto volume, a segunda chamada só soma custo e espera

Se o Jev já acerta com confiança alta, colocar outra IA em cima é pagar duas vezes pela mesma resposta haha

E tem situação em que nem o Jev sozinho é a escolha, vale dar uma olhada em quando não usar o Jev antes de empilhar camadas

Um meio-termo que aparece na literatura de ensembles: chamar um modelo de raciocínio mais caro só quando os modelos-base discordam, e cair pro modelo com maior acurácia histórica quando não há consenso

Ou seja, o comitê pode ser barato na maior parte do tempo e caro só onde precisa

O que você precisa antes de montar o comitê:

• Acesso ao Jev por um dos canais disponíveis: API direta da TypeSafe, Vercel AI Gateway ou Cloudflare AI
• Uma segunda IA capaz de devolver a resposta no mesmo formato tipado que o Jev usa
• Uma pergunta tipada já definida, do tipo Choice, Score ou Noul
• Um lugar pra gravar os votos, pode ser um log estruturado ou uma tabela no seu banco

Como montar um comitê com o Jev e outra IA, passo a passo

1. Defina a pergunta tipada comum e o tipo certo

O Jev trabalha com três tipos de pergunta:

• Choice: escolhe uma opção de uma lista e devolve a probabilidade de cada opção, mais a confiança
• Score: avalia o estado em níveis ordenados de uma rubrica e devolve probabilidades, mais a confiança
• Noul: devolve a probabilidade, de 0 a 1, de que uma afirmação seja verdadeira

As duas camadas respondem exatamente a mesma pergunta, com o mesmo tipo

Erro comum deste passo: deixar a outra IA responder em texto livre

Aí tu tem um voto estruturado de um lado e um parágrafo do outro, e os votos ficam incomparáveis

2. Normalize a resposta da segunda IA pro mesmo esquema

Mesmas opções no Choice, mesma rubrica no Score, mesma afirmação no Noul

Se o Jev escolhe entre três opções e a outra IA inventa uma quarta, o comitê já nasceu quebrado

Erro comum deste passo: comparar a confiança do Jev com uma "certeza" que a outra IA declarou sem a mesma definição

A confiança do Jev tem definição clara (concentração da distribuição), já uma IA que diz em texto que está "bem certa" não está medindo a mesma coisa

Tome cuidado! Número parecido não quer dizer métrica igual

3. Escreva a regra de desempate explícita

E o que fazer quando as duas discordam?

Os padrões documentados em artigos de ensembles de LLM são:

• Desempatador designado: um dos modelos tem a palavra final
• Métricas calibradas: desempate usando métricas calibradas de cada modelo, que tem ganho relatado sobre o desempate aleatório
• Desempate aleatório: simples, mas é o piso
• Categoria "sem consenso": a decisão não sai e vai pra outra fila (humano, por exemplo)
• Árbitro: um modelo que avalia os argumentos em vez de contar votos

Dá pra combinar com o fallback pro modelo com maior acurácia histórica quando não há consenso

Um esqueleto em pseudocódigo, sem SDK nenhum:

se voto_jev.escolha == voto_ia2.escolha:
    decisao = voto_jev.escolha
    regra_aplicada = consenso
senao:
    # escolha UMA regra e deixe ela escrita aqui
    decisao = SEM_CONSENSO          # vai pra fila de revisão humana
    regra_aplicada = sem_consenso

Erro comum deste passo: deixar o desempate implícito no código

Tipo um if perdido que sempre favorece quem respondeu primeiro e ninguém lembra por quê… já vi isso virar dor de cabeça em auditoria

4. Registre o voto de cada camada separadamente

Pra cada decisão, grave: resposta de cada camada, probabilidades, confiança quando houver (Choice e Score), regra aplicada e decisão final

Uma estrutura de log genérica fica assim (os nomes dos campos são da SUA aplicação, não da API do Jev):

decisao_id: <id>
pergunta: <nome da pergunta>
tipo: choice | score | noul
voto_jev:
  resposta: <opção, nível ou probabilidade>
  probabilidades: <distribuição>
  confianca: <valor, só em choice e score>
voto_ia2:
  resposta: <opção, nível ou probabilidade>
  probabilidades: <distribuição>
regra_aplicada: <consenso | desempatador | sem_consenso | ...>
decisao_final: <resultado>

Erro comum deste passo: gravar só a decisão final

Sem o voto individual tu perde justamente o que faz o comitê valer a pena: saber quem discordou, quando e com que confiança

5. Acione a segunda camada só quando necessário

Não precisa rodar o comitê em toda decisão

No Vercel AI Gateway, a condição do decision fallback fica assim:

when: { question: 'compatibility', confidenceBelow: 0.6 }

Quer dizer: se a confiança do Jev na pergunta compatibility ficar abaixo de 0.6, entra o modelo de fallback

Porém, lembra da tabela: o Gateway roda de novo o estado original e todas as perguntas no fallback e substitui o resultado

Então, pra manter o comitê com os dois votos, você precisa guardar o voto do Jev na sua aplicação antes, porque no resultado final ele não vem

Erro comum deste passo: usar confidenceBelow em pergunta Noul ou booleana

O Noul devolve uma probabilidade direta, não uma medida de confiança, então confidenceBelow só faz sentido em Choice e Score

Comitê ou modelo único: como decidir no seu projeto

O critério central é simples: comitê só onde o caso de borda paga a segunda chamada

E quando tiver comitê, ele precisa de três coisas: pergunta tipada comum, desempate escrito e votos registrados separadamente

No resto, o Jev sozinho resolve, ou o escalonamento por confiança do Gateway, sabendo que lá o fallback substitui o voto original

O próximo passo natural é definir os limites de confiança de cada pergunta, ou seja, a partir de qual valor tu age, escala pra humano ou recusa 😀

Até o próximo post!