Seu agent custa R$3k/dia (routing inteligente = salva)

Seu agent custa R$3k/dia (routing inteligente = salva)

What just happened (October 2026):

AWS + Strands revealed:

"Most agents route EVERY request to expensive LLM (GPT-4, Claude Opus)."

"Reality: 80% of requests = simple (could use cheap model or local logic)."

"Solution: Adaptive routing (match model to request complexity)."

"Impact: 10x cost reduction (without sacrificing quality)."

What this means for your company:

Current situation (your agent deployed): Your agent: Customer service on WhatsApp Setup: Uses OpenAI GPT-4 Turbo (default) Daily traffic: 10,000 customer requests

Request types: Type 1 (Status check): "What's my order status?" Complexity: Very simple (lookup in database) Model needed: None (rule-based, not AI) Your agent does: Calls GPT-4 Turbo (R$0.30 per call) Cost: 3,000 requests × R$0.30 = R$900/day Correct approach: Check database (R$0.0001 per call) Correct cost: 3,000 requests × R$0.0001 = R$0.30/day Waste: R$900 - R$0.30 = R$899.70/day (99.97% waste) Annual waste: R$328,000 (just for this query type)

Type 2 (FAQ): "How do I return an item?"
  Complexity: Low (FAQ lookup)
  Model needed: Maybe Gemini-2B (cheap, good enough)
  Your agent does: Calls GPT-4 Turbo (R$0.30 per call)
  Cost: 4,000 requests × R$0.30 = R$1,200/day
  Correct approach: Gemini-2B (R$0.0003 per call)
  Correct cost: 4,000 requests × R$0.0003 = R$1.20/day
  Waste: R$1,200 - R$1.20 = R$1,198.80/day (99.9% waste)
  Annual waste: R$438,000

Type 3 (Complex analysis): "Recommend best plan for my needs"
  Complexity: High (needs reasoning, context understanding)
  Model needed: GPT-4 or Claude Opus (expensive, necessary)
  Your agent does: Calls GPT-4 Turbo (R$0.30 per call)
  Cost: 3,000 requests × R$0.30 = R$900/day
  Correct approach: GPT-4 (R$0.30 per call, appropriate)
  Correct cost: 3,000 requests × R$0.30 = R$900/day
  Waste: R$0 (correctly sized)
  Annual waste: R$0

Total daily waste: Status checks: R$900/day wasted FAQs: R$1,200/day wasted Complex: R$0/day wasted Total: R$2,100/day wasted Annual: R$766,000 wasted

What you thought: "Agent costs R$100/day in API calls" "Pretty cheap, seems fine"

What's actually happening: "Agent costs R$2,100/day in API calls" "But you're only paying for R$100/day of actual value" "R$2,000/day = pure waste (unnecessary expensive model calls)" "You're throwing away R$600k/year"

Why this happens: Engineers built agent "quick": Just route everything to GPT-4 Thought: "It's simple, works, no need to optimize" Reality: Optimization = biggest ROI opportunity Lesson: First agent is never the final agent (needs tuning)

Red flags you're overspending: ✓ Agent costs more than you expected ✓ Bill increases with traffic (should be more efficient) ✓ Using expensive model for simple queries ✓ No request routing logic (everything goes to same model) ✓ Never analyzed request complexity distribution ✓ Engineer said "GPT-4 works" (not "GPT-4 is necessary")

If 3+ apply: You're definitely overspending (probably by 10-100x)

---

The problem: One-size-fits-all model routing is expensive

Why agents bleed money on oversized models

How your agent wastes R$600k/year:

Your current architecture (naive routing): Request arrives → Always call GPT-4 → Return response

Problem: Every request (simple or complex) hits expensive model

Request 1: "What's my account balance?" Current: GPT-4 API call (R$0.30) Optimal: Database query (R$0.0001) Waste: R$0.30

Request 2: "Help me choose between plans" Current: GPT-4 API call (R$0.30) Optimal: GPT-4 API call (R$0.30) [correct] Waste: R$0

Request 3: "Is this charge correct?" Current: GPT-4 API call (R$0.30) Optimal: Claude-Haiku (R$0.02) Waste: R$0.28

Per 100 requests: 30% simple queries: 30 × R$0.30 = R$9 (should be R$0.03 = waste R$8.97) 50% medium complexity: 50 × R$0.30 = R$15 (could be Gemini-2B R$0.0003 = waste R$14.98) 20% complex: 20 × R$0.30 = R$6 (correct = R$6) Total: R$30 (should be R$6.03 = waste R$23.97) Waste percentage: 80%

Optimal routing architecture: Request arrives → Analyze complexity → Route to appropriate model

