CODE / Jev · TypeSafe AI
01 Origem & Filosofia 02 As 3 Primitivas (Choice, Score, Noul) 03 Padrões de Arquitetura 04 Casos Reais (ALURYA & pmodash) 05 Código & SDKs (TypeScript / Python) 06 Cockpit Interativo / Playground 07 Calculadora de Latência & Custo 08 Quiz de Fixação ← Voltar ao Hub CODE
Masterclass de Arquitetura de IA TypeSafe AI · Jev v1.13

Jev & A Decisão em 100ms:
IA Sem Alucinação no Seu Código

Por que os LLMs convencionais falham em pipelines autônomos de software — e como substituir prompts lentos, caros e imprevisíveis por julgamento não-autoregressivo, probabilidades calibradas e tipagem estrita para o seu backend.

Latência Típica

~100ms

vs 3.500ms de LLMs comuns

Taxa de Erro de Tipo

0,0%

Garantia estrutural do modelo

Speculative Fan-out

30 Perguntas

Em paralelo no mesmo request

Redução de Custo

>90%

Zero tokens gastos gerando prosa

Módulo 01 Fundamentos Teóricos

A Virada do Sistema 1: Por Que LLMs Convencionais Falham em Pipelines de Software

TESE CENTRAL

O Jev não é um gerador de texto. Ele é um oráculo de juízo determinístico. Claude, ChatGPT e Gemini foram arquitetados para conversar com humanos (Sistema 2). Usá-los como engrenagem dentro de código produz latência insustentável, alucinações e parsing frágil de JSON. O Jev resolve o outro lado da moeda: a cognição intuitiva, ultrarrápida e calibrada (Sistema 1).

1. A Metáfora de Daniel Kahneman no Código

No clássico livro Rápido e Devagar: Duas Formas de Pensar, o Prêmio Nobel Daniel Kahneman mapeou os dois modos cognitivos da mente humana:

Sistema 2 (Reflexivo / Lento) GPT-4 · Claude · Gemini

Pensamento deliberado, analítico e discursivo

É o humano escrevendo uma dissertação ou deduzindo uma fórmula matemática. No mundo dos modelos: são os LLMs autoregressivos gerando palavras token por token. Levam de 2 a 8 segundos, custam caro e tendem a "viajar" ou alucinar explicações quando você só precisa de um veredito.

Sistema 1 (Intuitivo / Rápido) Jev (TypeSafe AI)

O relance imediato do especialista experiente

É o médico experiente que bate o olho no raio-X e diz "há consolidação aqui" em 200ms. Ou o analista que lê uma frase do WhatsApp e sabe: "esse lead quer alugar para quinta-feira". Não gera conversa: avalia probabilidades e entrega certeza matemática tipada.

2. A Origem: Por que Diogo Almeida Saiu da OpenAI

Diogo Almeida, fundador da TypeSafe AI, foi pesquisador na OpenAI e trabalhou no centro da criação de marcos como InstructGPT, RLHF (Reinforcement Learning from Human Feedback) e no próprio ChatGPT.

Ao longo desses anos, Diogo identificou um desalinhamento estrutural:

"Todos os grandes modelos de fronteira estão sendo otimizados para agradar o humano na ponta da conversa. Eles são prolixos, amigáveis, conversacionais. Mas quando um engenheiro de software coloca essa IA dentro de um backend ou de um CRM, ele não quer conversa: ele quer que a máquina decida se o pedido é válido, qual rota chamar e se os dados cumprem o contrato. Forçar um modelo de chat a cuspir JSON é tentar usar uma Ferrari para arar a terra."

— Diogo Almeida, Founder & CEO da TypeSafe AI

3. Matriz Comparativa: Jev vs LLM Autoregressivo

Dimensão LLM de Chat (Claude / GPT) Jev (TypeSafe AI)
Arquitetura Autoregressivo (gera token por token) Não-autoregressivo (julgamento paralelo)
Latência Média 2.000ms a 6.000ms 70ms a 180ms
Saída de Dados String de texto (exige `JSON.parse` arriscado) Tipagem forte garantida (`Choice`, `Score`, `Noul`)
Taxa de Quebra de Schema ~2% a 5% (vírgulas, chaves ou texto extra) 0% (espaço de resposta delimitado)
Múltiplas Perguntas Lentidão cumulativa e degradação de atenção Fan-out: até 30 perguntas no mesmo tempo (~100ms)
Certeza Operacional Logprob isolada (não calibrada para ação) Confiança epistêmica calibrada (0.0 a 1.0)
Módulo 02 Os Blocos Construtores

