---
title: "Jev e System One na prática: além dos loops de retry e das gambiarras de parsing"
author: "Pedro Dalben"
date: "2026-09-19T18:45:15Z"
category: "Arquitetura & CTO"
reading_time: "13 min"
canonical: "https://pedrodalben.com.br/blog/jev-e-system-one-na-pratica-alem-dos-loops-de-retry-e-das-gambiarras-de-parsing"
---

# Jev e System One na prática: além dos loops de retry e das gambiarras de parsing

> Uma análise técnica sobre amostragem restrita com Jev, os limites de confiança em produção e sete projetos práticos para Python e Ruby.

**Autor:** Pedro Dalben (CTO no Integrar Plus)  
**Publicado em:** 19 de September de 2026  
**URL Canônica Oficial:** [https://pedrodalben.com.br/blog/jev-e-system-one-na-pratica-alem-dos-loops-de-retry-e-das-gambiarras-de-parsing](https://pedrodalben.com.br/blog/jev-e-system-one-na-pratica-alem-dos-loops-de-retry-e-das-gambiarras-de-parsing)  

---


A indústria de software passou quase quatro anos aceitando uma aberração arquitetural como padrão: pedir para um modelo de linguagem gerar texto livre supostamente em JSON, descobrir que ele quebrou a sintaxe na terceira chave e torrar dinheiro com retry e biblioteca de conserto de string. Quem opera servidor próprio conhece o tamanho do desperdício de memória e CPU nessa brincadeira.

Nos últimos meses acompanhei a documentação do System One da TypeSafe e o repositório awesome-jev, que cataloga mais de cem projetos construídos sobre o Jev. Vejo dois grupos errando o alvo por motivos opostos. De um lado, quem insiste que prompt mais detalhado e validação tardia no application server resolvem confiabilidade. Do outro, quem trata decisão tipada como varinha mágica que dispensa calibração. Eu discordo dos dois. Validar texto gerado depois do fato é negligência com latência. Mas forçar o modelo a escolher dentro de uma lista fechada sem tratar rejeição cria um perigo pior: o sistema erra com certeza absoluta dentro de um conjunto arbitrário. O Jev interessa exatamente aí, não como mágica, como primitivas de julgamento que o código controla.

## Jev sem mito: state, perguntas tipadas, probabilidades

O modelo é direto. Você envia um state (o contexto: texto, identidades, políticas, fatos atuais, de preferência em campos JSON nomeados) e uma ou mais perguntas tipadas. Ele devolve respostas restritas ao que você definiu, com distribuição de probabilidade, e o código decide o que fazer. As perguntas independentes sobre o mesmo state rodam juntas, em paralelo, sem uma contaminar a outra.

São três primitivas. Choice escolhe uma opção de um conjunto definido e devolve a opção, a probabilidade de cada uma e a confiança. Score avalia o state contra níveis ordenados de uma rubrica e devolve posição ponderada por probabilidade mais confiança. Noul responde se uma afirmação é verdadeira com um número de 0 a 1, e não tem campo separado de confiança. Cada pergunta carrega instructions (o julgamento, com significado completo embutido) e criteria (as respostas possíveis, com contrastes e exclusões quando ajudam). Um detalhe que muita gente tropeça: Noul perto de 0.5 indica probabilidade parecida para sim e não, não intensidade média. E confiança baixa numa alternativa inofensiva não precisa invalidar nada; incerteza em ramo que o código nem usa deve ser ignorada.

O ponto arquitetural que separa System One de agente: o código é dono do fluxo, das regras determinísticas e dos efeitos colaterais. O modelo entra só onde precisa de bom senso programável sobre dado não estruturado. Regra, cálculo, lookup exato e execução ficam no código. Quando o julgamento é amplo demais, decomponha em perguntas atômicas e combine com sua fórmula, porque aí mudar prioridade vira trocar um coeficiente, não reescrever prompt.

Três limites que a própria documentação assume. Primeiro, o modelo hospedado é só texto: projeto de browser, áudio, imagem e robótica precisa extrair texto ou observações estruturadas antes, ou usar outro modelo para percepção. Segundo, saída válida no schema não é decisão correta: valide nos seus dados, calibre thresholds, mantenha ação de alto impacto atrás de checagem determinística e tenha fallback humano. Terceiro, existe página de jaggedness do jev-1.13 com arestas conhecidas em aritmética, datas, distratores e estado adversário. Trave a versão do modelo quando for comparar avaliações; os aliases jev-latest e jev-preview hoje apontam para jev-1.13.0, e alias móvel em benchmark é armadilha.

## O mapa do awesome-jev em 2026

A lista passou por revisão com fontes pinadas em 19 de setembro de 2026 e organiza o ecossistema em frentes bem delimitadas, com exigência de código público e loop de decisão concreto com o Jev. O retrato que ela dá:

Integração via providers: listagem no OpenRouter com alias móvel, endpoint no Vercel AI Gateway via API experimental de avaliação e integração mantida pela Cloudflare. SDKs oficiais em Python (a 0.7.0 trocou msgspec por Pydantic, breaking change documentado) e JavaScript/TypeScript, mais adaptador para comparar a interface System One com providers de LLM.

SDKs e ferramentas da comunidade cobrem Elixir/OTP, Haskell, Go, Java 17 com starter Spring, R, Ruby, Laravel, cliente async em Python, CLI para shell e pipelines Unix, plugin de Neovim que fatia o buffer com Treesitter e ranqueia funções por probabilidade no quickfix, ranqueador de histórico zsh, par local de validação Zod com validação semântica no Jev e vários servidores MCP que expõem classify, score e check como ferramentas.

Agents, coding e guardrails é a frente mais cheia: roteadores que escolhem modelo por turno, plugin que responde noul, choice e score em lote com contrato tipado de escalação devolvendo escrita ao LLM, hooks que desafiam alegação de done sem evidência no transcript, gate de tool call com allow, ask e deny, linter semântico contra preferências do projeto, revisor com dashboard, ranqueador de skills com abstenção e um gate experimental que decide se um timer merece acordar um agente adormecido. O aviso da seção procede: julgamento do modelo não estabelece segurança nem substitui checagem de permissão da aplicação.

Contexto e compactação: ferramentas que pontuam pares de tool-call e resultado para apagar ou truncar, preservando o texto mantido verbatim. Nada ali prova que o histórico omitido era desnecessário, e a lista diz isso com todas as letras.

Browser e computer use: o padrão é Jev escolhendo operação e alvo DOM válidos enquanto outro modelo escreve texto digitado e o código verifica o resultado. Tem experimento Android com modo que controla dispositivo real e demo que para antes de reservar de verdade. Demos publicadas têm critério de sucesso específico da tarefa e não estabelecem confiabilidade geral.

Roteamento, dados e workflows: extensão DuckDB que expõe julgamentos como valores SQL, extensões Postgres que perguntam sobre linhas depois do SQL rodar no servidor, cliente estilo psql, nó comunitário de n8n, reranker para RAG com threshold configurável, seletor de fontes de busca, workflow de intenção de e-mail em LangGraph, filtro e scorer de datasets Parquet e JSONL, triagem de logs OpenTelemetry antes de análise cara e dois experimentos de trading que por padrão simulam sem chave, com execução real possível quando configurada. Classificador de páginas de PDF para formulários fiscais com gate de confiança, com a ressalva correta de que página escaneada precisa de OCR e triagem não é aconselhamento.

Jogos, robótica e demos interativas: o padrão saudável aparece aqui, código determinístico dono do mundo e Jev decidindo só nos branches. Pokemon Red no PyBoy com previsão de faint pontuada por Brier contra a RAM do emulador, Tetris que enumera placements alcançáveis e descreve cada um em inglês para o modelo pontuar (com controle honesto onde um baseline de regex de 23 linhas supera o modelo), direção simulada com dinâmica local, Snake, Mario, StarCraft com probabilidades gravadas e avaliador de ideia de startup em kill, fix ou ship.

Mídia e criatividade: extensão que pinta probabilidade de sponsor por segmento na seekbar a partir da legenda, detector de sponsor com timestamps no código, estúdio de música simbólica onde o modelo escolhe planos e o código renderiza MIDI editável, controlador de slides por transcript com navegação manual e moderador de rascunho para X com descrição de mídia vinda de outro modelo de visão.

Reproduções abertas e avaliação: implementações independentes que imitam a interface (algumas transformando logits de modelos abertos em decisões tipadas, sem cabeça classificadora treinada separada) convivem com estudos de calibração, ajuste de threshold contra dado rotulado, comparação contra Claude, Qwen e GPT em tarefas de decisão de tool use e um bench de ORDER BY sobre probabilidade que passa em tópicos de newsgroup e falha em relevância de produto. Inclusão ali quer dizer evidência inspecionável, não benchmark reexecutado de forma independente.

Faltava dizer o óbvio sobre como ler essa lista procurando espaço em branco: quase tudo classifica, ranqueia ou verifica texto curto. Quase nada opera onde código controla dinheiro, segurança ou DDL, com o Jev só julgando e o código executando. É nesse vão que estão as ideias abaixo.

## Sete projetos que ainda não vi na lista

Cada ideia segue o mesmo molde: state nomeado, perguntas estreitas, composição no código, escalação por confiança. Nenhuma entrega escrita, ordem de compra ou DDL ao modelo.

1. Triagem de exceções do Solid Queue com quarentena. State com classe da exceção, mensagem, backtrace resumido, job e tentativas. Uma Choice escolhe a fila de destino entre retry imediato, backoff longo e quarentena; dois Nouls respondem se o padrão parece flaky conhecido e se há sinal de dado envenenado; um Score dá severidade. O código move para quarentena quando o Noul de dado suspeito passa do threshold ou a confiança da Choice cai, e só aí chama humano. Na lista há triagem de log genérica, não há roteador de job com quarentena para Rails.

2. Roteador de reviewer com gate de changelog. State com diff, mensagem de commit e histórico de ownership. Uma Choice escolhe time ou trilha de revisão; um Noul julga se o changelog cobre o diff; outro Noul acusa segredo ou debug esquecido. O código bloqueia merge só no segredo detectado e marca revisão humana quando a cobertura do changelog é incerta. Existe hook de commit que julga mensagem contra diff, não existe o par reviewer mais changelog com bloqueio seletivo.

3. Scrubber de PII em log de Rails antes de reter. Um Noul por classe (CPF, e-mail, token, chave) sobre cada linha ou campo estruturado; o código mascara e registra o que mascarou com probabilidade, para auditoria. Existe classificador de formulário fiscal americano, não existe mascarador de log com trilha de auditoria para LGPD.

4. Triagem de query lenta via pg_stat_statements. State com query normalizada, plano EXPLAIN, espera dominante e tamanho das tabelas. Uma Choice aponta a causa provável entre índice ausente, estatística desatualizada, lock e escrita amplificada; um Score dá risco de aplicar a correção em produção. O código sugere, nunca aplica DDL sozinho; humano aprova. As extensões Postgres da lista julgam linhas, nenhuma diagnostica causa de lentidão com gate de risco.

5. Classificador de teste flaky no CI. State com nome do teste, log de falha, arquivos tocados e histórico de vereditos. Uma Choice classifica entre flaky de ordem, de tempo, de infra e falha real; um Noul diz se vale retry isolado; abaixo de confiança mínima o código marca quarentena e abre issue com evidência em vez de repetir a suite inteira. Há classificador de diff e decisões para pipelines Unix, não há esse loop de quarentena de flaky com evidência anexada.

6. Fusão de anúncios duplicados em marketplace. O cookbook de alinhamento de entidades mostra o molde: um Score com três níveis que correspondem às três ações possíveis, fundir, deixar desligado ou mandar para curador. Aplicado a catálogo inconsistente de sellers, com state trazendo título, atributos e fotos descritas, o código funde só acima de threshold alto e curadoria pega o resto. O cookbook existe, o produto aplicado a marketplace não está na lista.

7. Gate de qualidade de alt text para acessibilidade. Um Noul julga se a imagem é decorativa; um Score avalia o alt contra rubrica de especificidade, contexto e ausência de redundância com a legenda. O código barra deploy de página com alt ruim em conteúdo informativo e libera decorativa sem alt. Não há projeto de acessibilidade na lista.

Dois esboços para tirar isso do papel. Em Python, com o SDK oficial:

```python
from typesafe import TypeSafeClient, Choice, Noul, Score

state = {
    "job": {"queue": "default", "attempts": 3, "error": "PG::UniqueViolation"},
    "trace_hint": "duplicated key on notifications(user_id, day)",
}

questions = {
    "route": Choice(
        instructions={"question": "Which queue should receive this failed job?"},
        criteria={
            "retry_now": {"what": "Transient failure, safe to retry"},
            "backoff": {"what": "Likely contention, retry with delay"},
            "quarantine": {"what": "Poison data or unknown pattern, hold for review"},
        },
    ),
    "poisoned": Noul(
        instructions={"question": "Does the failure indicate poison input data?", "inspect": "`job.error`"},
        criteria={"true": {"what": "Duplicate key or constraint pointing at input"}, "false": {"what": "Infra or transient error"}},
    ),
    "severity": Score(
        instructions={"question": "How severe is this failure for the queue?"},
        criteria=[{"what": "Noise, retries clear it"}, {"what": "Needs attention today"}, {"what": "Blocks processing, page someone"}],
    ),
}

with TypeSafeClient() as client:
    answers = client.system_one(state=state, questions=questions).answers

if answers["poisoned"].noul >= 0.7 or answers["route"].confidence < 0.75:
    quarantine(state)
elif answers["route"].choice == "backoff":
    requeue(state, delay=300)
else:
    requeue(state, delay=0)
```

Em Rails, com job no Solid Queue e o cliente comunitário de Ruby, versão simplificada:

```ruby
class TriageFailedJob < ApplicationJob
  queue_as :triage

  def perform(failure_id)
    failure = JobFailure.find(failure_id)
    verdict = JevRouter.route(failure.to_state)

    if verdict.uncertain? || verdict.poisoned?
      failure.quarantine!(confidence: verdict.confidence)
    else
      failure.requeue!(queue: verdict.queue)
    end
  end
end
```

O detalhe que importa nos dois: threshold avaliado nos próprios dados, ramo não usado com incerteza ignorada e nenhuma ação irreversível sem checagem determinística ou humano no caminho.

## Onde a teoria esbarra na produção

Trocar parse de JSON gerado por decisão tipada elimina uma classe inteira de bug, mas a calibração continua sendo trabalho seu. Threshold alto demais no Noul gera fila manual infinita; baixo demais e a Choice finge certeza sobre o que desconhece. Hardware também conta: daemon local em VPS exige atenção a memória e contenção, e para carga rotineira uma query bem desenhada ou regra pura continua mais rápida e barata. A fronteira onde o Jev paga a conta é ambiguidade linguística na entrada combinada com exigência de saída previsível. Fora dela, o modelo mais econômico segue sendo o que não precisa rodar.

## Fontes

- [https://github.com/cobanov/awesome-jev](https://github.com/cobanov/awesome-jev)
- [https://docs.typesafe.ai/introduction](https://docs.typesafe.ai/introduction)
- [https://docs.typesafe.ai/concepts/use-case-map](https://docs.typesafe.ai/concepts/use-case-map)