Drex 1.5: Agente decide 10x rápido (sem alucinar)

Drex 1.5: Agente decide 10x rápido (sem alucinar)

Notícia: Nace AI lançou Drex 1.5: modelo de 9B parâmetros que NÃO gera texto. Em vez disso, lê o contexto e retorna probabilidade pra cada opção. Resultado: Agente toma decisão em ~100ms (vs 2-5 segundos pra gerar texto).

Implicação: Se seu agente hoje usa GPT/Claude pra escolher entre opções, Drex muda o paradigma: decision model é 10x mais rápido + zero alucinação + open-source (você roda localmente).

**"Você é CTO de SaaS com agente de vendas em produção.

Cenário antigo (text generation model): ├─ Lead entra no chat do WhatsApp ├─ Lead: "Qual plano é melhor pra mim?" ├─ Agente envia pro GPT-4: │ ├─ "Analyze lead.profile" │ ├─ "Consider lead.budget" │ ├─ "Recommend best plan (Starter/Pro/Enterprise)" │ └─ "Explain reasoning in 2-3 sentences" ├─ GPT-4: Pensa... pensa... pensa... (~3-5 seg) ├─ GPT-4 responde: "Based on your profile, Pro plan is ideal because..." ├─ Lead tá esperando (bad UX) ├─ Lead: "Que app lento" → sai do chat └─ Resultado: Lead perdido

Cenário novo (decision model Drex): ├─ Lead entra no chat ├─ Lead: "Qual plano é melhor?" ├─ Agente envia pro Drex: │ ├─ state: {profile, budget, usage} │ ├─ options: ["Starter", "Pro", "Enterprise"] │ └─ question: "Best plan?" ├─ Drex: Calcula (~100ms) ├─ Drex responde: {Starter: 0.05, Pro: 0.85, Enterprise: 0.10} ├─ Agente: "Pro é melhor (85% confiança)" ├─ Lead tá feliz (resposta rápida) └─ Resultado: Lead converte

Diferença: └─ Antes: 3-5s (lead sai) └─ Depois: 100-200ms (lead fica) └─ Impacto: Conversão +30-40% "**

---

Por que decision model muda tudo

Text generation é lento (e caro)

Fluxo tradicional (LLM text generation): ├─ Input: "Qual plano escolher?" ├─ LLM precisa gerar cada token: │ ├─ Token 1: "Based" │ ├─ Token 2: "on" │ ├─ Token 3: "your" │ ├─ ... │ └─ Token 50: "Enterprise" (fim) ├─ Latência: 50 tokens × 20ms/token = 1.000ms ├─ Custo: 50 tokens input + 50 tokens output = R$ 0.01 └─ Problema: 1 segundo é MUITO pra decisão binária

Por que tão lento? ├─ LLM gera 1 token por vez ├─ Cada token = pass na rede neural (forward + backward) ├─ 50 tokens = 50 passes = 1 segundo ├─ Parallelização limitada (tokens dependem uns dos outros) └─ Solução: NÃO gerar tokens! Só retornar probabilidade

Comparação: ├─ Text model: 1.000ms (1 segundo) ├─ Decision model: 100ms (100x rápido) ├─ Latência LLM (batch): 5.000ms (batch size 100) └─ Decision model (batch): 100ms (mesmo!)

Decision model é diferente de "classification"

❌ O que NÃO é Drex: ├─ Classificação tradicional │ ├─ Input: "This customer is..." │ ├─ Output: "[CHURN, RETAIN, UPSELL]" │ ├─ Single choice (one hot) │ └─ Determinístico │ ├─ LLM em chain-of-thought │ ├─ Input: "Which option is best?" │ ├─ Output: "Let me think... option A because... option B because..." │ ├─ Reasoning explicado │ └─ Lento (text generation)

