Seu agent usa GPT-4 (mas Llama 2 resolveria)

Seu agent usa GPT-4 (mas Llama 2 resolveria).

Você é founder de SaaS.

Você deployou agent no WhatsApp.

Agent faz suporte (responde perguntas sobre produto).

Seu setup:

WhatsApp Customer → Agent (GPT-4) → Response

Cost per request: ├─ Input: 500 tokens × $0.03/1k = $0.015 ├─ Output: 200 tokens × $0.06/1k = $0.012 ├─ Total: $0.027 (R$0.14 por request) │ ├─ Per day (100 requests): R$14 ├─ Per month (3000 requests): R$420 ├─ Per year (36k requests): R$5,040 │ └─ Agent task: "Responda perguntas simples sobre product (FAQ)" Example: "Qual é seu horário de atendimento?" Required: Ler FAQ, responder Complexity: BAIXA (não precisa reasoning complexo) Model needed: Qualquer model (até Llama 2) Model used: GPT-4 (OVERKILL)

Alternativa (Llama 2 via AWS Bedrock):

WhatsApp Customer → Agent (Llama 2) → Response

Cost per request: ├─ Input: 500 tokens × $0.001/1k = $0.0005 ├─ Output: 200 tokens × $0.0015/1k = $0.0003 ├─ Total: $0.0008 (R$0.004 per request) │ ├─ Per day (100 requests): R$0.40 ├─ Per month (3000 requests): R$12 ├─ Per year (36k requests): R$144 │ └─ Agent task: Same (responda perguntas simples) Complexity: Same (BAIXA) Model needed: Llama 2 (PERFECT FIT) Model used: Llama 2 (RIGHT-SIZED)

Diferença de custo:

• GPT-4: R$5,040/year
• Llama 2: R$144/year
• Economia: R$4,896/year (96% cheaper)

Mas você usa GPT-4 porque...

"GPT-4 é melhor!"

"Melhor em quê?"

"Melhor em... tudo?"

Errado.

GPT-4 é melhor em algumas coisas (reasoning complexo, code generation, análise profunda). Mas pra tarefa simples (responder FAQ), Llama 2 é igualmente bom (talvez até melhor porque mais rápido).

Result:

Você pagou 35x mais pelo model

Pra task que não precisava 35x de poder computacional.

Essa é a dor do empresário:

Todas as startups fazem isso.

Usam GPT-4 / Claude Opus pra tudo.

Agentem simples, task simples, model gigante.

Conta de AI explode.

CEO quer saber por quê agent custa tanto.

---

Ontem, Diogo Almeida (coautor do InstructGPT paper, CEO da TypeSafe AI) disse:

"Stop using frontier models for production. Use System One models instead."

"System One = right-sized models for the job."

"We've been so obsessed with 'bigger = better' that we forgot: Right-sized = better."

---

O problema: Frontier model obsession (aka "God models")

Por que founders só usam GPT-4 (e perdem dinheiro)

=== THE PROBLEM ===

Founders think: "I need AI agent. Let me use best model." ├─ "Best" = Most powerful ├─ Most powerful = Frontier model ├─ Frontier model = GPT-4 / Claude Opus / Grok 4.7 │ ├─ Cost: R$0.14+ per request ├─ Speed: 2-3 sec (slow) ├─ Overkill: 99% of production tasks don't need frontier model power │ └─ Result: Agent costs R$5k-10k/month (overkill) Better solution: Use right-sized model for R$500-1k/month Money wasted: R$4.5k-9k/month (45-90% of budget)

=== WHY FRONTIER MODELS ARE WRONG FOR PRODUCTION ===

