Agent propõe, humano decide. Sua arquitetura está errada?

Agent propõe, humano decide. Sua arquitetura está errada?

Você é founder de SaaS.

Seu SaaS tem agent no WhatsApp (suporte, vendas).

You think: "Agent é autônomo (responde sem revisão humana)."

Or: "Agent é smart enough (treinou com milhões de dados)."

Or: "Human review = lento (agent é mais rápido)."

Then you read news (setembro 2026):

Headline: "AI agents do more of the work in model development, but humans still make the decisions" │ What's happening: ├─ Study: Research team analyzed 769 task logs (real AI agent usage) ├─ Context: Building an AI model (complex, high-stakes work) ├─ Finding 1: AI agents supplied 55% of method proposals ├─ Finding 2: Humans made 85% of final decisions ├─ Finding 3: 33% of tasks wouldn't happen without AI ├─ Key insight: "More agent activity ≠ more autonomy" ├─ What it means: │ ├─ Agent did MORE work (55% of proposals) │ ├─ But agent DECIDED LESS (85% human decisions) │ ├─ This is NOT a bug, it's a FEATURE │ ├─ Reason: Humans need to verify agent proposals (safety, correctness) ├─ The warning: "If your agent is doing 55% of work but making 85% of decisions, something is wrong" ├─ Correct structure: Agent proposes → Human decides ├─ Wrong structure: Agent decides → Human approves (rubber stamp) │

The "Autonomous vs Supervised" Problem

The Two Agent Archetypes

Archetype 1: Fully Autonomous Agent

What it does:

• Customer writes: "Help me open a support ticket"
• Agent: Reads request, processes it, creates ticket
• No human involved
• Response time: <1 second

Why it's attractive:

• Fast (instant response)
• Cheap (no human overhead)
• Scalable (infinite tickets, same cost)

Why it's dangerous:

