Agent responde (mas human decide aonde mandar)

Agent responde (mas human decide aonde mandar)

What just happened (October 2026):

Rescale published case study on AI triage agent:

"Problem: Engineering team, nightly test failures."

"Current workflow: Human on-call reads logs, classifies root cause, routes to right team."

"Inefficiency: Same manual steps repeat daily (classify + route = full-time hidden job)."

"Solution: AI triage agent automate the whole flow."

"Agent process: Read logs (step 1) → Classify error (step 2) → Route to owner (step 3) → Done."

"Result: Full automation (no human touches it, agent handles end-to-end)."

What this means for your company:

Current situation (your customer service agent):

Workflow (typical SaaS support): Customer: "Meu pagamento foi rejeitado" Agent: Responds → "Entendo, vou verificar" Agent (step 1): Retrieve customer data (answer question) Agent (step 2): Classify issue: "Payment declined" (classification) Agent (step 3): Human supervisor decides routing → Should go to Billing team? Finance team? Payment processor? → Human makes decision (manually) → Ticket sent to team Human (step 4): Team responds (finally)

Timeline:
  Agent responds: Instant (5 sec)
  Human routes: Manual (5-30 minutes)
  Team responds: Delayed (30 min - 2 hours)
  Customer resolution: Slow (several hours)
  

Problem: Step 1-2 (agent): Automated ✓ Step 3 (routing): MANUAL ✗ (bottleneck) Step 4 (team): Automated ✓

Agent automated answer, but human still gatekeeping routing
Result: Agent automation = partial (only 33% of workflow)
ROI: 30% (agent helped, but human still needed for routing)

With intelligent routing agent (Rescale model): Workflow (fully automated): Customer: "Meu pagamento foi rejeitado" Agent (step 1): Retrieve customer data Agent (step 2): Classify issue: "Payment declined" Agent (step 3): Intelligent routing (no human needed) → Check: Is customer issue about failed payment? → Route to: Billing team (internal classifier: "payment issue") → Route automatically (no human decision needed) Agent (step 4): Send to team + context (logs, customer history, classification) Team (step 5): Responds (already have context)

Timeline:
  Agent responds + routes: Instant (10 sec, fully automated)
  Human routes: Zero (automated) 🎯
  Team responds: Faster (already have full context)
  Customer resolution: Fast (5-30 minutes)
  

Result: Step 1-3 (agent): Fully automated ✓ Step 4-5 (team): Faster (already have context) ✓ Human involvement: Zero (pure automation) ROI: 90% (truly end-to-end automation)

---

The hidden problem: Routing bottleneck

Why routing is invisible but deadly

The paradox: Agent works, but automation fails

What you see (success metrics): ✓ Agent deployed (working) ✓ Agent responds to 1,000 customer inquiries/day ✓ Agent accuracy: 95% ✓ Agent cost: R$2k/day (vs R$20k human cost)

Conclusion: Agent is working, saving 90% on support cost!

What's actually happening (hidden): ✓ Agent responds to 1,000 inquiries ✗ Agent routes to team: Manual (human decides where each ticket goes) ✗ Routing process: 30 min/ticket (human classification) ✗ Routing bottleneck: 1,000 tickets × 30 min = 500 hours/day (impossible) ✗ Actual flow: Only 100 tickets routed/day (80% abandoned)

Reality: Agent handles response (good) But human routing blocks escalation (bad) Result: 800 tickets stuck (customer never reaches right team) ROI: Actually negative (agent added complexity, no real automation)

The routing problem in detail:

Typical SaaS agent workflow (broken):

1. Customer inquiry arrives: "Quanto custa o plano Pro?"

2. Agent responds: "O plano Pro custa R$500/mês, inclui X, Y, Z" (Agent working! Accuracy 95%!)

3. Customer asks follow-up: "Posso ter desconto anual?"

4. Agent responds: "Sim, 20% desconto se pagar anual" (Agent still working!)

5. Customer asks: "Mas preciso de integração customizada, vocês fazem?"

6. Agent responds: "Podemos fazer integração customizada" (Agent confident, maybe wrong)

7. Customer asks: "Ok, como funciona a integração? Tenho que assinar contrato separado?"

8. Agent responds: "Sim, há um contrato separado. Deixa eu conectar um vendedor." (Agent admits defeat, needs human)