Frontier model traits: ├─ Super expensive (R$0.10+ per 1k tokens) ├─ Super slow (2-3 sec latency) ├─ Optimized for: Reasoning, creativity, complex tasks ├─ Optimized AGAINST: Speed, cost efficiency, simplicity │ ├─ Use case where frontier model makes sense: │ ├─ Complex reasoning ("Analyze this legal contract") │ ├─ Creative writing ("Write marketing copy") │ ├─ Code generation ("Build me a function that does X") │ ├─ Deep analysis ("Why is this product failing?") │ └─ Frequency: 5% of production tasks │ ├─ Use case where frontier model is OVERKILL: │ ├─ FAQ responses ("What are your hours?") │ ├─ Simple classification ("Is this email spam?") │ ├─ Data extraction ("Extract order number from message") │ ├─ Routing ("Which department should this go to?") │ ├─ Simple Q&A ("Where's my order?") │ └─ Frequency: 95% of production tasks │ └─ Problem: Founders use frontier model for 95% of tasks (wrong) Should use: Right-sized model for 95% (right) Cost difference: 35x cheaper with right-sized model

=== WHAT IS "SYSTEM ONE" MODEL? ===

System One = Right-sized model for production ├─ Speed: <1 sec (vs 2-3 sec for frontier) ├─ Cost: R$0.001-0.01 per request (vs R$0.10+ for frontier) ├─ Quality: 95%+ accuracy for simple tasks (vs 99%+ for frontier, overkill) ├─ Reliability: Consistent output (vs sometimes hallucinating, frontier) ├─ Latency: Sub-second (vs seconds, frontier) │ ├─ Examples: │ ├─ Llama 2 (7B, 13B) │ ├─ Llama 2 Instruct │ ├─ Mistral 7B │ ├─ Phi (Microsoft) │ ├─ Qwen (Alibaba) │ └─ (Any model < 70B optimized for speed, not reasoning) │ ├─ Why "System One"? │ ├─ Reference: Daniel Kahneman's "Thinking, Fast and Slow" │ ├─ System 1 = Fast, intuitive, simple thinking │ ├─ System 2 = Slow, deliberate, complex thinking │ ├─ Production tasks = System 1 (fast, simple) │ ├─ Reasoning tasks = System 2 (slow, complex) │ └─ Match task to system = optimal │ └─ Key insight: "Frontier models are System 2 thinking. Most production tasks are System 1 thinking. Mismatch = waste."

=== THE COST COMPARISON ===

Task: FAQ agent (100 requests/day, 3k/month)

Frontier model (GPT-4 via OpenAI): ├─ Per request cost: R$0.15 ├─ Per month: R$0.15 × 3k = R$450/month ├─ Per year: R$5,400/year ├─ Speed: 2-3 sec ├─ Setup: Easy (API call) │ System One model (Llama 2 via AWS Bedrock): ├─ Per request cost: R$0.004 ├─ Per month: R$0.004 × 3k = R$12/month ├─ Per year: R$144/year ├─ Speed: <1 sec ├─ Setup: Moderate (need AWS account) │ System One model (Llama 2 self-hosted on A100): ├─ Per request cost: R$0.0001 (amortized) ├─ Per month: R$0.0001 × 3k = R$0.30/month ├─ Per year: R$3.60/year ├─ Speed: <0.5 sec ├─ Setup: Hard (need infrastructure) │ === SAVINGS ===

Frontier → Bedrock System One: ├─ Savings: R$450 - R$12 = R$438/month (97% cheaper) ├─ Per year: R$5,256/year saved │ Frontier → Self-hosted System One: ├─ Savings: R$450 - R$0.30 = R$449.70/month (99.9% cheaper) ├─ Setup cost: R$20k (GPU infrastructure) ├─ Break-even: 45 months ├─ Per year (after break-even): R$5,396/year saved │ === THE QUESTION ===

If you can get 95% same quality For 1% of the cost With 2x speed Why use frontier model?

Answer: Because you don't know what System One is.

---

A solução: Right-sized models for production

Como escolher o model certo pra sua agent task

=== DECISION MATRIX: WHICH MODEL TO USE? ===

