Jev e Laya além do hype: o que modelos de decisão fazem que o LLM não faz

Enquanto eu estudava o Jev e a Laya, o feed vendia os dois como o próximo LLM pequeno. Mini-ChatGPT, tweet de lançamento. Esse é o hype. Além dele, o que eles fazem é escolher uma porta, não escrever um parágrafo.

A porta serve delivery no WhatsApp, central de atendimento, marketplace, loja que vive de pedido e estorno. "Cadê o pedido?", "cancela", "quero estorno". O reflexo é chamar um LLM: ele escreve um texto e você ainda extrai a etiqueta. O Jev devolve a escolha em 0,17 s de P50 no OpenRouter. Time pequeno resolve com a API, ou com a Laya no localhost. A Julia-1 entra na mesma família, de passagem.

Eu cheguei nisso pelo Downshift. Cada subagente acordava no topo do SWE-bench. Jev e Laya são classificadores. Estudar eles me deu a ideia de adotar um no Downshift também. O MiniLM local foi essa adoção. Com Jev e Laya eu só fiz POCs. Os exemplos da seção 8 saem do Downshift.

Índice

• 1. LLM adivinha a próxima palavra, Jev escolhe uma porta
• 2. Jev na prática: saída finita, confiança e log
• 2b. Preço, latência e o que o pessoal já fez
• 3. Quando texto livre vence: o LLM entra depois da decisão
• 4. A dupla que economiza token: Jev filtra, LLM só entra quando precisa
• 5. Trade-offs honestos de modelo de decisão contra LLM
• 6. Antes de mandar pro Opus, decida se ele entra na rota
• 7. Evidência: o que a pesquisa sustenta
• 8. Jev e Laya no seu harness pessoal

1. LLM adivinha a próxima palavra, Jev escolhe uma porta

LLM é um modelo generativo. Ele prevê a próxima palavra dada a sequência anterior. Por isso ele escreve, resume, traduz e explica bem. E por isso a mesma pergunta pode gerar três respostas diferentes, com temperatura, ordem e contexto mudando o resultado.

Jev é o oposto: um modelo classificador e de decisão. Ele é produto real, o System One decision model da TypeSafe, disponível como typesafe/jev-1.13 no OpenRouter. Ele recebe um estado e devolve uma entre N classes que você definiu antes, com probabilidade calibrada e tipos nativos como noul, choice e score. Cena didática, para o mecanismo ficar visível. Não é telemetria da minha loja:

entrada: "minha fatura veio dobrada, quero estorno"
Jev -> { label: "reembolso", confidence: 0.94 }
entrada: "onde acompanho minha entrega?"
Jev -> { label: "rastreio", confidence: 0.91 }
entrada: "quero falar do plano anual para 40 pessoas"
Jev -> { label: "comercial", confidence: 0.88 }

Nada de parágrafo. Só etiqueta mais confiança. O número que não é cena está no Jev Lab de triage: 95 mensagens, cinco perguntas sim ou não, 475 respostas em 1,2 s, $0,0014 a rodada. E Laya também não é apelido: é um engine System One open-source que expõe o mesmo protocolo /v1/systemone do Jev, com modelos english, multilingual e typed-decisions (ver guia de uso), para decidir local sem API key. Quem redige a resposta final para o cliente é um LLM comum, que entra depois que a rota já foi decidida.

A diferença que importa para um mid-level recontar em uma frase: LLM escreve texto aberto e varia; Jev aponta uma porta entre poucas portas e repete.

2. Jev na prática: saída finita, confiança e log

O mecanismo, sem chamar a API do Jev. Um classificador simples resolve sem GPU, sem prompt de 2 mil tokens, sem retry criativo. Qualquer dev roda local:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression

texts = [
  "quero reembolso da fatura",
  "cobrança duplicada no cartão",
  "onde está minha entrega",
  "rastrear meu pedido",
  "orçamento para empresa",
  "plano anual para time",
]
labels = ["reembolso", "reembolso", "rastreio", "rastreio", "comercial", "comercial"]

vec = TfidfVectorizer()
X = vec.fit_transform(texts)
decisor = LogisticRegression().fit(X, labels)

def decidir(frase: str) -> dict:
    proba = decisor.predict_proba(vec.transform([frase]))[0]
    idx = proba.argmax()
    return {"label": decisor.classes_[idx], "confidence": round(float(proba[idx]), 2)}

print(decidir("fui cobrado duas vezes"))
# -> {"label": "reembolso", "confidence": 0.81}

Três propriedades que o LLM não te dá de graça:

• Saída finita: só existem reembolso, rastreio, comercial. Dá para validar com enum, testar com tabela, auditar no Grafana.
• Confiança calibrável: abaixo de 0.70 você manda para revisão humana ou para o LLM com contexto extra. Acima, segue o fluxo automático.
• Determinismo: mesma entrada, mesma saída. Sem temperatura para tunar, sem prompt que quebra porque alguém mudou uma vírgula.

