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:
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.
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) |
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
"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.
"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.
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.
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 });
}
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).
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!
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:
Automação Direta
O sistema atualiza o banco de dados, emite o alerta ou move o card no Kanban instantaneamente.
Revisão Humana
O sistema sinaliza um badge amarelo no dashboard e solicita confirmação com 1 clique de um operador.
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.
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 + SupabaseNo 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 150msNos 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ã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())
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:
Veredito do Seu Código Backend:
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.
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
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.