Os 3 Tijolos Primitivos: O Estado, Choice, Score e Noul

TESE CENTRAL

Você não precisa escrever prompts longos com *"Você é um assistente prestativo, responda em formato JSON"*. No Jev, o contrato é matemático: você passa um Estado (`State`) e um mapa de Perguntas Tipadas (`Questions`) formadas por três primitivas imutáveis: `Choice`, `Score` e `Noul`.

1. O Conceito de Estado (`State`)

O Estado é todo o contexto não-estruturado que você quer que o modelo observe. Pode ser uma string simples, um documento Markdown, o histórico de uma conversa de WhatsApp ou um objeto JSON aninhado:

// O State pode ser qualquer dado do seu sistema:
const state = {
  usuario: "Dra. Camila - Clínica Estética Spazio",
  historico_whatsapp: [
    "Olá! Vi o anúncio da locação do laser Lavieen.",
    "Vocês têm data disponível para a próxima quinta-feira em Ribeirão Preto?",
    "Qual o valor da diária de 12 horas?"
  ],
  etapa_atual_crm: "novo_lead"
};

2. Primitiva 1: `Choice` (Escolha Categórica)

Usa-se quando você precisa que a IA selecione uma opção entre várias categorias predefinidas. O diferencial do Jev é que cada opção recebe uma descrição semântica clara e o retorno traz a distribuição completa de probabilidades e a confiança na escolha.

import { choice } from "typesafe-ai";

const perguntaEtapa = choice({
  instructions: "Com base no `historico_whatsapp`, em qual coluna do Kanban o lead deve estar?",
  criteria: {
    novo_lead: "Apenas deu saudação ou perguntou se a empresa existe",
    qualificado: "Informou que é profissional habilitado ou dona de clínica",
    proposta_enviada: "Pediu orçamento, tabela de valores ou datas específicas",
    data_reservada: "Confirmou que deseja fechar a locação na data tal",
    descarte: "Engano, spam ou fora da área de atuação"
  }
});

// Resposta do Jev:
// {
//   choice: "proposta_enviada",
//   probabilities: { proposta_enviada: 0.91, qualificado: 0.08, novo_lead: 0.01 ... },
//   confidence: 0.94
// }

3. Primitiva 2: `Score` (Régua Contínua de Níveis)

Usa-se para avaliar intensidade, gravidade ou urgência em uma régua ordenada de critérios. O retorno não é apenas um número inteiro: o Jev interpola uma nota contínua (`float`) com base na massa de probabilidade distribuída entre os níveis!

import { score } from "typesafe-ai";

const termometroUrgencia = score({
  instructions: "Qual o nível de urgência temporal do cliente para a locação?",
  criteria: [
    "Nível 0: Curiosidade futura, sem horizonte de data definido",
    "Nível 1: Pretende alugar no próximo mês",
    "Nível 2: Precisa alugar nas próximas duas semanas",
    "Nível 3: Necessidade imediata (nesta semana ou dias específicos próximos)"
  ]
});

// Resposta do Jev:
// {
//   score: 2.85,  <-- O Jev percebeu que é para a próxima quinta-feira!
//   probabilities: [0.01, 0.02, 0.12, 0.85],
//   confidence: 0.96
// }

4. Primitiva 3: `Noul` (Booleano Probabilístico)

O Noul é o julgamento de afirmações do tipo Sim/Não. Ele retorna a probabilidade matemática precisa (de 0.0 a 1.0) da afirmação ser verdadeira, acompanhada do índice de confiança.

import { noul } from "typesafe-ai";

const temObjecaoPreco = noul({
  instructions: "O lead demonstrou insatisfação com os valores ou pediu desconto?"
});

// Resposta do Jev:
// {
//   noul: 0.04,  <-- 96% de certeza de que NÃO houve objeção de preço
//   confidence: 0.92
// }

5. A Diferença Crucial: Probabilidade vs Confiança

Probabilidade (O Quê)

"Qual a chance deste fato ser verdade?"