É por isso que time de suporte e pagamento gosta de decisor: dá para escrever teste unitário em cima. Com LLM puro, cada teste vira aproximação semântica.

Isso não é opinião. Em intenção com rótulo fixo, pequeno fine-tuned ainda vence grande generativo: em Banking-77 e CLINC-150, DistilBERT superou Phi-2 e Llama-3-8B com PEFT, com F1 em torno de 0.92 contra 0.88 e 0.83, treinando e inferindo mais rápido. Em CLINC-150 com 151 intenções, DistilBERT marcou 0.889 de acurácia com 5.3ms contra 0.888 da RoBERTa. Para tabular, CatBoost, LightGBM e XGBoost seguem no topo do benchmark amplo com 20 modelos, à frente de MLP e ResNet na maioria dos datasets.

2b. Preço, latência e o que o pessoal já fez

Números do OpenRouter no dia em que eu conferi. A latência do LLM é o começo da resposta: depois ele escreve e você paga a saída. A do Jev é a decisão inteira.

O V3.2 barato no papel ($0.2088) aparece com 1,32 s em um provider. O R1 é o extremo: entrada 16x a do Jev, saída cara, mais de um segundo antes de começar. Para classificar antifraude ou liberar um request, o DeepSeek é o modelo errado. Para escrever o parecer depois da etiqueta, aí sim.

O que já existe, com URL. Não achei delivery no WhatsApp em produção com número de negócio. O encaixe da intro é analogia. O que tem nome é isto.

Lab, ao vivo no browser (Jev Lab):

• Triage de atendimento: 95 mensagens, 475 respostas em 1,2 s, $0,0014 a rodada.
• Checkout que reage ao clique: 8 respostas em 300 ms, $0,0001 por checagem.
• Filtro de feed: 40 posts em 0,5 s, $0,0003 a rodada.

Receita oficial (hub do Jev):

• Permissão de coding agent: libera git diff e bun test, segura git push --force.
• Classificar e taguear em lote: ticket, post, review. $0,014 em 550 tweets no exemplo publicado.
• Moderação de marketplace: categoria errada, preço estranho, PIX por fora.
• Cascata barata com verificação: o frontier só entra se o Jev recusar o rascunho.

Repo da comunidade:

• metis-triage: issue vira label. O comentário continua template.
• jev-mcp e jev-review: julgamento no MCP e review de diff.

3. Quando texto livre vence: o LLM entra depois da decisão

Seria desonesto dizer que Jev resolve tudo. Quando a resposta precisa de nuance, contexto longo ou empatia, texto livre vence.

Cena que o classificador não resolve sozinho:

cliente: "assinei o anual ontem, mas meu sócio saiu hoje
e vamos reduzir de 40 para 6 pessoas. Consigo ajustar
sem multa? Estou preocupado com o orçamento."

Jev -> { label: "comercial", confidence: 0.83 }
LLM -> redige proposta com 2 opções, cita cláusula
de redução, sugere data de vigência e pergunta qual prefere.

O Jev acertou a rota em milissegundos. Mas só o modelo generativo monta a resposta com tom, condição e alternativa. Tentar fazer isso com regra e template vira um ninho de if que ninguém mantém depois de três meses.

Regra prática que uso: Jev e Laya decidem o quê fazer; o LLM decide como dizer.

4. A dupla que economiza token: Jev filtra, LLM só entra quando precisa

O ganho de token não vem de mágica. Vem de não chamar o modelo caro para o trabalho barato. Em uma frase: o roteador tira do LLM a triagem, a classificação e o gate de confiança, e deixa para ele só a redação final. O resto desta seção mostra como isso fica em código.

Padrão que tenho aplicado, roteador antes do gerador:

type Rota = "reembolso" | "rastreio" | "comercial" | "revisao_humana";

async function atender(ticket: string): Promise<string> {
  const decisao = await jevDecide(ticket); // Jev via API ou Laya local: milissegundos, custo quase zero

  if (decisao.confidence < 0.7) {
    return filaRevisao(ticket, decisao); // humano decide, sem gastar LLM
  }

  if (decisao.label === "rastreio") {
    return respostaTemplateRastreio(ticket); // nem chama LLM
  }

  // só aqui o LLM entra, já com rota e contexto enxuto
  return llmResponder(ticket, decisao.label);
}

Por que isso corta custo de verdade:

• Ticket de rastreio nunca acorda o LLM: lookup mais template.
• Ticket ambíguo vai para humano antes de gastar retries; quando o LLM entra, o prompt já vem curto e com a intenção resolvida.
• Sem chave de API ou offline, a Laya decide local no mesmo protocolo, sem mudar o request.