Task: Simple FAQ ("What are your hours?") ├─ Complexity: LOW ├─ Reasoning needed: NO ├─ Accuracy requirement: 95% (good enough) ├─ Latency requirement: <1 sec (WhatsApp real-time) ├─ Cost tolerance: Minimize cost │ ├─ Frontier model (GPT-4): WRONG CHOICE │ ├─ Overkill: 99% capabilities wasted │ ├─ Cost: R$0.15 per request │ ├─ Speed: 2-3 sec (too slow) │ └─ Decision: NO │ ├─ System One model (Llama 2): PERFECT CHOICE │ ├─ Sufficient: 95% accuracy achieved │ ├─ Cost: R$0.004 per request │ ├─ Speed: <1 sec │ └─ Decision: YES │ └─ Recommendation: Use Llama 2 / Mistral 7B Provider: AWS Bedrock (managed) Cost: R$12/month (3k requests/month)

---

Task: Customer service routing ("Which department?") ├─ Complexity: LOW-MEDIUM ├─ Reasoning needed: MINIMAL (classify intent) ├─ Accuracy requirement: 90% (good enough) ├─ Latency requirement: <2 sec ├─ Cost tolerance: Minimize cost │ ├─ Frontier model: WRONG CHOICE │ └─ Decision: NO │ ├─ System One model: PERFECT CHOICE │ ├─ Sufficient: 90% accuracy easily achieved │ ├─ Cost: R$0.005 per request │ ├─ Speed: <0.5 sec │ └─ Decision: YES │ └─ Recommendation: Use Llama 2 / Mistral 7B Provider: AWS Bedrock Cost: R$15/month (3k requests/month)

---

Task: Complex reasoning ("Analyze this contract and list risks") ├─ Complexity: HIGH ├─ Reasoning needed: YES (deep analysis) ├─ Accuracy requirement: 99% (need perfection) ├─ Latency requirement: Can be slow (5-10 sec okay) ├─ Cost tolerance: Pay for quality │ ├─ System One model: INSUFFICIENT │ ├─ Accuracy: Only 85% (not good enough) │ ├─ Reasoning: Limited capability │ └─ Decision: NO │ ├─ Frontier model: PERFECT CHOICE │ ├─ Sufficient: 99% accuracy achieved │ ├─ Reasoning: Deep analysis possible │ ├─ Cost: R$0.15 per request (okay for high-value task) │ └─ Decision: YES │ └─ Recommendation: Use GPT-4 / Claude Opus Provider: OpenAI / Anthropic Cost: R$0.15 per request (acceptable for high-value work)

---

Task: Code generation ("Write function that calculates X") ├─ Complexity: MEDIUM-HIGH ├─ Reasoning needed: YES (algorithmic thinking) ├─ Accuracy requirement: 95% (some errors okay, developer will fix) ├─ Latency requirement: Can be slow (2-3 sec okay) ├─ Cost tolerance: Moderate │ ├─ System One model: MARGINAL │ ├─ Accuracy: 70-80% (some errors, developer frustrated) │ ├─ Code quality: Mediocre │ ├─ Decision: MAYBE (risky) │ ├─ Mid-size model (Mistral Medium / Llama 34B): GOOD CHOICE │ ├─ Accuracy: 85-90% (mostly correct) │ ├─ Code quality: Good │ ├─ Cost: R$0.02 per request │ ├─ Decision: YES │ ├─ Frontier model: OVERKILL BUT SAFE │ ├─ Accuracy: 98%+ (nearly perfect) │ ├─ Code quality: Excellent │ ├─ Cost: R$0.15 per request │ ├─ Decision: YES (if budget allows) │ └─ Recommendation: Use Mistral Medium Provider: AWS Bedrock / Mistral API Cost: R$0.02 per request

---

=== DECISION FRAMEWORK ===