Routing decisions: If (query type == "status check") → Database query (R$0.0001) Else if (complexity < 0.3) → Gemini-2B (R$0.0003) Else if (complexity < 0.7) → Claude-Haiku (R$0.02) Else → GPT-4 (R$0.30)

Result: Simple queries: Handled locally or by cheap model Medium complexity: Fast, cheap model handles well Complex: Expensive model only when necessary Cost reduction: 80-90% (not less quality, just smarter routing)

Per 100 requests: 30% simple (database): 30 × R$0.0001 = R$0.03 50% medium (Gemini): 50 × R$0.0003 = R$0.015 20% complex (GPT-4): 20 × R$0.30 = R$6 Total: R$6.045 (was R$30, now R$6) Savings: R$23.96 per 100 requests (80% reduction)

Scale it up: Daily requests: 10,000 Current cost: 10,000 × R$0.30 = R$3,000 Optimized cost: 10,000 × R$0.60 = R$600 (80% reduction) Daily savings: R$2,400 Monthly savings: R$72,000 Annual savings: R$876,000

But wait: Your complexity distribution might be different If 90% simple queries: Savings = R$2,700/day = R$985k/year If 50% simple queries: Savings = R$1,500/day = R$547k/year If 10% simple queries: Savings = R$300/day = R$109k/year

Even conservative estimate: R$100k/year in savings (easy)

Why companies don't do this (and why they should): Reason 1: Laziness ("It just works" with GPT-4) Cost: R$876k/year in waste Effort to fix: 2-4 weeks (engineer time) ROI: 2000% (R$876k saved / R$40k engineer cost)

Reason 2: Complexity ("How do we classify requests?") Solution: Use meta-LLM (small model analyzes request, suggests model) Cost: Negligible (meta-LLM = R$0.0001 per call) Result: 90% accuracy in routing (good enough)

Reason 3: Latency ("Multiple models = slower?") Reality: Local queries faster than any API call API call: 500ms-2000ms (network) Local database: 10-50ms (same server) Optimization: Local > Cheap API > Expensive API

Reason 4: Quality ("Cheap model won't work") Reality: Gemini-2B works fine for 80% of queries FAQ lookup: Don't need GPT-4 (simple matching) Status check: Don't need GPT-4 (database lookup) Complex analysis: Only then use GPT-4 Insight: Right tool for right job (not biggest hammer for everything)

---

Smart routing strategies

How to implement adaptive agent routing

Routing tiers (from cheap to expensive):

Tier 1: Local (no API call needed) Use case: Status checks, FAQ lookups, data retrieval Examples: "What's my account balance?" → Check database "How do I reset password?" → Return FAQ text "What's my order #?" → Look up order in system Cost: R$0.0001 per request (database query) Quality: 100% (exact, not AI) Latency: 10-50ms (local)

Implementation: if (query matches FAQ) return faq_text() if (request_type == "status") return database_lookup() if (is_simple_data_retrieval) return cached_response() else continue to Tier 2

Estimated volume: 30-50% of requests Cost savings: Huge (eliminates API calls entirely)

Tier 2: Cheap local model (Gemini-2B, Llama-2, etc) Use case: Low-complexity reasoning, recommendations, simple analysis Examples: "Which plan should I choose?" → Gemini-2B analyzes needs "Why was I charged R$X?" → Gemini-2B explains (with context) "Fix my profile information" → Gemini-2B parses update request Cost: R$0.0003 per request (cheap API) Quality: 95% (good enough for most tasks) Latency: 200-500ms (API call, but fast model)

Implementation: if (complexity_score < 0.4) call gemini_2b() else continue to Tier 3

How to detect complexity: - Word count (simple = short, complex = long) - Keyword analysis (known vs unknown terms) - Requires reasoning? (Yes = complex, No = simple) - Historical data (track which questions are easy)

Estimated volume: 30-50% of requests Cost savings: 99% cheaper than GPT-4

Tier 3: Medium model (Claude-Haiku, GPT-3.5) Use case: Moderate reasoning, multi-step analysis Examples: "I'm having issue X with Y, help me debug" → Claude-Haiku reasons through it "Compare these 3 options" → GPT-3.5 analyzes differences "Generate monthly report" → Claude-Haiku summarizes data Cost: R$0.02 per request (medium API) Quality: 98% (very good for most cases) Latency: 500-1500ms (API, moderate latency)

Implementation: if (complexity_score < 0.7) call claude_haiku() else continue to Tier 4

Estimated volume: 15-30% of requests Cost savings: 93% cheaper than GPT-4

Tier 4: Expensive model (GPT-4, Claude-Opus) Use case: Complex reasoning, strategic decisions, novel problems Examples: "Design a custom integration for my use case" → GPT-4 thinks through it "Analyze my entire customer base and recommend strategy" → GPT-4 deep analysis "Debug complex system issue" → Claude-Opus investigates Cost: R$0.30 per request (expensive, but necessary) Quality: 99%+ (best available) Latency: 1000-3000ms (API, slower)