Laya no seu dia a dia: o mesmo request, sem API key. Suba o laya-serve local e aponte o cliente para ele. O protocolo é o mesmo do Jev, então o código que você testa na máquina é o que falaria com o gerenciado:

// TYPESAFE_BASE_URL=http://localhost:8002 TYPESAFE_API_KEY=local-test (Laya local)
// TYPESAFE_BASE_URL=https://api.typesafe.ai (Jev gerenciado)
const res = await fetch(`${process.env.TYPESAFE_BASE_URL}/v1/systemone`, {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.TYPESAFE_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "typed-decisions", // na Laya: english, multilingual ou typed-decisions
    state: { ticket: "fui cobrado duas vezes na fatura" },
    questions: {
      rota: {
        type: "choice",
        instructions: "Para qual fila vai este ticket?",
        labels: ["reembolso", "rastreio", "comercial"],
      },
      confianca_baixa: {
        type: "noul",
        instructions: "O pedido está ambíguo ou fora do escopo das filas?",
        labels: { yes: "Ambíguo", no: "Claro" },
      },
    },
  }),
});
const { answers } = await res.json(); // tipado, com probabilidade: sem parsing de texto

Três usos que a POC me pagou:

• Dev local sem key: testo o roteador no localhost antes de gastar um token sequer.
• CI: o teste do roteador vira assert em cima de answers.rota, igual teste de enum.
• Fallback: sem rede ou sem verba de API, a Laya decide local; com chave, o mesmo código fala com o Jev.

Esquema completo de campos no comparativo Laya vs Jev. E re-tune não é conselho vago, é número: para a distribuição {0.91, 0.04, 0.03, 0.02}, a Laya reporta confiança ~0.71, onde a fórmula de probabilidade máxima daria ~0.88. Mesmo request, gate diferente. Calibre o corte por fonte:

const corte = fonte === "laya" ? 0.6 : 0.7; // Laya e Jev não compartilham threshold
if (decisao.confidence < corte) return filaRevisao(ticket, decisao);

Em termos de harness: Jev é guia computacional antes da geração. Ele é barato, testável e roda no PR e CI como qualquer código. O LLM fica como passo inferencial depois do gate, com trilha de auditoria do que o decisor escolheu. Se um dia o decisor errar, você tem label, confiança e entrada no log, não um prompt gigante para adivinhar o que aconteceu.

Quanto custa decidir, em números verificados:

• Jev gerenciado: $0.042 por milhão de tokens de entrada, saída grátis (preço do Jev 1.13). Cada resposta traz usage.cost em dólar: dá para logar custo por rota junto com label e confiança.
• Laya local: custo marginal perto de zero. Você paga a máquina que já tem mais o download do modelo, e decide offline quantas vezes quiser.
• Ordem de grandeza (estimativa da minha POC, não benchmark): avaliação via decisor sai cerca de 50 a 100x mais barata que a mesma avaliação via GPT-4, que custa por token de entrada e de saída a cada retry.

Por isso a conta fecha: o roteador tira do LLM as chamadas baratas e repetidas (triagem, classificação, gate de confiança) e deixa para ele só a redação final. Cada ticket de rastreio que nunca acorda o LLM é token que não aparece na fatura.

O número que sustenta esse desenho vem de roteamento entre modelos: RouteLLM economizou até 3.66x no MT-Bench mantendo 95% da qualidade do GPT-4, e FrugalGPT em cascata economizou de 50% a 98% mantendo a acurácia do melhor modelo isolado. A lógica é a mesma do Jev: não acordar o modelo caro para o trabalho barato.

5. Trade-offs honestos de modelo de decisão contra LLM

Visão Staff, sem hype de mercado. Cada linha abaixo já me mordeu ao menos uma vez.

Três cuidados que o hype esconde:

1. Decisor apodrece em silêncio. Se surge um produto novo ou um golpe novo, o Jev continua classificando com confiança alta no vocabulário velho. Sem monitoramento de distribuição e re-rotulagem periódica, vira débito técnico.
2. Rótulo custa gente. LLM aceita 5 exemplos no prompt. Jev pede centenas de exemplos revisados para ficar estável. Esse custo aparece no planejamento, não na demo.
3. LLM cobre o buraco do decisor. Classe nova, idioma novo, caso raro: o LLM atende no improviso enquanto você coleta dados para treinar o Jev. Arquitetura boa usa os dois, não elege um vencedor.

Deixar claro, porque já vi confusão em review: Jev e Laya não são mini ChatGPTs. Eles não conversam, não resumem, não escrevem. Laya cai na mesma coluna do Jev, com duas diferenças práticas: roda local e open-source, e os thresholds precisam ser re-tunados porque a confiança é calculada de outro jeito. Se você pedir texto para eles, vai receber etiqueta. Se pedir decisão auditável para o LLM puro, vai receber parágrafo bonito que muda amanhã. Sem texto livre não significa sem erro: o modelo pode devolver exatamente o enum esperado e ainda escolher o enum errado.