Choose System One model (Llama 2 / Mistral 7B) if: ├─ ✓ Task is simple (FAQ, classification, extraction, routing) ├─ ✓ Accuracy 95% is acceptable ├─ ✓ Speed <1 sec is needed (real-time) ├─ ✓ Cost is important (budget conscious) ├─ ✓ Hallucinations are acceptable (low risk) │ Choose Mid-size model (Mistral Medium / Llama 34B) if: ├─ ✓ Task is medium complexity (some reasoning needed) ├─ ✓ Accuracy 90%+ is acceptable ├─ ✓ Speed 1-2 sec is acceptable ├─ ✓ Cost is important (moderate budget) ├─ ✓ Reasoning power needed (but not expert-level) │ Choose Frontier model (GPT-4 / Claude Opus) if: ├─ ✓ Task is complex (deep reasoning needed) ├─ ✓ Accuracy 99%+ is required ├─ ✓ Speed is not important (seconds okay) ├─ ✓ Cost is not important (high-value task) ├─ ✓ Hallucinations must be minimized (high risk if wrong)

---

Por que Diogo Almeida (InstructGPT author) está certo

"We've been using God models for tasks that need System One thinking"

=== DIOGO ALMEIDA'S THESIS ===

Quote: "API-available frontier models have gone down the wrong path."

Meaning: ├─ OpenAI, Anthropic, xAI only release frontier models (GPT-4, Claude, Grok) ├─ No one releases small, fast, cheap System One models ├─ Result: Builders only have access to frontier models ├─ Result: Builders use frontier models for everything (including overkill tasks) ├─ Result: Agent costs 35x more than necessary │ ├─ Analogy: Imagine car manufacturers only made Ferraris │ ├─ Someone needs to go to grocery store │ ├─ Only option: Drive Ferrari │ ├─ Cost: R$1M car for R$20 grocery trip │ ├─ Problem: Not the car's fault (it's great) │ ├─ Problem: Wrong car for the job │ └─ Solution: Need cheap Honda Civic option too │ ├─ Same with LLMs: │ ├─ Someone needs FAQ agent │ ├─ Only option: GPT-4 (frontier) │ ├─ Cost: R$5k/year for R$200/year task │ ├─ Problem: Not GPT-4's fault (it's great) │ ├─ Problem: Wrong model for the job │ └─ Solution: Need Llama 2 (System One) option too │ └─ Insight: We don't have a model problem. We have a model ecosystem problem. We need both frontier AND System One models. Currently we only have frontier.

Quote: "Alignment and refusals are making frontier models worse."

Meaning: ├─ OpenAI/Anthropic made frontier models "safe" with guardrails ├─ Guardrails = refuse unsafe requests ├─ Problem: Guardrails slow down model (reasoning about safety) ├─ Problem: Guardrails make model unpredictable (refuse random things) ├─ Problem: For production tasks, you don't need guardrails (you control input) │ ├─ Example: │ ├─ Frontier model refusal: "I can't help with that (might be unsafe)" │ ├─ Your task: Extract order number from customer message │ ├─ Input: "My order 12345 is broken" │ ├─ Why is model refusing? Not unsafe, just feature extraction │ ├─ Result: Wasted latency + frustrating error handling │ └─ Solution: Use System One model (no unnecessary guardrails) │ └─ Insight: Frontier model guardrails hurt production performance. You don't need them for controlled, internal tasks. System One models = no guardrails = faster + simpler.

Quote: "Everything became autoregressive chat-tuned LLMs because of ChatGPT success."