Se você joga uma moeda perfeita, a probabilidade de dar Cara é 0.50 (50%). Não há dúvida de que o valor é 0.50. É uma estimativa do estado das coisas.

Confiança (A Certeza de Agir)

"O modelo tem dados suficientes para ter certeza?"

Se a mensagem do WhatsApp diz apenas "Ok, combinado", a probabilidade de fechar pode parecer 0.70, mas a confiança é baixa (0.35) porque falta contexto! Se a confiança for baixa, seu código não arrisca tomar uma ação destrutiva.

Módulo 03 Engenharia de Sistemas

Os 4 Grandes Padrões de Arquitetura em Produção

TESE CENTRAL

Não construa agentes soltos que decidem os próprios passos em loops infinitos de tokens. Use os padrões comprovados do Sistema 1: Code in Control, Speculative Fan-out, Composite Scoring e Confidence-Gated Routing.

01

Code in Control (O Código Manda, a IA Opina)

Em arquiteturas frágeis, o LLM recebe a chave do banco e decide sozinho o que fazer ("Tool Calling Autônomo"). Quando o modelo tem uma alucinação sutil, dados são apagados ou compras erradas são disparadas.

Com o Jev, o fluxo do software é 100% determinístico. Seu código tradicional em TypeScript, Python ou Go mantém a máquina de estados, transações de banco de dados e validações. O Jev entra estritamente no momento do julgamento de dados desestruturados:

// SEU CÓDIGO CONTROLA O DESTINO:
if (res.answers.proxima_etapa.choice === "data_reservada" && res.answers.proxima_etapa.confidence >= 0.85) {
  await crm.moverCard({ leadId, paraColuna: "fechamento" });
  await notificacoes.alertarCloser({ leadId, motivo: "Cliente pronto para contrato" });
} else {
  await crm.manterColunaComAlertaRevisao({ leadId });
}
02

Speculative Fan-out (Disparo Paralelo Massivo)

Em um LLM tradicional, se você fizer 20 perguntas sobre um documento, a latência escala para 15 segundos e o modelo sofre de context rot (esquece o começo do texto ou mistura as respostas).

Como o Jev é uma rede discriminativa não-autoregressiva, ele avalia 10, 20 ou até 30 perguntas ao mesmo tempo sobre o mesmo State. O custo de tempo é praticamente o mesmo (~100ms a 150ms).

Você pode fazer perguntas especulativas (perguntas que talvez nem use agora, mas que já vêm calculadas caso seu código tome uma bifurcação posterior).

03

Composite Scoring (Julgamento Atômico + Matemática)

Nunca pergunte para uma IA: "Esse cliente é de alto risco?". Essa pergunta é vaga e o modelo inventará pesos arbitrários.

A engenharia do Sistema 1 manda quebrar o problema em perguntas atômicas e combinar os resultados com pesos no seu próprio código:

// 3 Perguntas Atômicas avaliadas em paralelo pelo Jev:
const p1 = answers.tem_atraso_cronograma.noul;    // 0.0 a 1.0
const p2 = answers.tem_risco_glosa.noul;           // 0.0 a 1.0
const p3 = answers.severidade_impacto.score;       // 0.0 a 3.0

// A FÓRMULA MATEMÁTICA VIVE NO SEU BACKEND (Auditável & Sem Alucinações):
const riscoFinal = (0.4 * p1) + (0.4 * p2) + (0.2 * (p3 / 3));

// Se a política da diretoria mudar amanhã, você só altera os números acima!
04

Confidence-Gated Routing (Roteamento Tripartite por Certeza)

A resposta do modelo diz O QUE ele encontrou. A confiança calibrada diz SE VOCÊ DEVE EXECUTAR sem supervisão:

Confiança > 0.85

Automação Direta

O sistema atualiza o banco de dados, emite o alerta ou move o card no Kanban instantaneamente.

0.50 ≤ Confiança < 0.85

Revisão Humana

O sistema sinaliza um badge amarelo no dashboard e solicita confirmação com 1 clique de um operador.

Confiança < 0.50

Fallback Crítico

O dado está ambíguo demais. Nenhuma ação automática ocorre; escala-se para o humano ou para um modelo pesado.

Módulo 04 Projetos CODE em Produção

Casos Reais Aplicados: Do WhatsApp Autônomo à Auditoria PMO

TESE CENTRAL