✅ O que É Drex (decision model): ├─ Probabilidade pra cada opção │ ├─ Input: {state, options, question} │ ├─ Output: {optionA: 0.73, optionB: 0.20, optionC: 0.07} │ ├─ Calibrated (somam 100%) │ └─ Confiança built-in │ ├─ Rápido (não gera texto) │ ├─ Latência: ~100ms │ ├─ Pode rodar localmente (9B = cabe em 1 GPU) │ └─ Batch processing eficiente │ ├─ Usa context pra decidir │ ├─ Input: Full state (não só classe) │ ├─ Exemplo: {customer_lifetime_value, churn_score, nps, ...} │ ├─ Modelo lê TUDO antes de decidir │ └─ Muito mais smart que classification

Exemplo real: ├─ Input state: │ ├─ customer: {age, industry, company_size, MRR} │ ├─ behavior: {login_freq, feature_usage, support_tickets} │ ├─ sentiment: {last_nps, last_comment} │ └─ options: ["Starter", "Pro", "Enterprise"] │ ├─ Drex lê estado completo ├─ Drex retorna: │ ├─ Starter: 0.05 (não recomendado, pouca chance) │ ├─ Pro: 0.73 (melhor, 73% de confiança) │ └─ Enterprise: 0.22 (possível, 22% de confiança) │ └─ Agente: "Pro é a melhor opção pra você (73% confiança)"

---

Por que Drex é melhor que LLM pra decisões

Velocidade: 10x mais rápido

Benchmark latência (ms):

Tarefa: "Qual plano do SaaS escolher?"

GPT-4o: ~3.500ms (gera ~100 tokens) Claude 3.5: ~2.500ms (mais rápido, mas ainda texto) Drex 1.5: ~100ms (rápido demais) Localhost Drex: ~50ms (rodar local, sem rede)

Implicação pra UX: ├─ GPT: 3.5s (lead tá irritado) ├─ Claude: 2.5s (melhor, mas ainda percebe latência) ├─ Drex: 100ms (instant, imperceptível) └─ Localhost: 50ms (super snappy)

Custo ($): ├─ GPT-4o: $0.01 por call ├─ Claude: $0.007 por call ├─ Drex (hosted): ~$0.0001 por call (100x mais barato) ├─ Drex (local): $0 (roda na sua infra) └─ Economia: Se 1M calls/mês → $10K/mês vs $100 com Drex

Scaling: ├─ LLM API: Limitado (rate limit, overload) ├─ Drex local: Unlimited (sua GPU decide) └─ Estratégia: LLM pra reasoning, Drex pra decisão

Zero alucinação (outputs calibrados)

Problema com LLM: ├─ GPT às vezes "inventa" opções inexistentes ├─ Exemplo: │ ├─ Options: [A, B, C] │ ├─ GPT: "I recommend option D" │ ├─ Problema: Option D não existe! │ └─ Você precisa de try/catch │ ├─ Solução hoje: Prompt engineering │ ├─ "You MUST choose from [A, B, C]" │ ├─ "Do NOT invent new options" │ ├─ "Never suggest outside the list" │ └─ Ainda assim, GPT às vezes erra

Drex é fundamentalmente diferente: ├─ Retorna EXATAMENTE o que você pediu ├─ Input: options: ["Starter", "Pro", "Enterprise"] ├─ Output: {Starter: 0.XX, Pro: 0.XX, Enterprise: 0.XX} ├─ NUNCA inventa quinta opção ├─ NUNCA retorna invalid JSON ├─ Output é sempre determinístico └─ Zero surpresas, zero try/catch

Calibração: ├─ Probabilidades somam exatamente 1.0 ├─ Não há valores como 1.5 ou -0.3 ├─ LLMs raramente garantem isso ├─ Drex: Garantido por design └─ Você pode confiar nas probabilidades

Custo: 100x mais barato

Math pra SaaS típico:

Cenário: 100K customers × 10 decisions/mês = 1M decisions/mês

GPT-4o path: ├─ Input: ~50 tokens ├─ Output: ~100 tokens ├─ Cost: $0.003 input + $0.012 output = $0.015/call ├─ Monthly: 1M × $0.015 = $15.000/mês └─ Yearly: $180.000/ano