Implementation: if (complexity_score >= 0.7) call gpt4() else error (shouldn't reach here)

Estimated volume: 5-15% of requests Cost savings: None (but money spent on actual value)

Implementation checklist: [ ] Analyze current request distribution (80/20 rule) [ ] Identify which requests go to which tier [ ] Build complexity detection (keywords, patterns, historical data) [ ] Test routing accuracy (doesn't downgrade quality) [ ] Monitor costs per tier (ensure savings) [ ] A/B test (compare one-model vs adaptive routing) [ ] Refine thresholds (based on results) [ ] Document routing logic (team understanding) [ ] Automate routing decision (in agent code) [ ] Monitor ongoing (cost, quality, latency)

Cost modeling example: Tier 1 (local): 40% requests × R$0.0001 = R$4/day Tier 2 (cheap): 35% requests × R$0.0003 = R$10.50/day Tier 3 (medium): 20% requests × R$0.02 = R$60/day Tier 4 (expensive): 5% requests × R$0.30 = R$150/day Total: R$224.50/day (was R$3,000/day with naive routing) Savings: R$2,775.50/day = R$1.01M/year

Implementation cost: R$20-40k (engineer time) ROI: 2500% (R$1.01M saved / R$40k cost) Payback period: 5 days

Meta-routing (auto-detect complexity): Approach: Use lightweight model to analyze request, suggest tier

Meta-model request: Input: Customer request Output: Complexity score (0.0 - 1.0) Model: Distilbert-base (tiny, <50MB, R$0.00001 per call) Speed: 50-100ms (local inference)

Routing logic: score = meta_model.analyze(request) if score < 0.3: use_local() elif score < 0.5: use_gemini_2b() elif score < 0.8: use_claude_haiku() else: use_gpt4()

Accuracy: 85-90% (good enough for cost optimization) Cost: Negligible (meta-model is tiny) Benefit: Automatic, no manual classification needed

Hybrid approach: Combine multiple strategies: 1. Pattern matching (FAQ, status = local) 2. Meta-routing (complexity detection) 3. Feedback loop (user satisfaction → adjust thresholds) 4. A/B testing (compare routing strategies)

Result: Converges to optimal routing over time Effort: One-time implementation, then continuous tuning

---

Bottom line

The routing imperative:

AWS/Strands insight: "Every request to expensive model = waste" "80% of requests = simple (don't need GPT-4)" "Adaptive routing = 10x cost reduction"

Your situation: Agent deployed: Yes Using single expensive model: Probably yes Request complexity distribution analyzed: Probably not Annual waste: R$100k-1M (likely) Time to fix: 2-4 weeks ROI of fixing: 500-2500%

Current bill: R$100-300/day (you think) Actual optimal bill: R$10-50/day Difference: R$50-250/day you're overpaying Annual overpayment: R$18k-91k (conservative)

What you're paying for: R$30/day: Actual agent value R$70/day: Waste from oversized models R$100/day: Total

Only 30% of bill = value
70% of bill = pure waste

Action items (this week):

1. Audit: Check your LLM API logs (which model, how many calls)
2. Analyze: Request complexity distribution (simple vs complex %)
3. Calculate: How much you'd save with adaptive routing
4. Plan: Routing tiers + complexity detection logic
5. Implement: Build routing logic into agent
6. Monitor: Track cost per tier, adjust thresholds
7. Refine: Continuous tuning based on results

Expected outcomes: Week 1: Audit + analysis (understand your baseline) Week 2-3: Implementation (build routing logic) Week 4: Testing + monitoring (verify quality maintained) Month 2: Cost reduction visible (R$100k+ annual savings) Ongoing: Continuous optimization (additional savings)

Quick win (implement today): [ ] Identify 3 request types that could use local/cheap tier [ ] Calculate savings if you route those 3 types differently [ ] Implement routing for those 3 types [ ] Measure: Cost reduction + quality impact [ ] Expand: Add more request types to routing

Expected: 30-50% cost reduction in first iteration Effort: 3-5 hours Savings: R$15-50k/year ROI: Immediate (5-10x return on engineering time)

Final thought: Using GPT-4 for status checks = like hiring McKinsey partner to answer emails Wrong tool, wrong price, obvious waste Adaptive routing = hiring junior analyst for emails, McKinsey partner for strategy Right tool for right job = 10x cheaper, same/better results

→ OpenClaw: Adaptive agent routing, cost optimization, LLM model selection, agent efficiency, request complexity classification, intelligent model switching

Seu agent custa R$3k/dia porque chama GPT-4 pra TUDO. Routing inteligente = Gemini-2B pra 80%. Salva R$1M/ano. 💰🧠✨