Como a inteligência Sistema 1 resolve problemas práticos nos projetos que construímos aqui no CODE: o CRM autônomo da ALURYA (Omega Laser) onde cards se movem sozinhos, e o pmodash para auditoria instantânea de contratos de concessão pública de saneamento.

Cenário A · ALURYA (Omega Laser CRM)

Edge Functions + Supabase

No manifesto da ALURYA, a diretriz é categórica: "Card que precisa ser arrastado manualmente é bug de conceito." Quando um lead envia mensagem no WhatsApp, o webhook do Supabase aciona o Jev em 90ms para decidir a coluna sem intervenção humana:

import { TypeSafeClient, choice, score, noul } from "typesafe-ai";

export async function handleWhatsAppWebhook(lead, historicoRecente) {
  const client = new TypeSafeClient();

  const { answers } = await client.systemOne({
    state: {
      lead_nome: lead.nome,
      coluna_atual: lead.status_kanban,
      historico: historicoRecente
    },
    questions: {
      proxima_etapa: choice({
        instructions: "Qual deve ser o status deste lead de locação de laser no CRM?",
        criteria: {
          novo_lead: "Primeiro contato ou dúvida genérica",
          qualificado: "É médica/biomédica com clínica própria",
          proposta_enviada: "Pediu valores, catálogo ou disponibilidade de datas",
          data_fechada: "Confirmou interesse firme em reservar data de locação",
          perdido: "Desistiu ou não atende os requisitos"
        }
      }),
      urgencia: score({
        instructions: "Quão próxima é a data que o lead quer reservar?",
        criteria: [
          "Sem data prevista",
          "No próximo mês",
          "Nas próximas duas semanas",
          "Nesta semana ou data já declarada"
        ]
      }),
      pediu_desconto: noul({
        instructions: "O lead fez contraproposta de preço ou reclamou do valor?"
      })
    }
  });

  // AÇÃO AUTÔNOMA SEGURA:
  if (answers.proxima_etapa.confidence >= 0.85) {
    await supabase.from("leads").update({
      status_kanban: answers.proxima_etapa.choice,
      score_urgencia: answers.urgencia.score,
      alerta_objecao: answers.pediu_desconto.noul > 0.7
    }).eq("id", lead.id);
  } else {
    await supabase.from("leads").update({
      tag_atencao_humana: true
    }).eq("id", lead.id);
  }
}

Cenário B · pmodash (Auditoria PMO de Concessões)

Auditoria de 28 Obrigações em 150ms

Nos contratos de concessão de saneamento (Araxá, Balneário Camboriú, Curitiba), ofícios de 100 páginas chegam da agência reguladora ou da concessionária. O Jev executa um Speculative Fan-out de 28 perguntas de uma só vez:

const auditoria = await client.systemOne({
  state: { texto_oficio: textoExtraidoDoPDF },
  questions: {
    tem_balanco_contabil: noul({ instructions: "Contém o balanço patrimonial auditado 2021-2025?" }),
    tem_cadastro_redes: noul({ instructions: "Apresenta coordenadas e diâmetros das redes de água?" }),
    tem_decreto_tarifario: noul({ instructions: "Contém homologação oficial da agência reguladora?" }),
    // ... até 28 verificações contratuais em paralelo!
    risco_prazo: score({
      instructions: "Qual o impacto do ofício no cronograma das obras?",
      criteria: ["Nenhum", "Atraso leve (<15 dias)", "Atraso crítico", "Paralisação"]
    })
  }
});

// Atualiza o painel do pmodash instantaneamente:
dashboard.atualizarChecklist({
  balanco: auditoria.answers.tem_balanco_contabil.noul > 0.8 ? "Entregue" : "Pendente",
  redes: auditoria.answers.tem_cadastro_redes.noul > 0.8 ? "Entregue" : "Pendente",
  alerta_vermelho: auditoria.answers.risco_prazo.score >= 2.0
});
Módulo 05 Guia de Implementação

Mão na Massa: SDKs em TypeScript e Python

TESE CENTRAL

A TypeSafe AI disponibiliza SDKs oficiais para TypeScript (`typesafe-ai`) e Python (`typesafe`). Ambos garantem inferência tipada estática, política de retry exponencial configurável e tipagem com auto-complete na sua IDE.

Instalação via NPM / PNPM / Yarn:

