Seu agent responde (mas não completa tarefas)

Seu agent responde (mas não completa tarefas)

What just happened (October 2026):

Amazon published multi-turn RL guide for agents:

"Problem: Standard agent training = single-turn (answer one question well)."

"Reality: Real work = multi-turn (sequence of actions, each depends on previous)."

"Example: Expense report filing = (1) Collect receipt, (2) Categorize, (3) Find cost center, (4) Submit. NOT one question = one answer."

"Current training: Works for step 1 (collect receipt). Fails on step 4 (agent doesn't know what happened in step 3)."

"Solution: Multi-turn reinforcement learning (train agent on WHOLE sequence, not individual steps)."

"Result: Agent learns: Step 3 → determines Step 4 success. Agent optimizes entire workflow (not single response)."

What this means for your company:

Current situation (your SaaS agent in production):

Setup (typical agent deployment): Your agent: Support ticket triage agent (WhatsApp) Training: Standard fine-tuning (single-turn) Agent trained on: "Customer says X → respond with Y" Agent learned: Good responses to individual messages

What happens in real work: Customer message 1: "I can't log in" Agent response 1: "Let me help. What email do you use?" ✓ (Good)

Customer message 2: "john@empresa.com"
Agent response 2: "Checking account..." ✓ (Good)

Customer message 3: "I see error 403"
Agent thinking: "This is step 3 in a sequence..."
Agent trained on: Single-turn responses (not sequences)
Agent decision: Tries to answer step 3 in isolation
Agent response 3: "Try clearing cache" ✗ (WRONG - ignores steps 1+2)