9. Routing (MANUAL step): Agent sends ticket to: Queue: "Sales team" But which sales person? Assigned to whom? Human supervisor: "Hmm, let's see..." Looks at customer: "SME customer, high value, assign to senior sales" Time spent: 15-30 minutes (human classification)

10. Finally routed: Sales person gets ticket (30 min after inquiry) Customer already frustrated (waited) Sales person has to re-read context Inefficient.

Problem: Step 1-8: Agent handles (fast) Step 9: Human decides routing (slow, 30 min) Step 10: Delayed escalation (customer waits)

Agent automation: Partial (answer is automated)
Routing: Manual (human bottleneck)
Net ROI: 30% (agent helped, but routing killed efficiency)

Why companies don't automate routing

Common reasons (all wrong):

Reason 1: "Routing is too complex (different rules per team)" Reality: Not complex, just not prioritized Solution: Build simple classifier (Rescale did it in weeks)

Reason 2: "Routing mistakes are expensive (route to wrong team = bad)" Reality: Manual routing also makes mistakes (humans distracted) Solution: Intelligent routing with confidence scores (if unsure, escalate to human)

Reason 3: "We tried, routing is hard" Reality: Probably didn't invest enough Solution: Use multi-step agent (Rescale's approach: classify + route + notify)

Reason 4: "Each team has unique needs (can't automate)" Reality: Most teams follow patterns Solution: Build agent per routing rule (Rescale example: payment issues → Billing)

---

How intelligent routing works (Rescale's approach)

Multi-step agent: The key

Agent with routing (what Rescale built):

Step 1: Understand the issue Input: Customer inquiry (text) Agent: "What's the core problem?" Action: Classify into category Categories: Payment issue, Feature question, Bug report, Billing, Technical, etc. Output: Issue category (high confidence) Time: <100ms

Step 2: Gather context Input: Issue category Agent: "What do I need to know to route correctly?" Action: Retrieve relevant data Data: Customer profile, usage history, account status, similar past issues Output: Full context for routing decision Time: <500ms

Step 3: Intelligent routing Input: Issue category + context Agent: "Which team should handle this?" Action: Apply routing logic Logic examples: IF issue=Payment AND customer_status=Premium THEN route=VIP_Billing (priority) IF issue=Technical AND usage_pattern=Complex THEN route=Senior_Engineer IF issue=Feature AND status=Enterprise THEN route=Product_Manager Output: Recommended team + confidence score Time: <200ms

Step 4: Escalate with context Input: Routed team + full context Agent: "Send all information to the team" Action: Create ticket with full context Context includes: - Original issue (verbatim) - Agent's classification (why routed here) - Customer context (history, profile, importance) - Suggested next steps (agent's recommendation) Output: Ticket sent to team (zero human involvement) Time: <100ms

Total process: <1 second (fully automated, no human needed)

Comparison: Manual routing (current): 30 minutes per ticket Intelligent agent routing: <1 second per ticket Speed improvement: 1800x faster

Routing rules (how to build your own)

Simple classification framework:

Step 1: Define routing categories Example categories: 1. Billing (payment, subscription, invoices) 2. Technical support (bugs, errors, crashes) 3. Feature requests (new functionality) 4. Integrations (API, connections, webhooks) 5. Sales (pricing, enterprise, custom features) 6. Account management (user management, permissions)

Step 2: Define routing rules (if-then logic) Rule 1: IF issue_contains("payment", "invoice", "charge") AND confidence > 80% THEN route=Billing_Team

Rule 2: IF issue_contains("bug", "crash", "error") AND error_type_identified THEN route=Engineering_Team

Rule 3: IF issue_contains("new feature", "request") AND priority=high THEN route=Product_Manager

Rule 4: IF issue_contains("API", "integration") AND customer_type=Enterprise THEN route=DevOps_Team

Rule 5: IF issue_contains("pricing", "discount", "custom plan") AND deal_size > R$50k THEN route=Enterprise_Sales

Step 3: Prioritization (route based on urgency) Priority 1 (urgent): Customer on-call, system down, revenue impact → Route to senior team (fast response)

Priority 2 (normal): Standard issues, feature questions → Route to standard team

Priority 3 (low): Feedback, general questions → Route to queue (can wait)

Step 4: Confidence handling (uncertain routing) IF confidence score < 70% THEN route=Human_Review (safety fallback)