Meaning: ├─ ChatGPT was successful (everyone adopted it) ├─ Result: Everyone built around ChatGPT architecture ├─ Result: Model ecosystem collapsed into single type (chat-tuned LLM) ├─ Problem: Not all tasks need chat-tuned LLM ├─ Problem: Some tasks (classification, extraction) need simpler architecture ├─ Problem: We lost model diversity │ ├─ What we lost: │ ├─ Small, fast, cheap models (Llama 7B) │ ├─ Specialized models (domain-specific) │ ├─ Non-chat-tuned models (simpler) │ └─ Efficient models (edge deployment) │ ├─ What we need: │ ├─ Bring back small models (System One) │ ├─ Bring back specialized models (industry-specific) │ ├─ Bring back efficient architectures (fast + cheap) │ └─ Stop obsessing with frontier models (they're for 5% of tasks) │ └─ Insight: Model monoculture = suboptimal for production. We need model diversity. We need System One models back.

=== THE SHIFT ===

Old paradigm: "Biggest model = best" ├─ Invest in: Scaling models (GPT-5, Claude 4, etc.) ├─ Result: Bigger models (more expensive, slower) ├─ Use case: 5% of tasks (reasoning, creativity, analysis) │ New paradigm: "Right-sized model = best" ├─ Invest in: System One models (speed, cost, efficiency) ├─ Result: Variety of models (small, medium, large) ├─ Use case: 95% of tasks (FAQ, classification, extraction, routing) │ Winner: Builders who use right-sized models ├─ Cost: 35x cheaper ├─ Speed: 2-3x faster ├─ Simplicity: Easier to operate ├─ Quality: Same (95% accuracy sufficient for 95% of tasks) │ Loser: Builders who use frontier models for everything ├─ Cost: 35x more expensive ├─ Speed: 2-3x slower ├─ Complexity: Hard to operate ├─ Quality: Same (99% accuracy overkill for 95% of tasks) │ === THE PREDICTION ===

In 2 years: ├─ System One models will dominate production (95% of usage) ├─ Frontier models will be specialist tools (5% of usage) ├─ Builders using frontier models for everything will be seen as wasteful ├─ Cost-optimized teams will use right-sized model for each task ├─ Agent economics will shift from "expensive" to "cheap" │ Companies winning: ├─ Companies that adopt System One models early ├─ Companies that optimize agent cost (same quality, 35x cheaper) ├─ Companies that can deploy agents at scale (cheap = deploy more) │ Companies losing: ├─ Companies stuck on frontier models (expensive) ├─ Companies with high agent costs (can't compete) ├─ Companies deploying few agents (cost-prohibitive)

---

Conclusão

Simple verdade:

You don't need GPT-4 for FAQ agent.

You need Llama 2 (System One model).

Diogo Almeida (InstructGPT author, CEO TypeSafe AI) is right:

1. Frontier models are wrong for production (expensive, slow, overkill)
2. System One models are right for production (cheap, fast, sufficient)
3. We have a model ecosystem problem (only frontier models available)
4. The future is right-sized models (small for simple, large for complex)

Cost impact:

• Frontier model: R$5k-10k/year per agent
• System One model: R$144-500/year per agent
• Savings: 95% cost reduction (R$4.5k-9.5k/year)

Speed impact:

• Frontier model: 2-3 sec latency (slow WhatsApp)
• System One model: <1 sec latency (fast WhatsApp)
• Speed gain: 3-6x faster

Quality impact:

• Frontier model: 99% accuracy (overkill)
• System One model: 95% accuracy (sufficient)
• No difference in user experience (both "good enough")

Risk:

If you don't switch to right-sized models, competitors will.

They'll have 35x cheaper agents.

They'll deploy 35x more agents.

They'll dominate the market.

---

Próximos passos

Na OpenClaw, ajudamos SaaS builders migrar pra right-sized models:

• Model Audit: Qual model você tá usando? Por quê? (analysis)
• Task Classification: Qual é o complexity de cada task? (mapping)
• Model Selection: Qual é o right-sized model pra cada task? (optimization)
• Cost Analysis: Quanto você vai economizar? (ROI)
• Migration: Como switch sem breaking agents? (execution)
• Benchmarking: Como validar quality après migration? (validation)
• Monitoring: Como track cost savings + quality metrics? (operations)
• Scaling: Como deploy 10x mais agents com same budget? (growth)
• Architecture: Como build multi-model agent (small + frontier)? (design)
• Team Training: Como educate team on model selection? (culture)

System One Models | Right-Sized LLM | Agent Cost Optimization →