Result: Agent fails to complete ticket
Customer: Still can't log in
Agent: Gave unrelated troubleshooting
Ticket status: UNRESOLVED (agent didn't triage, just responded)

Why it failed: Agent trained on: Individual Q&A pairs Agent not trained on: "Sequence of actions leading to resolution" Agent doesn't know: How to use previous context Agent doesn't understand: What outcome we're trying to achieve

Better approach (multi-turn RL): Agent trained on: ENTIRE sequences Sequence 1: (Message 1) → (Response 1) → (Message 2) → (Response 2) → (Message 3) → (Response 3) → RESOLVED Sequence 2: (Message 1) → (Response 1) → (Message 2) → (Response 2) → (Message 3) → (Response 3) → UNRESOLVED Agent learns: Which sequences = RESOLVED Agent learns: Which responses → lead to resolution Agent learns: How to use context (step 3 depends on step 1+2) Result: Agent optimizes for OUTCOME (ticket resolved), not individual response quality

---

The single-turn problem (why standard training fails)

What is single-turn training (and why it's limited)

Standard training = teach good responses, not good sequences

Single-turn fine-tuning:

What it does: Training data: Pairs of (question, good_answer) Example pair 1: Input: "I can't access my account" Output: "I'll help. What email do you use?" Example pair 2: Input: "Error 403 on login" Output: "Error 403 = access denied. Check permissions." Example pair 3: Input: "How do I reset password?" Output: "Go to login page, click 'Forgot password'."

Training goal: Maximize accuracy on individual responses Metric: "Is this response good for this question?" Agent learns: Good response patterns Agent does NOT learn: How to sequence responses

Result in production: Question 1: Agent responds well ✓ Question 2: Agent responds well ✓ Question 3: Agent responds well ✓

But... questions are RELATED (sequence)
Single-turn agent: Treats each independently
Agent misses: Context from Q1 + Q2 affects Q3 answer

Real-world example (expense report): Step 1: "What project is this for?" Single-turn agent: "Tell me the project name" ✓ Good response (if Q1 was isolated)

Step 2: "The project is R&D-2026"
  Single-turn agent: "Got it"
  ✓ Good response (if Q2 was isolated)
  
Step 3: "How much to allocate?"
  Single-turn agent (ignoring steps 1+2): "I need more info"
  ✗ BAD - should know it's for R&D-2026 (from step 2)
  ✗ Should check R&D-2026 cost center (from step 1)
  ✗ Single-turn doesn't use context
  
Step 4: "Can you file it?"
  Single-turn agent: "Sure, which project?"
  ✗ FAILED - Already told us (step 1 + step 2)
  ✗ Agent didn't remember
  ✗ Workflow not completed

The workflow problem (real work = sequences, not Q&A)

Most business tasks = multi-step (single-turn training misses this)

Real-world workflows (not single Q&A):

Example 1: Support ticket triage Step 1: Understand problem (what's broken?) Step 2: Reproduce issue (can agent replicate?) Step 3: Diagnose root cause (why is it broken?) Step 4: Suggest fix (what's the solution?) Step 5: Verify (did it work?) Outcome: Ticket resolved OR escalated

Single-turn training:
  Trains on: "Given problem description → give diagnostic"
  Missing: How step 1 → affects step 2 diagnosis
  Missing: How step 2 → affects step 3 root cause
  Missing: How step 3 → affects step 4 solution
  Missing: How step 4 → affects step 5 verification
  Result: Agent gives step 2 answer without step 1 context
  

Example 2: Expense report filing Step 1: Collect receipt (amount, date, category) Step 2: Assign to project (which project paid for this?) Step 3: Find cost center (which cost center in that project?) Step 4: Add to budget (does budget allow this?) Step 5: Submit for approval (send to approver) Outcome: Expense approved OR flagged for review

Single-turn training:
  Trains on: "Given amount → assign cost center"
  Missing: Which project (step 2) → affects cost center options (step 3)
  Missing: Cost center (step 3) → affects budget check (step 4)
  Missing: Budget status (step 4) → affects approval (step 5)
  Result: Agent picks wrong cost center (ignored project context)
  

Example 3: Sales lead qualification Step 1: Identify prospect (who are they?) Step 2: Assess need (do they need our product?) Step 3: Check budget (can they afford it?) Step 4: Determine timeline (when do they need it?) Step 5: Create opportunity (if qualified) Outcome: Lead qualified OR disqualified

Single-turn training:
  Trains on: "Given prospect → qualify"
  Missing: Company size (step 1) → affects need assessment (step 2)
  Missing: Market segment (step 1) → affects budget assumptions (step 3)
  Missing: Urgency (step 4) → affects sales strategy (step 5)
  Result: Agent misses context (treats each decision in isolation)
  

Common pattern: All workflows: Step N depends on decisions from steps 1-(N-1) Single-turn: Each step = independent Result: Context lost (agent makes bad decisions)

The feedback problem (single-turn can't measure success)

Single-turn training: Measures individual response quality. Multi-turn: Measures workflow outcome.

Training feedback difference:

Single-turn feedback: Question: "What's the error?" Agent response: "Error 403 = access denied" Feedback: "Good response" ✓ OR "Bad response" ✗ Measured: Individual response quality Problem: Doesn't measure workflow success

Example:
  Question: "What's the error?"
  Agent response 1: "Error 403 = access denied"
  Feedback: ✓ Correct (factually accurate)
  
  Agent response 2: "Have you tried restarting?"
  Feedback: ✗ Wrong answer (doesn't address the question)
  
  But what if... response 2 actually SOLVES the problem?
  Then response 2 > response 1 (despite being "wrong" answer)
  Single-turn feedback: Can't measure this
  

Multi-turn feedback: Question: "What's the error?" Agent response: "..." Question: "..." Agent response: "..." Question: "..." Agent response: "..." Final outcome: RESOLVED ✓ OR UNRESOLVED ✗ Measured: Workflow success (did ticket get resolved?)

Example sequence 1:
  Customer: "Error 403"
  Agent: "That's an access error"
  Customer: "How do I fix it?"
  Agent: "Check file permissions"
  Customer: "Thanks, fixed!"
  Outcome: RESOLVED ✓
  Agent learns: This sequence works
  
Example sequence 2:
  Customer: "Error 403"
  Agent: "Have you tried restarting?"
  Customer: "That doesn't help"
  Agent: "Not sure, contact IT"
  Customer: "Never got resolved"
  Outcome: UNRESOLVED ✗
  Agent learns: This sequence fails
  
Multi-turn feedback: Can measure which sequences work
Single-turn feedback: Can't (only measures individual response quality)

---

How multi-turn RL solves it (training on sequences)

What is multi-turn RL (training on outcomes)

Train agent on ENTIRE sequences, measure FINAL outcome

Multi-turn reinforcement learning:

What it does: Training data: SEQUENCES (not individual Q&A pairs)

Example sequence 1:
  Customer: "I can't login"
  Agent: "What email do you use?"
  Customer: "john@empresa.com"
  Agent: "Checking account... I see you tried 5 times. Account locked."
  Customer: "How do I unlock it?"
  Agent: "Click 'Unlock' button in account settings or contact support"
  Customer: "Got it, unlocked!"
  Outcome: RESOLVED ✓
  Reward: +100 (sequence succeeded)
  
Example sequence 2:
  Customer: "I can't login"
  Agent: "Try clearing your cache"
  Customer: "That didn't work"
  Agent: "Try restarting your browser"
  Customer: "Still doesn't work"
  Agent: "I don't know what to do"
  Customer: "Never got helped"
  Outcome: UNRESOLVED ✗
  Reward: -50 (sequence failed)
  

Training goal: Maximize total reward for sequences Metric: "Did this sequence achieve the outcome?" Agent learns: Which actions → lead to successful outcomes Agent learns: How to use context (previous steps affect next) Agent learns: Long-term thinking (sacrifice step 2 for step 5 success)

Key difference: Single-turn: "Is this response good?" Multi-turn: "Did this sequence achieve the goal?"

Real-world impact: Single-turn agent: Optimizes for response quality (individual steps) Multi-turn agent: Optimizes for task completion (entire workflow) Which is more valuable? Obviously the second (completing tasks)

Step dependency (how multi-turn handles context)

Multi-turn RL learns: Decision at step N depends on steps 1-(N-1)

Step dependency in expense report:

Sequence with context: Step 1: "What's the expense amount?" Agent decision: "OK, it's R$500" Context recorded: amount = R$500

Step 2: "What project is this for?"
  Agent decision: "Marketing campaign Q4"
  Context recorded: project = Marketing
  Agent uses context: Step 1 (R$500) + Step 2 (Marketing)
  
Step 3: "Which cost center should this go to?"
  Agent decision: "Marketing cost center 4500"
  Agent used: Step 1 (R$500 is reasonable for Marketing) + Step 2 (Marketing project)
  Agent learns: Step 3 depends on steps 1+2
  
Step 4: "Does the budget allow this?"
  Agent decision: "Yes, Marketing budget has R$20k remaining"
  Agent used: Step 3 (cost center 4500 has R$20k)
  Agent learns: Step 4 depends on step 3
  
Step 5: "Ready to submit?"
  Agent decision: "Yes, submit for approval"
  Outcome: APPROVED ✓
  

What multi-turn RL learns: Step 1 → Step 2: Amount affects project choice? No Step 2 → Step 3: Project affects cost center? YES Step 3 → Step 4: Cost center affects budget? YES Step 4 → Step 5: Budget status affects approval decision? YES Overall: Agent optimizes sequence for APPROVAL (outcome)

Single-turn (no context): Agent trained: "Amount → cost center" Agent doesn't learn: How project affects cost center Agent doesn't learn: Cost center has budget implications Agent picks wrong cost center (no context) Outcome: REJECTED (over budget)

Multi-turn (with context): Agent trained: Full sequence Agent learns: Project → cost center relationship Agent learns: Cost center → budget implications Agent picks correct cost center (uses context) Outcome: APPROVED (in budget)

Credit assignment (learning which decision caused success/failure)

Multi-turn RL solves: Which step caused the final outcome?

Credit assignment problem:

Scenario: Ticket resolved (OUTCOME: SUCCESS) Step 1: Agent asked "What's the problem?" Step 2: Agent said "Let me check the logs" Step 3: Agent found "Database connection timeout" Step 4: Agent suggested "Restart database" Step 5: Customer did it Outcome: RESOLVED ✓

Question: Which step caused success?
Single-turn: Can't answer (doesn't measure sequences)
Multi-turn RL: Analyzes:
  - If we skip step 2 (don't check logs)? Probably fail
  - If we skip step 3 (don't diagnose)? Probably fail
  - If we skip step 4 (don't suggest fix)? Probably fail
  Agent learns: All steps matter
  Agent credits: Steps 2, 3, 4 contributed to success
  

Scenario: Ticket unresolved (OUTCOME: FAILURE) Step 1: Agent asked "What's the problem?" Step 2: Agent said "Try restarting" Step 3: Customer said "That didn't work" Step 4: Agent said "Not sure" Step 5: Ticket closed (unresolved) Outcome: UNRESOLVED ✗

Question: Which step caused failure?
Single-turn: Can't answer
Multi-turn RL: Analyzes:
  - Step 2 was too generic (didn't diagnose)
  - Step 4 gave up (didn't escalate)
  Agent learns: Generic suggestions fail
  Agent credits: Steps 2, 4 caused failure
  Agent updates: "Ask diagnostic questions first (step 2)"
  Agent updates: "Escalate if stuck (step 4)"
  

Result: Multi-turn: Agent learns which decisions matter Single-turn: Agent can't learn (no sequence feedback)

---

Implementation (how to train multi-turn agents)

Step 1: Identify your workflow (what sequence matters?)

Map the steps in your real business process

Workflow identification:

Example 1: Support ticket triage Step 1: Understand problem (customer describes issue) Step 2: Initial diagnosis (ask clarifying questions) Step 3: Root cause (determine why) Step 4: Propose solution (suggest fix) Step 5: Verify (confirm it worked) Outcome: Resolved OR escalated OR needs follow-up

Example 2: Lead qualification Step 1: Identify prospect (who's this company?) Step 2: Assess fit (do they need us?) Step 3: Check budget (can they afford us?) Step 4: Understand timeline (when do they need it?) Step 5: Create opportunity (if qualified) OR disqualify Outcome: Qualified lead OR disqualified

Example 3: Expense approval Step 1: Collect expense details (amount, date, category) Step 2: Assign to project (which project?) Step 3: Assign cost center (which cost center?) Step 4: Check budget (does budget allow?) Step 5: Route for approval (send to approver) Outcome: Approved OR flagged for review

For your agent: Identify: Main workflow List: Sequential steps Define: Success outcome (what's "resolved"?) Define: Failure outcome (what's "unresolved"?)

Step 2: Collect multi-turn training data (sequences, not Q&A pairs)

Record successful AND unsuccessful workflows

Training data collection:

Instead of: (Input: "What's the issue?", Output: "Tell me the issue") (Input: "Error 403", Output: "Access denied error") (Input: "How to fix?", Output: "Check permissions")

Collect: Full successful sequence: Turn 1: Customer: "I can't login" Agent: "What email do you use?" Turn 2: Customer: "john@empresa.com" Agent: "Checking... Account locked after 5 failed attempts" Turn 3: Customer: "How do I unlock?" Agent: "Go to settings → Security → Unlock Account" Turn 4: Customer: "Thanks, worked!" Outcome: RESOLVED ✓ Reward: +100

Full failed sequence:
  Turn 1: Customer: "I can't login"
          Agent: "Try clearing your cache"
  Turn 2: Customer: "Didn't work"
          Agent: "Try a different browser"
  Turn 3: Customer: "Still doesn't work"
          Agent: "Contact our IT team"
  Turn 4: Customer: "Never got help"
  Outcome: UNRESOLVED ✗
  Reward: -50
  

Collection strategy: 1. Record real customer conversations (with permission) 2. Label outcomes (resolved vs unresolved) 3. Assign rewards (based on outcome) 4. Include both success AND failure examples 5. Aim for: 100+ sequences (larger = better training)

Step 3: Train with multi-turn RL (Amazon SageMaker)

Use SageMaker to train on sequences

Training setup (simplified):

Data format: Input: List of sequences Sequence 1: [turn1, turn2, turn3, turn4] → outcome=RESOLVED, reward=100 Sequence 2: [turn1, turn2, turn3, turn4] → outcome=UNRESOLVED, reward=-50 ...

SageMaker training: Algorithm: Multi-turn reinforcement learning Objective: Maximize total reward across sequences Training: Agent learns which actions → lead to high rewards

Key difference from single-turn: Single-turn: Trains on (input → output) pairs Multi-turn: Trains on (input, context, previous_turns → output)

Result: Agent learns: How to use context Agent learns: How to chain actions Agent learns: Long-term thinking (sacrifice short term for outcome)

Time to train: Depends on: Data size, model size, infrastructure Typical: Few hours to few days Cost: $100-1000 (SageMaker training)

Step 4: Test and iterate (measure task completion rate)

Measure: Do workflows actually complete?

Testing/iteration:

Metric (single-turn agent): "Accuracy of individual responses: 85%" But: "Task completion rate: 40%" (Agent answers well but doesn't complete tasks)

Metric (multi-turn agent): "Individual response accuracy: 75% (slight drop)" But: "Task completion rate: 85%" (major improvement) (Agent optimizes for outcomes, not individual response quality)

Iteration: Test agent in production (with real customers) Measure: Task completion rate If low: Collect more training data (more sequences) If low: Add more steps to workflow (agent needs more context) Iterate: Retrain, retest

Success threshold: Task completion rate > 80% (good) Task completion rate > 90% (great) Task completion rate > 95% (excellent)

---

The bottom line: Train for outcomes, not responses

Single-turn = agent answers questions. Multi-turn = agent completes tasks.

Comparison:

Single-turn training: Trains: Agent to answer individual questions well Result: Good responses (for isolated questions) Fails on: Multi-step workflows (ignores context) Task completion: ~40-50% (agent fails on real work) Cost: Low (simple training) Useful for: Chatbots, FAQ answering

Multi-turn RL training: Trains: Agent to complete workflows successfully Result: Agent chains steps (uses context, optimizes outcome) Succeeds on: Multi-step workflows (handles complex tasks) Task completion: ~80-90% (agent completes real work) Cost: Medium (more complex training) Useful for: Support, sales, automation agents

For your SaaS agent: Current: Probably single-turn Problem: Agents fail on real workflows Solution: Switch to multi-turn RL Benefit: Agents actually complete tasks

When to use multi-turn: If agent handles: Multi-step workflows If agent needs: Context from previous steps If agent must: Complete tasks (not just answer questions) = Most SaaS agents (do this)

Implementation effort: Effort: Medium (data collection + retraining) Time: 2-4 weeks (typical) Cost: R$20k-50k (training infrastructure) ROI: Massive (80%+ task completion vs 40%)

Strategic question: Your agent: 40% task completion (single-turn) vs Multi-turn agent: 85% task completion

Which would you rather deploy?
Obviously the second (actually solves customer problems)

Cost to switch: R$30k (effort)
Benefit: Agents that actually work
Payback: Immediate (customers get solved issues)

Strategic decision:

Your support agent: Answers customer questions: ✓ Good Completes support tickets: ✗ FAILS

Why? Trained on: Individual Q&A (single-turn) Missing: Workflow context (multi-turn)

Alternative: Train on: Complete workflows Result: Agent completes tickets Cost: R$30k (training) Benefit: Working agent (priceless)

When will you switch? Now (before competitors do)? Or later (after seeing competition win)?

Amazon proved: Multi-turn RL works Recommendation: Adopt it Timeline: This quarter Impact: 2x task completion rate

→ OpenClaw: Multi-Turn Agent Training, Reinforcement Learning, Multi-Step Workflow Completion, Agent Task Outcomes, Sequence Learning

Your agent answers questions (good). Customers need task completion (better). Multi-turn RL = agents that finish work. Train for outcomes, not responses. 🎯✅📈