This ensures: - High-confidence routes (>70%) are automated - Low-confidence routes are human-verified - Zero bad routing (safety > speed)

---

Real-world impact: Rescale's results

Before: Manual triage (broken)

Scenario: Engineering on-call rotation

Nightly ritual:

1. Test suite fails (happens daily)
2. On-call engineer woken up (2 AM)
3. Engineer pulls logs (5 min)
4. Engineer reads/classifies error (10 min) - Is it DB issue? API issue? Service issue?
5. Engineer routes to team (5 min) - Which team owns this service? - Who's on-call? - Send to right person
6. Next engineer takes over (10 min handoff)
7. Engineer fixes issue (30-60 min)

Total time: ~2 hours per incident

Daily impact: Incidents/day: 3-5 Time on-call: 6-10 hours/day Engineer burnout: Inevitable Quality: Degraded (tired engineers make mistakes)

Mental toll: On-call engineer: Constantly anxious Sleep disrupted: 2-3 wake-ups/night Productivity next day: 50% (tired) Turnover: High (engineers quit on-call)

Business cost: Salary cost: R$200k/engineer/year On-call burden: 30% time wasted on triage Real cost: R$60k/year per engineer (just on triage)

If 10 engineers on rotation: Total annual cost: R$600k (pure overhead, no features built)

After: Intelligent triage agent (fixed)

Scenario: Same engineering on-call rotation

Nightly automation:

1. Test suite fails (happens daily)
2. Agent reads logs (automated, <1 sec)
3. Agent classifies error (automated, <1 sec) - DB issue? API issue? Service issue?
4. Agent routes to team (automated, <1 sec) - Sends to service owner (automatic) - Includes full context (logs, history, classification)
5. Right team gets notification (instant)
6. Team fixes issue (30-60 min)

Total time: ~30-60 min (no human triage needed)

Daily impact: Incidents/day: 3-5 (same) Engineer woken up: Yes (still needed to fix, agent just triaged) Time on-call: 2-4 hours/day (66% less) Time wasted on triage: 0% (agent handled it) Quality: Improved (engineers start with full context, no re-reading logs)

Mental toll: On-call engineer: Aware agent will triage Sleep disruption: Only when incident critical (less anxiety) Productivity next day: 85% (less tired) Turnover: Reduced (on-call is now acceptable)

Business cost: Agent cost: R$5k/month (infrastructure) Engineer time saved: 30% × 10 engineers × R$200k = R$600k/year Net savings: R$600k - R$60k = R$540k/year (pure profit)

Plus: Faster incident resolution (30 min vs 2 hours) = less customer impact Reduced engineer burnout = better quality code Lower turnover = cost of new hire avoided (R$100k per engineer)

---

How to build your own intelligent routing agent

4-week roadmap

Week 1: Define routing logic

[ ] Map current workflow [ ] How do tickets currently get routed? (manual, rules, etc.) [ ] Who makes routing decisions? [ ] How long does routing take? [ ] What are the errors? (wrong team, delayed routing)

[ ] Define routing categories [ ] What are the main issue types? [ ] What's the routing rule for each? [ ] Create decision tree (if-then rules) [ ] Identify confidence thresholds (when to escalate to human)

[ ] Document rules [ ] For each category: What data predicts correct routing? [ ] Build classifier: Given issue text, what category? [ ] Build router: Given category + context, what team?

Week 2: Build classification agent

[ ] Train classifier [ ] Get 200-500 historical tickets [ ] Label each with correct category [ ] Train LLM classifier (Llama, Claude, etc.) [ ] Test accuracy (target: >85%)

[ ] Build context retrieval [ ] Agent retrieves customer data (profile, history, priority) [ ] Agent retrieves issue context (error logs, related tickets) [ ] Combine context for routing decision

[ ] Test multi-step agent [ ] Agent: Classify issue [ ] Agent: Gather context [ ] Agent: Output routing recommendation [ ] Test on 50 real tickets (compare agent routing vs human routing)

Week 3: Implement routing logic

[ ] Build routing rules engine [ ] Implement if-then logic (category → team) [ ] Implement confidence scoring (how sure is agent?) [ ] Implement fallback (if unsure, escalate to human)

[ ] Integrate with ticketing system [ ] Agent outputs: Recommended team + context [ ] Ticketing system: Auto-assign to team based on recommendation [ ] Notification: Team gets alert with full context