Drex hosted (via OpenRouter): ├─ Cost: ~$0.0001/call (estimated) ├─ Monthly: 1M × $0.0001 = $100/mês └─ Yearly: $1.200/ano

Drex local (você roda): ├─ GPU cost: ~$500/mês (RTX 4090) ├─ Compute: ~$100/mês (electricity) ├─ Monthly: $600/mês ├─ Capacity: 10M+ decisions (overkill) └─ Per-decision cost: ~$0 (amortizado)

ROI: ├─ GPT today: $180K/ano ├─ Drex hosted: $1.2K/ano → Save $178.8K ├─ Drex local: $6K/ano (GPU) → Save $174K ├─ Payback: Instantly (mes 1) └─ 3-year ROI: $500K+ savings

---

Como usar Drex 1.5 no seu agente

Opção 1: OpenRouter (hosted, easiest)

bash

Signup: https://openrouter.ai/

Find: Drex 1.5 in model list

Get API key

Code example (Node.js)

const fetch = require('node-fetch');

const decideWithDrex = async (state, options, question) => { const response = await fetch('https://openrouter.ai/api/v1/decision', { method: 'POST', headers: { 'Authorization': Bearer ${OPENROUTER_API_KEY}, 'Content-Type': 'application/json', }, body: JSON.stringify({ model: 'nace/drex-1.5', state: state, // Your context options: options, // ["A", "B", "C"] question: question, // "Which option?" }), });

const result = await response.json(); // result = {A: 0.73, B: 0.20, C: 0.07} return result; };

// Usage in your agent const customerState = { lifetime_value: 50000, churn_score: 0.1, industry: 'SaaS', team_size: 25, };

const options = ['Starter', 'Pro', 'Enterprise']; const result = await decideWithDrex(customerState, options, 'Best plan?');

console.log(result); // Output: {Starter: 0.05, Pro: 0.85, Enterprise: 0.10}

// Pick best option const bestOption = Object.entries(result) .sort(([,a], [,b]) => b - a)[0][0]; console.log(Recommendation: ${bestOption});

Opção 2: Hugging Face (download & run local)

bash

Download model

git lfs install git clone https://huggingface.co/nace/drex-1.5

Requirements

pip install torch transformers

Python code

from transformers import AutoModelForCausalLM, AutoTokenizer import torch

model_name = "nace/drex-1.5" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.bfloat16, device_map='auto', )

def decide_with_drex(state_dict, options, question): # Format input state_str = "\n".join([f"{k}: {v}" for k, v in state_dict.items()]) options_str = ", ".join(options)

prompt = f"""State:

{state_str}

Question: {question}

Options: {options_str}

Scores: """

inputs = tokenizer(prompt, return_tensors='pt').to(model.device)

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=50,
        temperature=0.1,  # Deterministic
    )

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
# Parse response to get scores
return parse_scores(response, options)

Usage

state = { 'lifetime_value': 50000, 'churn_score': 0.1, 'industry': 'SaaS', } options = ['Starter', 'Pro', 'Enterprise'] result = decide_with_drex(state, options, 'Best plan?') print(result) # {Starter: 0.05, Pro: 0.85, Enterprise: 0.10}

Opção 3: Hybrid (LLM + Drex)

python

Strategy: Use both pra máximo poder

async def smart_decision(context, options, question): """ 1. LLM gera reasoning (lento, mas smart) 2. Drex retorna probabilidades (rápido) 3. Combine: Reasoning + confident decision """

# Step 1: Get reasoning from LLM (parallel)
reasoning_task = generate_reasoning_with_llm(
    context, options, question
)

# Step 2: Get decision from Drex (parallel)
decision_task = decide_with_drex(
    context, options, question
)

# Wait both (concurrent)
reasoning = await reasoning_task
decision = await decision_task

# Step 3: Combine
best_option = max(decision.items(), key=lambda x: x[1])[0]
confidence = max(decision.values())

return {
    'option': best_option,
    'confidence': confidence,
    'reasoning': reasoning,  # Why this option
}

Usage

result = await smart_decision(state, options, 'Plan?') print(f"{result['option']} ({result['confidence']:.0%} confident)") print(f"Why: {result['reasoning']}")

Output:

Pro (85% confident)

Why: Your company size and budget fit Pro perfectly...

---

Performance na prática

Benchmark Drex vs alternatives

Tarefa: "Route customer to right team" Options: [Sales, Support, Success, Billing]

┌─────────────────┬────────┬──────────┬─────────────────┐ │ Model │ Lat. │ Cost │ Accuracy (%) │ ├─────────────────┼────────┼──────────┼─────────────────┤ │ GPT-4o │ 3500ms │ $0.015 │ 92% (rare errs) │ │ Claude 3.5 │ 2500ms │ $0.012 │ 94% (rare errs) │ │ Drex 1.5 │ 100ms │ $0.0001 │ 89% (reliable) │ │ Localhost Drex │ 50ms │ $0 │ 89% (reliable) │ │ Rule-based (if) │ 5ms │ $0 │ 70% (brittle) │ └─────────────────┴────────┴──────────┴─────────────────┘

Conclusion: ├─ Drex sweet spot: 100ms + $0.0001 + 89% accuracy ├─ Trade-off: Slightly less accurate (94 vs 89) │ ├─ But: Much faster (35x) │ ├─ And: 150x cheaper │ ├─ And: Deterministic (no surprises) │ └─ Worth it? YES, 100% │ └─ Use case: ├─ LLM: Complex reasoning, open-ended ├─ Drex: Quick decision, bounded options ├─ Rule: Ultra-fast, very brittle └─ Combo: Best UX (fast + accurate)

---

Quando usar Drex (decision matrix)

Use Drex quando: ✅ Options são bounded (A/B/C/D, não infinite) ✅ Speed matters (100ms vs 3s) ✅ Cost is concern (100x cheaper) ✅ Determinism required (no "oops, hallucinated") ✅ Context is structured (JSON state, not prose)

NÃO use Drex quando: ❌ Options são open-ended ("write a response") ❌ Need full reasoning explanation ❌ Creative generation (coding, copy) ❌ Few options (<3) → rule-based is simpler ❌ Ultra-low latency (<10ms) → run locally

Exemplos de USO: ├─ Route customer to team: Drex ✅ ├─ Plan recommendation: Drex ✅ ├─ Churn prediction: Drex ✅ ├─ Risk classification: Drex ✅ ├─ Generate email copy: LLM ❌ ├─ Write code: LLM ❌ ├─ Brainstorm ideas: LLM ❌ └─ Explain concept: LLM ❌

---

Conclusão: Drex muda a economia de decisões

Antes (LLM pra tudo):

❌ Slow: 1-5 segundos por decisão ❌ Caro: $0.01+ por call ❌ Risco: Pode alucinar opção inexistente ❌ Indeterminístico: Mesmo input pode mudar └─ Viável, mas subótimo

Depois (Drex pra decisões):

✅ Rápido: 100ms (10x melhor) ✅ Barato: $0.0001 (100x mais barato) ✅ Confiável: Outputs garantidos + calibrados ✅ Determinístico: Same input = same output └─ Melhor em todo aspecto

Para seu agente:

Implementação: ├─ Identifique decisões no seu agente ├─ Drex: Decision points (routing, classification) ├─ LLM: Reasoning + generation ├─ Combine: Rápido (Drex) + smart (LLM) └─ Deploy: Local (barato) ou hosted (simples)

ROI: ├─ Se 1M decisions/mês: Save $180K/ano ├─ Latência -35x: Conversão +30% ├─ Zero alucinação: Support tickets -20% └─ Total impact: 300%+ ROI

Bottom line:

Drex não é substituição pra LLM. Drex é especialista pra decisões.

Seu agente: └─ Decision points (70%) → Drex └─ Reasoning (30%) → LLM └─ Result: Fast + smart + cheap

→ OpenClaw: Agentes híbridos com Drex + LLM

Seu agente está usando LLM pra simples decisões? Hora de migrar pra Drex. ⚡