• Wrong decisions go unchecked
• Customer angry = reputation damage
• No audit trail (who decided what?)
• Compliance issue (who's liable if agent makes mistake?)

Archetype 2: Supervised Agent (Human-in-the-Loop)

What it does:

• Customer writes: "Help me open a support ticket"
• Agent: Reads request, proposes solution, flags for review
• Human: Checks agent's proposal, approves or corrects
• Agent: Executes (with human approval)
• Response time: 2-5 minutes

Why it's attractive:

• Safe (human verifies)
• Auditable (we know who approved)
• Compliant (human is responsible)
• Learnable (agent improves from human feedback)

Why it seems slow:

• Human review = delay
• Costs more (paying human to review)
• Doesn't scale as easily (limited by human review speed)

The Research Finding: Humans Should Still Decide

The study showed:

Agent work: 55% (proposed solutions) Human decisions: 85% (made final call)

Interpretation: Agent proposed 100 solutions (55% of all work) Human accepted 50 of them (50% approval rate) Human rejected or modified 50 (50% rejection rate) Human also made 300 decisions agent didn't propose (human-only decisions)

Conclusion: Agent is good at proposing (saves 55% of thinking time) Agent is NOT good at deciding (85% decision rate = human-dominated) Correct usage: Agent ≈ assistant (proposes), Human ≈ decision-maker (decides)

The warning: "More agent activity doesn't mean more autonomy."

Translation: "Just because agent is doing more work doesn't mean agent should decide more."

Example:

• Agent proposes: "Based on chat history, customer needs refund (probability: 92%)"
• Human reads agent's reasoning, checks account, decides: "Approve refund"
• Result: Agent saved human 5 minutes of review (the 55% work)
• But: Human made the decision (the 85% control)
• This is correct structure

How Most SaaS Get It Wrong

Mistake 1: Autonomous Agent (No Review)

Your setup:

• WhatsApp agent: Handles support tickets autonomously
• Agent criteria: "If customer says 'refund', auto-refund (up to R$ 500)"
• No human review

What happens:

• Customer: "I want a refund" (tests the system)
• Agent: "Approved, refund processing" (instant)
• You discover: Customer was scammer (wanted free service)
• You lost: R$ 500 + reputation (customer complains on Twitter)

Cost of autonomy: R$ 500 (direct) + reputation damage (indirect)

Would human review have prevented it? Yes (human would see "new customer, high refund rate" = suspicious)

Mistake 2: Agent Makes Decisions, Human Rubber-Stamps

Your setup:

• Agent: Proposes solutions to complex problems
• Human: Reviews agent's proposal (takes 30 seconds)
• Human: Clicks "Approve" (rubber-stamp)
• Agent: Executes

What happens:

• Agent proposes: "Offer 20% discount to retain customer"
• Human: Glances at it, clicks "Approve" (trusts agent)
• Agent: Sends discount offer
• Reality: Agent didn't check: Customer already has ongoing discount (agent compounded it)
• Result: Customer gets 40% total discount (unintended)

Cost of rubber-stamping: Lost profit (margin eroded), no learning (agent still makes same mistake)

Would deeper review have prevented it? Yes (human would catch "customer already has discount")

Mistake 3: Agent Decides, Humans Never See It

Your setup:

• Agent: Handles escalations autonomously
• Agent criteria: "If customer is angry (sentiment score >0.8), auto-escalate to manager"
• No human visibility (unless escalated)

What happens:

• 1,000 customers/month interact with agent
• 50 are escalated (5%)
• 950 are handled autonomously (nobody checks them)
• Q: Were those 950 decisions good?
• A: Nobody knows (no audit, no review)
• Problem: Agent makes same mistake 100 times (you never see the pattern)

Cost of invisibility: Systemic failures go undetected (agent keeps making same error, customers keep getting frustrated)

Would human review have prevented it? Yes (human would see pattern after 10 complaints, not 100)

The Correct Architecture: Agent Proposes, Human Decides

Pattern 1: Low-Risk, Routine Decisions (Can Be Autonomous)

Type: Customer asks FAQ question ("What are your business hours?")

Agent does:

• Recognizes FAQ (confidence: 95%+)
• Proposes answer
• Checks confidence score
• If confidence >90%: Execute autonomously (answer directly)
• If confidence <90%: Escalate to human

Human involvement: Minimal (only for low-confidence cases)

Result: 95% handled by agent (fast), 5% by human (safe)

Why it works: Low risk (FAQ is factual, hard to get wrong)

Pattern 2: Medium-Risk Decisions (Propose + Human Approves)

Type: Customer asks for account changes ("Change my email address")

Agent does:

• Recognizes request (confidence: 85%)
• Proposes action: "Change email from X to Y"
• Sends to human queue (no auto-execution)

Human does (2-5 min review):

• Checks: Is this actually the customer? (verify identity)
• Checks: Any red flags? (account status, payment history)
• Decides: Approve or reject
• Provides feedback to agent ("Good proposal, but check account status first")

Agent learns: Next time, check account status before proposing

Result: Agent saves 80% of human review time (proposes well), human controls 100% of decisions

Why it works: Medium risk (identity matters, human should verify)

Pattern 3: High-Risk Decisions (Human Only)

Type: Customer requests refund (money involved, trust matters)

Agent does:

• Recognizes request (confidence: 90%)
• Gathers information: "Order date, reason, amount"
• Proposes decision: "Approve refund (customer in good standing, within 30 days)"
• Sends to human queue (mandatory human review)

Human does (5-10 min review):

• Reads agent's proposal
• Checks: Customer history, refund pattern, account status
• Decides: Approve, partial, or reject
• If reject, explains to customer why (agent doesn't)

Agent doesn't execute: Even if agent proposed approval, agent doesn't refund without human approval

Result: Agent saves 30-40% of human thinking (gathers data), human controls 100% of decisions

Why it works: High risk (money, compliance, reputation = human should decide)

Real Example: Brazilian SaaS Support Agent

The Company

SaaS subscription platform (R$ 100/month, 5,000 customers).

Support tickets/month: 1,000.

Support team: 2 people.

The Problem (Before Agent)

Customer: "I want to cancel my subscription."

Support process:

1. Customer emails
2. Support reads email (5 min)
3. Support: Asks "Why are you canceling?" (back-and-forth, 10 min)
4. Support: Tries to retain (offer discount, 10 min)
5. Support: Processes cancellation (5 min)

Total time: 30 minutes per cancellation.

1,000 tickets/month = 500 hours/month = 2 FTE (full-time equivalent).

The First Attempt (Autonomous Agent)

Agent setup:

• Customer: "I want to cancel."
• Agent: "Processing cancellation..."
• Agent: Cancels subscription (autonomously)
• No human involved

What happened:

• Speed: ✅ Instant (no waiting)
• Cost: ✅ No human time
• Problem: ❌ Customer didn't actually want to cancel (was testing)
• Problem: ❌ Customer was angry (no retention attempt)
• Problem: ❌ Recurring revenue: Lost R$ 100/month (unnecessary churn)

Annual cost: R$ 100 × 12 = R$ 1,200 per accidental cancellation.

If 10% of cancellations are mistakes: R$ 1,200 × (1,000 × 0.1) / 12 = R$ 10K/month revenue lost.

Verdict: Autonomous agent = too risky for revenue-affecting decisions.

The Second Attempt (Rubber-Stamp Agent)

Agent setup:

• Agent: Proposes cancellation
• Human: Clicks "Approve" (30 seconds)
• Agent: Cancels

What happened:

• Speed: ✅ Faster (agent does 80% of work)
• Cost: ⚠️ Still using human (30 sec per ticket)
• Problem: ❌ Human not really reviewing (just clicking)
• Problem: ❌ Agent repeats mistakes (same wrong proposals, human rubber-stamps)
• Problem: ❌ No learning (human never gives feedback to agent)

Verdict: Rubber-stamp = faster, but not actually better (human still involved, agent not improving).

The Third Attempt (Supervised Agent - Correct)

Agent setup:

• Low-risk tickets (FAQ): Agent handles autonomously
• Medium-risk tickets (account changes): Agent proposes, human approves
• High-risk tickets (refunds, cancellations): Agent proposes data, human decides

For cancellation specifically:

Agent does (2 min):

• Recognizes: "Customer wants to cancel"
• Gathers: Order history, payment status, account age
• Proposes: "Approve cancellation OR offer 50% discount to retain"
• Provides reasoning: "Customer in good standing, been with us 18 months"
• Sends to human queue

Human does (5 min):

• Reads: Agent's proposal + reasoning
• Checks: Any additional context (recent support issues? feature request?)
• Decides: "Approve cancellation" OR "Offer retention (discount)"
• Provides feedback: "Good proposal, but next time check if customer contacted support in last 30 days"

Agent learns: Next time, include recent support history in proposal

Result:

• Tickets saved from agent prep: 2 min × 1,000 = 2,000 min/month = 33 hours/month
• Human time for decisions: 5 min × 1,000 = 5,000 min/month = 83 hours/month
• Total: 116 hours/month (was 500 before agent)
• Savings: 384 hours/month = 77% improvement
• Agent made decisions: 0% (human decided)
• Agent proposed decisions: 100% (agent did useful work)

Business impact:

• Before: 2 FTE (R$ 12K/month salary) + tools = R$ 14K/month
• After: 1.5 FTE (R$ 9K/month) + agent (R$ 2K/month) = R$ 11K/month
• Savings: R$ 3K/month = R$ 36K/year
• Plus: Better customer experience (faster responses)
• Plus: Better retention (human retention attempts, not agent auto-cancel)

How to Build the Supervised Agent Architecture

Step 1: Categorize Decisions by Risk

Worksheet:

Decision Type | Risk Level | Current Human Time | Agent Capability | Approval Needed? ───────────────────────────────────────────────────────────────────────────────── FAQ answer | Low | 2 min | High | No (>95% confidence) Account change | Medium | 5 min | Medium | Yes (human approves) Refund request | High | 15 min | Medium | Yes (human decides) Cancellation | High | 10 min | Medium | Yes (human decides)

Rule of thumb:

• Low risk = agent can execute autonomously (if confidence >90%)
• Medium risk = agent proposes, human approves
• High risk = agent gathers info, human decides

Step 2: Design Agent Outputs for Each Risk Level

Low-risk (autonomous):

Agent output to customer: "Here's the answer to your FAQ" No human involved

Medium-risk (propose):

Agent output to human: "Customer wants to change email. Proposed action: Change from X to Y. Confidence: 85%. Customer history: Good standing." Human reviews 2-5 min, approves or rejects

High-risk (decide):

Agent output to human: "Customer wants refund. Data gathered: Order date, amount, reason. Recommendation: Approve (customer in good standing, within 30 days). Risk flags: None." Human reads, makes final decision (approve/reject) Agent doesn't execute without human approval

Step 3: Build Feedback Loop

After human decides:

• System records: What agent proposed vs what human decided
• AI learns: "Agent proposed A, human chose B, here's the difference"
• Agent improves: Next proposal gets closer to human's typical decision

Example:

• Agent proposes: "Refund all R$ 500"
• Human decides: "Refund R$ 250 (partial)"
• System learns: "This customer type warrants partial, not full, refund"
• Next similar case: Agent proposes partial (better match to human decision)

Step 4: Monitor & Adjust

Monthly metrics:

• % of decisions agent makes autonomously (should increase over time)
• % of agent proposals human approves (should increase over time)
• Time saved per ticket (should increase over time)
• Customer satisfaction (should stay same or improve)
• Error rate (should decrease over time)

If agent's approval rate stays low (e.g., 20%):

• Problem: Agent proposals aren't good
• Solution: Retrain agent (improve prompt, add more examples)

If agent's approval rate is high (e.g., 95%):

• Problem: Might be rubber-stamping (human not really reviewing)
• Solution: Spot-check some decisions (human actually reading?)

The Research Insight Applied to Your SaaS

The study found: Humans make 85% of final decisions.

What this means for your agent:

• Your agent should PROPOSE 55% of the work (give good suggestions)
• Your HUMANS should DECIDE 85% of the time (make final calls)
• This is NOT a failure of the agent (it's the correct design)

If your agent is making 85% of decisions:

• Red flag 🚩 (agent is probably making mistakes you don't see)

If your agent is making 55% of decisions, humans the rest:

• Green flag ✅ (this is the ideal architecture)

Common Objections (And Why They're Wrong)

Objection 1: "Human review is slow. Agent is faster."

Reality:

• Agent-only: Fast, but risky (wrong decisions go unchecked)
• Agent + human: Slightly slower, but accurate (wrong decisions caught)
• Trade-off: 10% slower ≠ 100% of the time (good data)

Better answer: "Use supervised agent for risky decisions, autonomous agent for safe ones."

Objection 2: "We can't afford human review. Need to automate everything."

Reality:

• Autonomous agent failures = expensive (customer churn, refunds, reputation)
• Supervised agent = more investment, but protects revenue
• Math: Spend R$ 500/month on human review vs lose R$ 5K/month from agent errors

Better answer: "Supervised agent saves more money long-term (prevents expensive failures)."

Objection 3: "Our agent is good enough. We tested it."

Reality:

• Good in testing ≠ good in production
• Edge cases emerge over time (production has more variety than test data)
• Agent doesn't learn without human feedback

Better answer: "Start supervised, graduate to autonomous (only if evidence supports it)."

Action Plan: Redesign Your Agent

Week 1: Audit Current Decisions

• List all decisions your agent makes
• Categorize by risk (low/medium/high)
• Estimate % of decisions agent makes alone
• Estimate % that should have human review

Week 2: Identify High-Risk Failures

• Pull last 100 agent decisions
• Find mistakes (wrong answer, upset customer, revenue impact)
• Categorize mistakes (could human have prevented it?)
• Calculate cost of each type of failure

Week 3: Design Supervised Architecture

• For high-risk decisions: Move to "propose" mode (no auto-execute)
• Add human approval workflow
• Design feedback loop (human decision → agent learns)
• Set approval SLA (how fast should human approve?)

Week 4: Implement & Measure

• Deploy supervised agent (to 10% of users first)
• Track: % agent proposals approved, time per decision, CSAT
• Compare: Old agent vs new agent (same scenario)
• Decide: Expand or adjust

---

Next Steps: Agent Governance Audit for Your SaaS

At OpenClaw, we help SaaS founders design agent architecture that balances speed and safety:

• Decision categorization (what should agent decide, what should human decide?)
• Approval workflow design (how to make human review fast, not slow)
• Feedback loop setup (how agent learns from human decisions)
• Risk monitoring (catching failures before they hurt revenue)
• Agent-human collaboration (making them work as team, not replacement)

Get a free agent governance audit: Schedule 30 minutes with our AI governance specialist. We'll review your current agent setup, identify where it's making decisions it shouldn't, and show you how to redesign it (agent proposes, human decides).

[Book your free agent governance audit] → [Button: Schedule Now]

---

FAQ

Q: Doesn't supervised agent make my SaaS slower?

A: Only for high-risk decisions (cancellations, refunds). For low-risk (FAQ, status checks), agent can be instant. For medium-risk, adding 2-5 min of human review is worth it (prevents expensive mistakes). The research shows humans should decide 85% of the time anyway—supervised just formalizes this. Speed matters less than correctness for revenue-affecting decisions.

Q: At what point can agent make decisions without human review?

A: Never for high-risk. For medium-risk, only after agent proposal approval rate consistently >85% for 3+ months (meaning agent understands the decision pattern). For low-risk, only if agent confidence score >95% and historical error rate <5%. Use data, not gut feeling.

Q: How do I keep human reviewers engaged (not rubber-stamping)?

A: (1) Spot-check decisions randomly (ask human "why did you approve this?"), (2) Rotate reviewers (prevent boredom), (3) Show agent's reasoning (force human to read, not skim), (4) Use SLA (human must approve/reject in 5 min, or escalate), (5) Train humans (explain why certain decisions matter).

Q: Can I use AI to review AI decisions (instead of humans)?

A: No. That's just deferring the problem (second AI might make same mistakes as first). Humans needed for: (1) Value judgment ("is this decision ethical?"), (2) Customer context ("I know this customer, agent missed something"), (3) Edge cases ("this situation is unusual"). Use humans.

Q: Should I tell customers their issue is being reviewed by AI vs human?

A: Yes. Transparency builds trust. "Your request is being reviewed by our team" is honest (agent is team member now). Hiding AI and pretending it's human = erodes trust later (when they find out). Better: "Your request: Agent prepared recommendation, our team is reviewing now."