[ ] Test end-to-end [ ] Create 100 test tickets (mix of categories) [ ] Agent: Classify + route each ticket [ ] Verify: Tickets reached correct teams [ ] Measure: Speed (target <1 sec per ticket)

Week 4: Deploy and optimize

[ ] Pilot deployment [ ] Roll out to 20% of tickets (A/B test) [ ] Monitor: Routing accuracy, speed, customer satisfaction [ ] Collect feedback: Did teams get the right tickets? [ ] Expected: 80%+ accuracy, <1 sec routing time

[ ] Monitor and iterate [ ] Track: Routing errors (wrong team, missed context) [ ] Identify: Which categories are hard? Improve those [ ] Refine: Update classifier based on mistakes

[ ] Full rollout [ ] Roll out to 100% once confident (accuracy >85%) [ ] Measure business impact: - Time saved per ticket - Team satisfaction (got right tickets) - Customer satisfaction (faster resolution) - Cost savings (human time freed up)

---

Why routing is the hidden blocker

The math: Routing vs response quality

Which matters more?

Scenario A: Agent answers well, routing manual Agent response quality: 95% Routing speed: 30 min (human) Customer resolution: Slow Example: Customer asks: "How do I integrate API?" Agent responds: "Here's the docs + example code" (Response is great!) But: Needs escalation to Engineer Routing: Manual (human decides to send to DevOps) Time: 30 min wait Engineer gets it: Finally, customer resolved (1 hour later)

Net value: 50% (great answer, but slow routing kills it)

Scenario B: Agent answers ok, routing automated Agent response quality: 90% Routing speed: <1 second (agent) Customer resolution: Fast Example: Customer asks: "How do I integrate API?" Agent responds: "Here's the docs + I'm routing to Engineer" (Response is ok, could be better) Routing: Automated (agent instantly sends to DevOps) Engineer gets it: Immediately, customer resolved (5 min later)

Net value: 95% (ok answer, but fast routing wins)

Conclusion: Scenario A (better answer, slow routing): 50% value Scenario B (ok answer, fast routing): 95% value

Which wins? Scenario B Lesson: Speed (routing) > Quality (response) for customer satisfaction

Routing as competitive advantage

Competitor A (no intelligent routing): Agent responds: Yes (fast) Agent routes: Manual (slow, 30 min) Customer resolution: 1-2 hours ROI: 30% (agent helps but human bottleneck kills it)

Your company (intelligent routing agent): Agent responds: Yes (fast) Agent routes: Automated (fast, <1 sec) Customer resolution: 5-15 minutes ROI: 90% (true end-to-end automation)

Competitive advantage: Your customer: Resolved 10x faster Perception: Your agent is amazing Competitor: Can't compete (manual routing kills them) Market share: You win

---

Bottom line: Routing is the missing piece

The shift:

2024-2025: "Deploy agents, they automate responses" Companies obsess over agent accuracy But routing is manual (hidden bottleneck) Real automation: 30%

2026-2027: "Deploy agents WITH intelligent routing" Companies obsess over end-to-end automation Routing is automated (no hidden bottleneck) Real automation: 90%+

Trend: Response automation → End-to-end automation Routing becomes table stakes (not optional) Companies without routing = still mostly manual

Your decision:

Option 1: Deploy agent, leave routing manual Agent works: Yes Routing: Human (30 min per ticket) Automation level: 30% ROI: Limited Status: Chatbot (not real agent)

Option 2: Deploy agent WITH intelligent routing Agent works: Yes Routing: Automated (1 sec per ticket) Automation level: 90%+ ROI: Massive Status: Real agent (true end-to-end automation)

Which wins? Option 2 (obviously) Cost to add routing: R$20-50k (engineering effort) Benefit: 90% time saved on manual routing If 10 support staff: 9 freed up (R$1.8M/year savings) Payback: 1 week ROI: 3600x

Decision: Build intelligent routing now. Cost of waiting: Every day = 10 hours manual routing (R$200/day lost)

→ OpenClaw: Intelligent Agent Routing, Multi-Step Automation, Escalation Logic, End-to-End Workflows

Agent responds fast (good). But human routing (bad). Rescale automated triage: Classify + route + escalate (fully automated). Your agent = partial (answer only). Real automation = routing included. Without routing = chatbot, not agent. Build intelligent routing now. +90% automation, R$1.8M/year savings. ⚡🎯📊