npm install typesafe-ai
import { TypeSafeClient, choice, score, noul } from "typesafe-ai";

// O cliente lê automaticamente TYPESAFE_API_KEY do process.env
const client = new TypeSafeClient({
  maxRetries: 3,
  timeoutMs: 5000
});

async function executarClassificacao() {
  try {
    const response = await client.systemOne({
      state: {
        transacao_valor: 4850.00,
        origem_ip: "187.54.21.90",
        horario: "03:42 AM",
        dispositivo_novo: true
      },
      questions: {
        risco_fraude: score({
          instructions: "Qual o grau de suspeição desta transação?",
          criteria: [
            "Normal: compatível com padrão",
            "Atenção leve: horário incomum mas valor típico",
            "Alto risco: anomalia de horário e valor",
            "Crítico: provável fraude em andamento"
          ]
        }),
        bloquear_cartao: noul({
          instructions: "A transação deve ser travada preventivamente?"
        })
      }
    });

    console.log("Nota contínua de risco:", response.answers.risco_fraude.score);
    console.log("Confiança do veredito:", response.answers.risco_fraude.confidence);

  } catch (err) {
    console.error("Falha na avaliação:", err);
  }
}

Instalação via pip:

pip install typesafe
import asyncio
from typesafe import AsyncTypeSafeClient, Choice, Score, Noul

async def main():
    client = AsyncTypeSafeClient()

    state = {
        "feedback": "O atendimento foi excelente, mas a entrega demorou 15 dias a mais do que o prometido."
    }

    result = await client.system_one(
        state=state,
        questions={
            "sentimento": Choice(
                instructions="Qual o sentimento geral do cliente?",
                criteria={
                    "positivo": "Elogio claro e satisfação plena",
                    "misto": "Elogiou um aspecto mas criticou outro",
                    "negativo": "Insatisfação predominante"
                }
            ),
            "abrir_chamado_logistica": Noul(
                instructions="O cliente relatou atraso de entrega?"
            )
        }
    )

    print(f"Sentimento: {result.answers.sentimento.choice} (conf: {result.answers.sentimento.confidence})")
    print(f"Probabilidade atraso: {result.answers.abrir_chamado_logistica.noul}")

asyncio.run(main())
Módulo 06 · Cockpit Laboratório Interativo

Playground Interativo: Experimente o Sistema 1 ao Vivo

Selecione um cenário real pré-configurado ou edite o Estado livremente. Clique em Avaliar com Jev para observar as 3 primitivas sendo computadas em paralelo, o cálculo de probabilidades e a reação do código determinístico.

Perguntas Atômicas Disparadas:

1. Choice:

2. Score:

3. Noul:

Resposta do Jev
0 Erros de Schema
1. Choice ():
Probabilidade: Confiança:
2. Score ():
Classificação contínua Confiança:
3. Noul ():
Probabilidade afirmativa Confiança:

Veredito do Seu Código Backend:

Módulo 07 · Métricas Business Case & ROI

Calculadora de Custo, Latência e Segurança Operacional

Veja quanto a sua infraestrutura economiza trocando chamadas de LLM genérico (Claude Sonnet / GPT-4o) para decisões tipadas em Jev.

Volume de Decisões por Dia:
500 25.000 50.000 100.000
Tamanho Médio do Contexto (`State`):
300 (WhatsApp) 2.500 (E-mail/Ticket) 8.000 (Ofício/Contrato)

Premissas de Benchmark:

  • LLM Chat (GPT-4o/Claude): 3.200ms de latência média, US$ 2.50/M input, US$ 10.00/M output.
  • Jev (TypeSafe AI): 95ms de latência média, tarifa de fração de centavo machine-native.
  • Taxa de erro JSON LLM: 2.3% (necessidade de retry). Jev: 0%.

Tempo Economizado / Mês

Menos tempo de usuário esperando loading de chatbot

Economia Financeira / Mês

Economia direta de fatura de API de tokens

Erros de JSON Evitados

Falhas em produção eliminadas pela tipagem nativa

Ganho de Throughput

33x

Mais decisões processadas por segundo

Módulo 08 · Certificação Quiz Prático

Teste Seus Conhecimentos: Você Dominou o Sistema 1?

Quatro perguntas de arquitetura do mundo real. Teste suas decisões técnicas e veja o feedback imediato.