6. Antes de mandar pro Opus, decida se ele entra na rota

O Jev ou a Laya não corrigem o botão. Eles decidem quem deveria corrigir.

"corrija o texto desse botão"
        ↓
decision / router
        ↓
mecânica + baixo risco → modelo pequeno
        ↓
lint / teste passou?
   sim → encerra
   não → sobe para Sonnet / Sol / Opus

"Menor" não é número de parâmetros. É custo por tarefa, latência e capacidade suficiente. O nome do modelo muda. A estratégia não: a menor capacidade que ainda passa no seu critério.

Benchmark é ponto de partida, não política de routing. O que vence o leaderboard pode perder no seu repo, com o seu contexto, as suas tools e o seu orçamento. No harness, o que importa é: acerto, custo por tarefa que deu certo, latência, retries, taxa de escalada, tokens, resultado de teste ou lint.

Para comparar sem feeling: Artificial Analysis (custo, velocidade, latência) e SWE-bench Verified (tarefa real de engenharia). O resto é instrumentar a sua operação.

Não escolha pela marca. Escolha o menor que cumpre. Se falhar, escale. É a tese do Downshift: small-first, frontier sob demanda.

7. Evidência: o que a pesquisa sustenta

Sem prometer número do seu ticket. Estes são os benchmarks nos datasets deles, que uso como limite do que dá para afirmar:

• Tabular: benchmark com 20 modelos coloca CatBoost, LightGBM e XGBoost no topo, à frente de deep learning na maioria dos datasets (completo, XGBoost vs LightGBM).
• Intenção: DistilBERT fine-tuned vence Phi-2 e Llama-3-8B em Banking-77 e CLINC-150, com F1 0.92 contra 0.88 e 0.83 (Intent Recognition using DistilBERT). Em CLINC-150, 0.889 de acurácia com 5.3ms de inferência (avaliação BERT, RoBERTa e DistilBERT). Híbrido encoder mais LLM mantém precisão com cerca de 50% menos latência (Intent Detection in the Age of LLMs).
• Few-shot: TabLLM vence com 8 exemplos ou menos, mas com ajuste de split o LightGBM melhora 290% e a vantagem cai 84.5%. A partir de 16 a 64 exemplos, GBDT empata por fração do tempo (GBDT and LLMs for few-shot). Fusão LLM mais GBDT vence no meio do caminho (LLM-Boost).
• Roteamento: RouteLLM com 3.66x no MT-Bench, 1.41x no MMLU e 1.49x no GSM8K, ver também blog LMSYS.
• Jev real: documentação no OpenRouter, tutorial de primeira chamada e preço e providers do Jev 1.13 ($0.042/M tokens de entrada, saída grátis). Cases públicos na seção 2b.
• Laya real: comparativo Laya vs Jev (mesmo protocolo, confiança com cálculo próprio, re-tunar thresholds) e guia de uso no Spring AI.
• Cascata: FrugalGPT com 50% a 98% de economia, paper final em TMLR.

Onde tenho segurança para recomendar Jev: saída em enum, alto volume, precisa de auditoria e latência baixa. Onde não prometo número: economia exata no seu fluxo. Meça acerto, confiança e custo por rota por um mês antes de cravar.

8. Jev e Laya no seu harness pessoal

Jev e Laya ensinaram o classificador. Eu adotei um no Downshift. Eles foram POC. No Cursor, quem decide o spawn é o Downshift: typo no barato, gate de PRD no frontier. É o mesmo model routing, sem segundo LLM-judge e sem contexto gordo antes da skill.

$ downshift try "fix a typo in the README"
→ TRIVIAL → claude-haiku-4-5

$ downshift try "rearchitect the payment flow across services"
→ COMPLEX → claude-opus-4-8

Nenhum LLM na classificação. Default do binário: hash-embed-v1. O MiniLM local é a adoção do classificador, só entra com DOWNSHIFT_MINILM_EMBED.

Holdout all-MiniLM-L6-v2, 300 prompts em inglês: 287 certos (95,7%). Com margem 0,02, 97,9%. P50 1,87 ms. Erra no MEDIUM (85,3%). Esse número é do MiniLM, não do hash. Português pede modelo multilingual.

Decisor decide, gerador escreve, humano veta.

Para debater: na sua próxima tarefa de agente, o que você prefere?

• A) Decisor determinístico (Jev/Laya/regra) escolhe a rota; o LLM só redige quando precisa.
• B) LLM classifica e roteia tudo (mais simples de montar, mais caro e menos auditável).
• C) Ainda não separou as duas camadas.

Conta qual letra e o primeiro passo que você faria na segunda-feira.