Seu agent mente (71%). Adicione "não adivinhe" (20%).

Seu agent mente (71%). Adicione "não adivinhe" (20%).

Você é founder de SaaS.

Seu SaaS tem agent no WhatsApp (suporte ao cliente).

Agent works: Responde perguntas rápido.

BUT: Agent mente às vezes (faz respostas que não sabe).

Example:

Customer: "Qual é o horário de funcionamento no Rio de Janeiro?" Agent: "Aberto de 9h às 17h, segunda a sexta." Reality: Você não tem loja no Rio (agent inventou) Customer: "Vou hoje à noite, obrigado!" Customer arrives: Loja não existe (rage)

You think: "Agent alucinando é normal (vem com LLM)."

Or: "Não há solução (problema é estrutural do AI)."

Then you read news (setembro 2026):

Headline: "Calling the AI bluff: Adding 'Do not guess' cut made-up fields from 71% to 20%" │ What's happening: ├─ Experiment: Researcher tested AI with financial data extraction ├─ Task: Extract fields from documents ("What's the account number?") ├─ Baseline: AI answered all questions (even when answer wasn't in document) ├─ Hallucination rate: 71% (AI made up answers 71% of the time) ├─ The fix: Add one instruction: "Do not guess. If you don't know, say 'I don't know.'"
├─ Result: Hallucinations dropped to 20% (51 percentage point improvement) ├─ Key insight: AI was CAPABLE of being honest, just wasn't INSTRUCTED to be ├─ What this means: │ ├─ Hallucination is often a prompt problem, not a model problem │ ├─ Better instructions = more honest AI │ ├─ "Do not guess" is shockingly effective │ ├─ Most founders don't use this instruction (they should) │

The Hallucination Problem (And Why It Kills SaaS)

What is hallucination?

Definition: AI generates plausible-sounding information that's not true.

Example scenarios:

Agent: "Your account balance is R$ 5,000." (Actually R$ 2,000) Agent: "We have that product in stock." (Out of stock) Agent: "Your order ships Monday." (Will ship Wednesday) Agent: "I can process your refund now." (Refund requires manager approval)

Why it happens: LLMs are trained to generate text that "sounds right," not text that's "actually true."

Think of it like autocomplete on your phone:

• Phone learns: "Good morning" usually followed by "I hope you're having a great day"
• Phone suggests that ending (sounds natural)
• Doesn't matter if you actually hope that (the pattern is what matters)

Same with LLMs:

• Model learns: "Question about product stock" usually followed by "Yes, we have it"
• Model generates: "Yes, we have it" (sounds natural for that context)
• Doesn't matter if inventory system says "out of stock" (pattern is what matters)

The Business Cost of Hallucination

Scenario 1: Customer Support

Customer asks: "Can I return within 30 days?" Agent (hallucinating): "Yes, 30-day return policy." Reality: 14-day policy (agent made it up) Outcome: Customer buys, realizes it's 14 days, feels betrayed Cost: Chargeback ($50) + reputation damage (negative review) + support time ($100) Total: $150 per hallucination

Scenario 2: Sales Agent

Prospect asks: "Do you integrate with Salesforce?" Agent (hallucinating): "Yes, full Salesforce integration out of the box." Reality: Integration requires custom development ($5K) Outcome: Prospect expects free integration, discovers cost, walks away Cost: Lost deal ($50K annual value) Total: $50K per hallucination

Scenario 3: Technical Support

Customer: "How do I reset my password?" Agent (hallucinating): "Go to Settings → Account → Reset Password." Reality: Reset is done via email (no such menu) Outcome: Customer can't reset, stuck, escalates Cost: Escalation ($50 human time) + customer frustration + support backlog Total: $50 per hallucination

Math on hallucination cost:

1,000 customer interactions/month 71% hallucination rate (baseline) = 710 wrong answers/month

If 10% of hallucinations cause damage: 710 × 0.10 = 71 damaged interactions/month

Average cost per damage: $100 Total cost: 71 × $100 = $7,100/month

Annual: $85,000 in damages from hallucination

With "Do not guess" instruction: 20% hallucination rate = 200 wrong answers/month 200 × 0.10 = 20 damaged interactions 20 × $100 = $2,000/month = $24,000/year

Savings: $85K - $24K = $61,000/year (just by adding one instruction)

The Experiment: What Changed?

The Setup

Task: Extract financial data from documents

Examples of fields:

• Account number
• Transaction date
• Balance amount
• Fee description

Key detail: Some documents had fields, some didn't.

The Baseline (No "Do Not Guess" Instruction)

Agent behavior:

• Question: "What's the account number?"
• Document: (doesn't mention account number)
• Agent response: (generates plausible-sounding account number like "ACC-123456")
• Result: HALLUCINATION (made it up)

Hallucination rate: 71%

Translation: Out of 100 questions on missing fields, agent answered 71 of them (made up 71 answers).

The Fix: One Instruction

Instruction added to prompt:

"Do not guess. If the information is not in the document, respond with: 'Information not provided.'"

That's it. Nothing fancy, no fancy architecture, no retraining.

The Result (With "Do Not Guess" Instruction)

Agent behavior:

• Question: "What's the account number?"
• Document: (doesn't mention account number)
• Agent response: "Information not provided."
• Result: HONEST (admitted it doesn't know)

Hallucination rate: 20%

Translation: Out of 100 questions on missing fields, agent answered 20 of them (misunderstandings, not full hallucinations).

The improvement: 71% → 20% = 51 percentage point reduction (72% fewer hallucinations).

Why This Works: The Psychology of AI

The Default Assumption

What AI "thinks" by default:

User asked a question ↓ User expects an answer ↓ I should provide an answer (not say "I don't know") ↓ If I don't have the exact answer, I'll infer/guess (because empty response = bad) ↓ Generate plausible answer

Result: Hallucination (because AI defaulted to "answer > honesty")

With "Do Not Guess" Instruction

What AI "thinks" now:

User asked a question ↓ User expects an answer ↓ BUT: User explicitly said "Do not guess" ↓ So "I don't know" is an acceptable answer ↓ If I don't have info, I'll say so (not guess) ↓ Generate honest response

Result: Honesty (because AI was explicitly told that's the right choice)

The Deeper Insight

Hallucination is not always a model limitation, it's a prompt problem.

Model is capable of being honest (as proven by the 20% result).

Model just needed permission (explicit instruction).

This is huge for founders: You don't need a better model, you need better instructions.

How to Apply This to Your Agent

Step 1: Identify Where Your Agent Hallucinates

Common hallucination areas in SaaS agents:

1. Product/Feature Questions

Customer: "Do you have this feature?" Agent: "Yes, we have it." (Actually, it's on the roadmap, not released) Hallucination: Feature capability claimed but not real

2. Pricing/Policy Questions

Customer: "What's your refund policy?" Agent: "30-day money back guarantee." (Actually, 14 days) Hallucination: Policy details made up

3. Integration Questions

Customer: "Do you integrate with tool X?" Agent: "Yes, native integration." (Actually, Zapier workaround only) Hallucination: Integration capability overstated

4. Status/Data Questions

Customer: "What's my current usage?" Agent: "You've used 500 credits." (Actually, I don't have access to customer data) Hallucination: Made-up data

5. Escalation/Process Questions

Customer: "Can you process a refund?" Agent: "Yes, refund processing now." (Actually, requires manager approval) Hallucination: Authority/capability overstated

Step 2: Add "Do Not Guess" Instructions

For each hallucination area, add explicit instruction:

Template:

"For [area], do not guess. If you don't know [specific condition], respond with: '[Honest response]'"

Examples:

For Product Questions:

Instruction: "For feature questions, do not guess. Only mention features that are documented in our feature list. If a feature is not on the list, respond with: 'That feature is not currently available. Let me check our roadmap.'"

For Pricing Questions:

Instruction: "For pricing and policy questions, do not guess. Only state information from our official pricing page. If you're unsure, respond with: 'Let me get the exact details from our team.'"

For Integration Questions:

Instruction: "For integration questions, do not guess. Only mention integrations on our official integration list. If an integration is requested but not listed, respond with: 'We don't have a native integration, but we can help you build one with our API.'"

For Data Access Questions:

Instruction: "For customer data requests (usage, account info), do not guess or make up numbers. If you don't have direct access, respond with: 'I don't have access to your account details. Let me connect you with our support team.'"

For Escalation Questions:

Instruction: "For requests that require approval (refunds, cancellations), do not guess about authority. Respond with: 'I'll need to escalate this to our specialist who can authorize that.'"

Step 3: Test the Changes

Before/After comparison:

Scenario: Product Feature Question

Before (no instruction):

Customer: "Do you have API rate limiting controls?" Agent: "Yes, we have full rate limiting controls and custom limits." Reality: Rate limiting exists, but custom limits are coming next month Result: Customer expects feature, disappointed when it's not there

After (with instruction):

Customer: "Do you have API rate limiting controls?" Agent: "We have standard rate limits. Custom limits are coming soon. Let me connect you with our API team for details." Reality: Honest, sets expectations, offers escalation Result: Customer informed, satisfied, no surprise

Scenario: Pricing Question

Before:

Customer: "Is there a discount for annual plans?" Agent: "Yes, we offer 20% discount for annual billing." Reality: We offer 15% (agent made up the number) Result: Customer signs up expecting 20%, gets invoiced 15%, angry

After:

Customer: "Is there a discount for annual plans?" Agent: "We do offer annual discounts. Let me get the exact percentage from our pricing specialist to make sure you have the current rate." Reality: Honest, careful, escalates for accuracy Result: Customer gets correct info, happy

Step 4: Build a "Do Not Guess" Library

Create a document for your team:

markdown

Agent Honesty Instructions

Areas Where Agent Must NOT Guess

1. Feature Availability

   • Rule: Only mention features in official feature list
   • If unsure: "That feature is not on our current list"

2. Pricing & Billing

   • Rule: Only quote from pricing page
   • If unsure: "Let me get the exact pricing"

3. Integrations

   • Rule: Only mention integrations in official list
   • If unsure: "Let me check our integration partners"

4. Customer Data

   • Rule: Never make up account info
   • If needed: "I don't have direct access, let me get our team"

5. Authorization

   • Rule: Never claim authority for approvals
   • If requested: "I'll escalate this to who can approve it"

6. Timelines

   • Rule: Only state confirmed dates/timelines
   • If unsure: "Let me confirm the exact timeline"

Template Responses for "I Don't Know"

• "I don't have that information. Let me connect you with [specialist]."
• "That's outside my knowledge base. I'll escalate this."
• "I'm not certain about that. Let me verify with our team."
• "That's a great question. Let me research and get back to you."
• "I don't want to guess. Let me get the official answer."

Real Example: Brazilian SaaS Support Agent

The Company

SaaS platform (accounting software), 500 customers, 200 support requests/month via WhatsApp.

The Problem (Before "Do Not Guess")

Request 1:

Customer: "Do you support currency conversion?" Agent: "Yes, we support 50+ currencies with automatic conversion." Reality: We support currency storage, but no automatic conversion Outcome: Customer buys, discovers limitation, requests refund Cost: $100 refund + time

Request 2:

Customer: "What's the refund policy?" Agent: "30-day money back guarantee, no questions asked." Reality: 14-day with approval (not automatic) Outcome: Customer demands refund on day 25, agent promised 30 days Cost: $500 refund + dispute resolution

Request 3:

Customer: "Can you process a refund for me?" Agent: "Sure, processing now." Reality: Agent has no refund authority (only managers do) Outcome: Customer thinks it's processing, it's not, customer angry Cost: $200 escalation cost + reputation damage

Monthly cost of hallucinations: ~$800-1,000

Annual cost: ~$10K-12K

The Solution (After "Do Not Guess")

Updated agent instructions:

FOR FEATURES:

• Only mention features in official feature list
• If customer asks about unreleased feature: "That feature is on our roadmap. Let me connect you with our product team."

FOR REFUNDS:

• Never claim authority
• Always direct to: "I'll connect you with our refund specialist."
• Policy to mention: "Our policy is 14 days with manager approval."

FOR POLICIES:

• Only state what's on the website
• If unsure: "Let me get the exact details from our compliance team."

FOR TECHNICAL QUESTIONS:

• If outside your knowledge: "I want to give you accurate info. Let me connect you with our technical team."

Results After Implementation

Week 1: Agent starts using "Do Not Guess" instructions

Metrics:

• Hallucination rate: 71% → 30% (first week, still learning)
• Escalations: 20% → 40% (more honest = more escalations, initially)
• Customer satisfaction: 3.2 → 3.5 (customers prefer honesty over wrong answers)

Week 4: Agent refined (team adjusted escalation workflow)

Metrics:

• Hallucination rate: 30% → 18% (agent improving)
• Escalations: 40% → 28% (more efficient, agent learning)
• Customer satisfaction: 3.5 → 4.1 (honesty + quick escalation = happy)
• Support time: 5 min → 4 min (agent not wasting time guessing)

Monthly cost of hallucinations: $800 → $150 (savings: $650/month)

Annual savings: ~$7,800 (just from adding one instruction)

Common Objections (And Why They're Wrong)

Objection 1: "If agent always says 'I don't know,' it looks dumb."

Reality:

• Honest "I don't know" > dishonest "yes"
• Customer prefers accurate no > wrong yes
• "Let me get you the right answer" sounds professional, not dumb

Better answer: "Honesty builds trust. Trust builds loyalty. That's the opposite of dumb."

Objection 2: "More escalations = slower support."

Reality:

• Initial escalation increase (agent learning)
• Escalations decrease as agent learns (team adjusts rules)
• Fewer wrong answers = fewer escalations later (customer satisfaction)

Math:

Before "Do Not Guess":

• 100 requests
• 71 hallucinations (wrong answers)
• 20 escalations (customer upset, demands escalation)
• Total escalations: 20

After "Do Not Guess":

• 100 requests
• 20 honest "I don't know" (agent doesn't guess)
• 20 escalations (for those 20)
• Total escalations: 20 (same!)
• But now escalations are for right reasons (not cleanup)

Better answer: "Escalations go to right place (not to fix agent mistakes)."

Objection 3: "This is just telling agent to be careful. That's obvious."

Reality:

• It IS obvious to humans
• NOT obvious to LLMs (trained on next-token prediction, not truthfulness)
• Explicit instruction changes behavior dramatically (71% → 20%)
• Most founders don't do this (untapped improvement)

Better answer: "Obvious to us doesn't mean obvious to AI. Results speak: 51pp improvement from one instruction."

The Ripple Effect: What Happens After You Fix Hallucination

Customer Satisfaction Improves

Before: Agent says "yes" (wrong) → customer angry After: Agent says "I'll check" (honest) → customer trusts Result: NPS improves (customers trust agent more)

Support Becomes Predictable

Before: Random wrong answers → customer complaints → team reacts After: Agent honest → escalations are intentional → team proactive Result: Ops efficiency improves (less firefighting)

Agent Becomes Valuable

Before: Agent as liability (makes things worse with hallucinations) After: Agent as filter (honest, routes right, saves human time) Result: Agent ROI improves (measurable value)

Brand Trust Grows

Before: Customers discover inconsistencies (agent promised 30 days, policy is 14) After: Customers experience consistency (agent honest, delivers what promised) Result: Word-of-mouth improves (customers recommend you)

Action Plan: Implement "Do Not Guess" This Week

Day 1: Audit

• List 5 areas where your agent hallucinates most
• Estimate cost of each hallucination
• Rank by business impact

Day 2: Write Instructions

• For top 3 areas, write "Do Not Guess" instructions
• Use templates provided above
• Be specific (not vague)

Day 3: Test

• Add instructions to agent prompt
• Run 50 test conversations (same scenarios as before)
• Measure: Hallucination rate before/after

Day 4-7: Deploy & Monitor

• Deploy to 25% of traffic (gradual)
• Monitor: Hallucination rate, escalation rate, CSAT
• Adjust instructions (if needed)
• Roll to 100% (if metrics improve)

Week 2: Optimize

• Review escalations (why did agent say "I don't know"?)
• Refine instructions (make agent smarter about when to escalate)
• Document learnings (create "Do Not Guess" library for team)

---

Next Steps: Prompt Engineering Audit for Your Agent

At OpenClaw, we help SaaS founders eliminate hallucination through prompt optimization:

• Hallucination audit (where's your agent lying?)
• "Do Not Guess" instruction design (specific to your use cases)
• Prompt refinement (make agent honest without sacrificing speed)
• Escalation workflow improvement (so escalations are efficient)
• ROI measurement (quantify cost savings from reduced hallucination)

Get a free hallucination audit: Schedule 30 minutes with our prompt engineering specialist. We'll review your current agent conversations, identify your top 3 hallucination areas, and show you exactly how to fix them (just like the "Do not guess" example).

[Book your free hallucination audit] → [Button: Schedule Now]

---

FAQ

Q: Will "Do not guess" slow down my agent?

A: No. Agent responds faster with "I don't know" than making up wrong answers. No hallucination = faster response. Plus, agent doesn't waste time generating plausible-sounding fiction. Win-win.

Q: Should I tell customers that escalations are intentional?

A: Yes. Transparency builds trust. "Our agent is careful. If unsure, they escalate to our specialist to get you the right answer" = customers appreciate honesty. Makes your support look professional (not lazy).

Q: Can I use "Do not guess" for all questions, or just specific areas?

A: Specific areas (start with high-impact). Don't tell agent "never guess" for everything (customer gets frustrated). Instead: "For [feature/pricing/data], be extra careful. Don't guess." Targeted is better.

Q: What if my agent still hallucinates after "Do not guess"?

A: (1) Check your instruction clarity (is it specific enough?), (2) Check model quality (is your LLM strong enough?), (3) Add examples (show agent what good responses look like), (4) Use multi-step verification (have agent check against knowledge base). If still failing, might be model limitation, not prompt.

Q: How often should I review my "Do not guess" instructions?

A: Monthly (as you add features, policies change). Add new instructions as hallucinations emerge. Review customer feedback (complaints often reveal new hallucination areas). Prompt engineering is continuous, not one-time.