Seu support pula entre 5 portais (HEMA cortou pra 1)

Seu support pula entre 5 portais (HEMA cortou pra 1).

Você é CTO/CEO de SaaS.

Seu support team tem problema.

The problem (probably):

Customer: "Como faço pra resetar minha senha?" ↓ Support agent (first instinct): "Let me find that info" ├─ Opens browser ├─ Opens portal #1 (company wiki) ├─ Searches "password reset" ├─ Not there ├─ Tries portal #2 (service catalog) ├─ Searches "password" ├─ Finds something, but outdated ├─ Tries portal #3 (IT documentation) ├─ Finally finds answer (after 10 minutes) ↓ Support agent: "Your password reset link is in your email" ├─ (Should have taken 30 seconds) ├─ (Took 10 minutes instead) ├─ (Customer waited on chat the whole time) ↓ Customer: "Why did that take so long?" Customer: "I'm switching to competitor" ↓ You: "Why is my support time so high?" │ === THE PROBLEM: PORTAL-HOPPING === │ Your support team: ├─ Has access to 5+ information sources ├─ Wiki (internal documentation) ├─ Service catalog (products/services) ├─ IT portal (policies, procedures) ├─ Email/Slack history (previous answers) ├─ Knowledge base (public-facing articles) │ But: ├─ They're in 5 different places ├─ Info is duplicated (same answer in 3 portals) ├─ Info is outdated (wiki not updated in 6 months) ├─ Info is conflicting (portal #1 says X, portal #2 says Y) ├─ Support agent has to search all 5 to find answer ├─ Customer waits 10 minutes for answer that exists (but is hidden) │ Result: ├─ Customer satisfaction: Low ├─ Support response time: High ├─ Support team burnout: High ├─ Operating cost: High ├─ Churn: High │ === THE SOLUTION: UNIFIED AGENT (HEMA'S APPROACH) === │ Yesterday: ├─ Customer asks question ├─ Support agent searches 5 portals (10 minutes) ├─ Support agent finds answer (maybe) ├─ Support agent responds │ Today (with agent): ├─ Customer asks question ├─ Agent searches unified knowledge layer (2 seconds) ├─ Agent finds answer (always, because all portals are unified) ├─ Agent responds instantly (or support agent does, but with answer ready) │ === WHAT HEMA BUILT === │ HEMA (100-year-old Dutch retailer): ├─ Problem: Engineers portal-hopping (5+ sources) ├─ Solution: Built knowledge layer on Amazon Bedrock + MCP ├─ Result: Instant answers (no more hopping) │ Key implementation: ├─ MCP (Model Context Protocol): Unified access to all data sources ├─ Amazon Bedrock: LLM engine (Claude, other models) ├─ Knowledge layer: Single place to ask questions ├─ Agent: Searches knowledge layer, returns answer │

Yesterday, you read:

AWS Blog: "From portal-hopping to instant answers: HEMA's journey with MCP and Amazon Bedrock."

Key insight: "HEMA engineers were wasting hours searching disconnected wikis, service catalogs, and IT portals. They built a unified knowledge layer using MCP (to connect all sources) and Amazon Bedrock (to run the LLM). Result: Instant answers to any question."

Translation: HEMA solved portal-hopping by unifying all data sources behind a single agent interface. Your support team can do the same.

What this means (for your business):

=== THE HEMA MODEL === │ Before (portal-hopping): ├─ Support agent gets question ├─ Searches wiki (not there) ├─ Searches service catalog (outdated) ├─ Searches IT portal (found it, but took 10 minutes) ├─ Responds to customer (delayed) │ After (unified agent): ├─ Support agent gets question ├─ Asks unified agent (behind the scenes) ├─ Agent searches ALL sources simultaneously (via MCP) ├─ Agent finds answer in 2 seconds ├─ Support agent responds instantly (or agent responds directly) │ === WHAT HEMA SAVED === │ Time per question: ├─ Before: 10 minutes (portal-hopping) ├─ After: 30 seconds (unified agent) ├─ Saving: 9.5 minutes per question │ Questions per day (per agent): ├─ Before: 4 questions (10 min each = 40 min productive work) ├─ After: 40 questions (30 sec each = 20 min productive work, 40 min other tasks) ├─ Improvement: 10x more questions handled │ Customer satisfaction: ├─ Before: Customer waits 10 minutes ├─ After: Customer gets instant answer ├─ Improvement: Massive (wait time drops from minutes to seconds) │ Operating cost: ├─ Before: Need 20 support agents for 80 questions/day ├─ After: Need 2 support agents for 80 questions/day (agent handles rest) ├─ Saving: 18 support agents = R$500k-1M/year (salaries, benefits) │ === THE TECHNOLOGY (MCP) === │ MCP = Model Context Protocol (new standard for connecting data sources to LLMs) │ What it does: ├─ Connects LLM to data sources (wikis, databases, APIs) ├─ Allows LLM to search/access data in real-time ├─ Standardizes how data is exposed to LLM │ Example: ├─ LLM: "What's the password reset procedure?" ├─ MCP: Searches wiki, service catalog, IT portal simultaneously ├─ MCP: Finds answer in service catalog ├─ MCP: Returns answer to LLM ├─ LLM: "Password reset procedure is..." │ Why this matters: ├─ Before MCP: You had to build custom integrations (wiki → API, service catalog → API, etc) ├─ After MCP: Standard protocol (any data source can expose via MCP) ├─ Result: Faster to build, easier to maintain, more flexible │

---

Como HEMA fez (passo a passo)

1. Unified knowledge layer (combining data sources)

=== THE PROBLEM === │ Data sources (disconnected): ├─ Wiki (internal docs) ├─ Service catalog (products/services) ├─ IT portal (policies) ├─ Email/Slack (previous answers) ├─ Knowledge base (public articles) │ Each source: ├─ Different format (markdown, JSON, HTML, plain text) ├─ Different update schedule (some updated weekly, some never) ├─ Different access method (some read-only, some searchable) ├─ Different quality (some curated, some messy) │ Result: ├─ LLM doesn't know all sources exist ├─ LLM can't search them simultaneously ├─ LLM gives incomplete/outdated answers │ === THE SOLUTION === │ Unified knowledge layer: ├─ Connect ALL sources via MCP ├─ Index all content (single search) ├─ Deduplicate content (same answer in 3 places → appears once) ├─ Update metadata (when was this last updated?) ├─ Expose via LLM (through Amazon Bedrock) │ Result: ├─ LLM has single source of truth ├─ LLM can search all sources simultaneously ├─ LLM gives complete/current answers │ === HOW HEMA DID IT === │ Step 1: Connect data sources ├─ Wiki → MCP connector (reads wiki, exposes via protocol) ├─ Service catalog → MCP connector (reads service data) ├─ IT portal → MCP connector (reads policies) ├─ Email/Slack → MCP connector (reads conversation history) ├─ Knowledge base → MCP connector (reads public articles) │ Step 2: Unify data ├─ All sources now speak MCP protocol ├─ LLM can access any source ├─ LLM searches all sources simultaneously │ Step 3: Run LLM ├─ Use Amazon Bedrock (hosted LLM service) ├─ Give LLM access to MCP layer ├─ Ask questions → LLM searches all sources → instant answers │

2. Agent architecture (who responds to customer)

=== TWO RESPONSE MODELS === │ Model 1: Agent responds directly (fully automated) ├─ Customer: "How do I reset password?" ├─ Agent: Searches knowledge layer (via MCP) ├─ Agent: Finds answer ├─ Agent: Responds to customer directly ├─ Support team: Not involved (freed up) │ Model 2: Support agent uses agent as assistant ├─ Customer: "How do I reset password?" ├─ Support agent: Asks agent (internal tool) ├─ Agent: Searches knowledge layer (via MCP) ├─ Agent: Finds answer (returns in 2 seconds) ├─ Support agent: Copy/paste answer to customer (looks personalized) ├─ Support agent: Also adds context ("I've helped 100 people with this...") │ === HEMA CHOSE MODEL 2 === │ Why? (our guess, not stated in article) ├─ Support team maintains quality (human touch) ├─ Avoid 100% automation (customers prefer human contact) ├─ Use agent as copilot (assistant, not replacement) ├─ Still frees up support team (no more portal-hopping) │ === THE WORKFLOW === │ Customer asks question (via chat, email, phone) ↓ Support ticket created ↓ Support agent assigned ↓ Support agent: "Let me check our system" ↓ Agent (via MCP): Searches all knowledge sources ├─ Wiki: Searched ├─ Service catalog: Searched ├─ IT portal: Searched ├─ Email history: Searched ├─ Knowledge base: Searched ↓ Agent returns: "Here's the answer (found in service catalog, updated 2 days ago)" ↓ Support agent reviews answer (2 seconds, instead of 10 minutes searching) ↓ Support agent sends to customer (personalized with context) ↓ Customer: "Wow, that was fast!" │

3. Implementation challenges (what HEMA solved)

=== THE CHALLENGES === │ Challenge 1: Data quality ├─ Problem: Some sources have outdated info ├─ Example: Wiki says "password reset takes 24 hours" (actually instant) ├─ Risk: Agent gives outdated answer ├─ Solution: HEMA curated data (removed outdated info, flagged sources with dates) │ Challenge 2: Access control ├─ Problem: Some data is confidential (salaries, policies) ├─ Risk: Agent exposes confidential data ├─ Solution: HEMA restricted MCP access (only connect public sources to LLM) │ Challenge 3: Context relevance ├─ Problem: LLM might find 100 documents (which one is most relevant?) ├─ Risk: Agent returns wrong answer ├─ Solution: HEMA ranked search results (most recent, most viewed first) │ Challenge 4: LLM hallucinations ├─ Problem: LLM might make up answer (not in knowledge base) ├─ Risk: Agent gives wrong answer ├─ Solution: HEMA configured LLM to cite sources ("Answer found in service catalog, updated 2 days ago") │ === HOW HEMA ADDRESSES THESE === │

1. Data governance ├─ Assign owner to each data source (wiki owner, catalog owner, etc) ├─ Owner audits data quarterly (removes outdated, flags uncertain) ├─ Version control (know when data was last updated) │
2. Access control ├─ Classify data (public vs confidential) ├─ Only expose public data to LLM (via MCP) ├─ Keep confidential data in separate systems │
3. Search ranking ├─ Recent > old ├─ Frequently used > rarely used ├─ Exact match > fuzzy match │
4. LLM configuration ├─ Prompt: "Only answer if you found in knowledge base. If not found, say 'I don't know'" ├─ Temperature: Low (more factual, less creative) ├─ Citations: "Source: wiki (updated 3 days ago)" │

---

Por que seu support ainda pula entre portais (e como parar)

The cost of portal-hopping

=== THE MATH === │ Your support team: ├─ 10 agents ├─ 8 hours/day each = 80 agent-hours/day ├─ Average question takes 10 minutes (including portal-hopping) ├─ Questions per day: (80 hours × 60 min) / 10 min = 480 questions/day │ With unified agent: ├─ 10 agents ├─ 8 hours/day each = 80 agent-hours/day ├─ Average question takes 1 minute (agent returns answer instantly) ├─ Questions per day: (80 hours × 60 min) / 1 min = 4,800 questions/day ├─ Or: 10 agents handle 4,800 questions (instead of 480) │ Alternatively (keep 480 questions/day output, reduce staff): ├─ Need 1 agent (instead of 10) to handle 480 questions/day ├─ Saving: 9 agents = R$450k-900k/year (salaries, benefits, equipment) │ Cost of NOT doing this: ├─ Customer wait time: 10 minutes (instead of 1 minute) ├─ Customer frustration: High ├─ Churn: 5-10% of customers leave due to slow support ├─ Lost revenue: If average customer = R$5k/year, losing 10% = R$25k/year (for 500 customers) │ === THE DECISION === │ Implement unified agent: R$50k-100k (engineering, setup, MCP connectors) Save per year: R$450k-900k (staff reduction) + R$25k-100k (reduced churn) ROI: 5-10x in year 1 │ Don't implement: Keep paying for inefficiency ├─ Support staff wasting 9 minutes per question ├─ Customers frustrated (waiting 10 minutes) ├─ Churn increasing ├─ ROI: Negative (you're paying extra for worse service) │

Why most companies haven't done this (yet)

=== THE BARRIERS === │ Barrier 1: Technical complexity ├─ "MCP sounds complicated" ├─ "We don't have data engineers" ├─ "We don't know how to connect our systems" │ Barrier 2: Organizational ├─ "Our data is all over the place (no single owner)" ├─ "Wiki owner doesn't want to change format" ├─ "Service catalog owner has different priorities" ├─ "IT team doesn't want to expose their portal" │ Barrier 3: Concerns ├─ "Will LLM expose confidential data?" ├─ "Will agent give wrong answers?" ├─ "Will this replace support team?" ├─ "Do we really need this?" │ === WHY HEMA COULD DO IT === │ HEMA advantages: ├─ Resources (100-year company, budget available) ├─ Data (already existed, just needed to connect) ├─ Support (AWS partnership, technical guidance) │ What's different now: ├─ MCP is now standard (easier to adopt) ├─ Amazon Bedrock exists (no need to manage LLM) ├─ Open weight models exist (cheaper, faster) ├─ Tooling is mature (less risk) │ === HOW SMALLER COMPANIES CAN DO IT === │ Start small: ├─ Connect ONE data source (wiki) ├─ Connect to ONE LLM (Claude, via Bedrock) ├─ Build simple agent (asks wiki, returns answer) ├─ Measure impact (time saved per question) ├─ Expand (add more sources) │ Timeline: ├─ Week 1-2: Set up Bedrock, MCP connector to wiki ├─ Week 3-4: Build simple agent interface ├─ Week 5: Test with support team ├─ Week 6: Launch (use agent as assistant for 1 support team member) ├─ Week 7-8: Rollout to all support team │ Cost: ├─ Engineering time: R$20k-30k (depends on team) ├─ AWS/Bedrock: R$500-1000/month (depends on usage) ├─ Total: R$30-40k for proof-of-concept │ ROI: ├─ Time saved: 1 support agent (R$50k-100k/year) ├─ Reduced churn: R$10-20k/year ├─ Payback: 3-6 months │

---

Conclusão

Simple verdade:

HEMA proved portal-hopping is solved by unified agents (MCP + LLM). Your support team is probably doing same thing (searching 5 portals for every answer). You should build unified agent (like HEMA) or accept paying extra for inefficiency.

3 facts:

1. Portal-hopping costs time (and money). Support agent searches 5 portals = 10 minutes/question. Unified agent = 1 minute/question. 9 minutes saved per question × 480 questions/day = 4,320 minutes = 72 hours/day = need 9 extra agents. HEMA solved this by unifying data sources behind agent.
2. MCP makes this easier (now). 5 years ago, connecting data sources meant custom integrations (expensive, fragile). Now MCP is standard (AWS supports it, open-source tools exist). Easier to build = more companies will adopt = this becomes table-stakes.
3. Time to implement is short. HEMA case study not available, but reasonable estimate: 4-8 weeks for basic version, 3-6 month ROI. If you wait, competitor implements first (captures support cost advantage, spends savings on product development). You fall behind.

3 action items (this week):

1. Audit your support workflow (How many portals does support agent search per question? Is info duplicated? Is any outdated? If yes to any, you have problem.)
2. Calculate cost of portal-hopping (Measure: Average time per question today. Project: What if agent reduced this by 90%? How many staff could you reduce? What's the annual saving?)
3. Decide: Build or hire (Option A: Build unified agent yourself (4-8 weeks, R$30-40k). Option B: Hire team to build (3-6 months, R$100-200k). Option C: Wait (risk: competitor builds first). Choose.)

The cost of waiting:

• Your support is slow (10 minutes per question)
• Customers are frustrated
• You're paying 9 extra support agents (for same volume that 1 agent could handle)
• Competitor (who builds agent) captures cost advantage
• Competitor reinvests savings into product
• Competitor wins market

The benefit of acting now:

• Support is fast (1 minute per question, via agent)
• Customers are happy
• You can reduce support staff (save R$450k/year)
• You reinvest savings into product
• You win market

---

Próximos passos

Na OpenClaw, ajudamos SaaS builders build unified agent layer (like HEMA):

• Support Workflow Audit: Quantos portais seu support pula hoje? (analysis)
• Data Source Inventory: Onde está sua informação? Wiki, service catalog, IT portal, KB? (discovery)
• MCP Strategy: Como conectar suas fontes? Qual priorizar? (planning)
• Bedrock Setup: Como configurar Amazon Bedrock pra seu use-case? (infrastructure)
• Agent Design: Qual interface? Web, Slack, internal chat? (product)
• Pilot Program: Como testar com 1 support agent antes de rollout? (testing)
• Measurement: Como saber se economizou tempo? Que métricas rastrear? (analytics)
• Expansion: Como adicionar mais data sources? Qual próxima? (scaling)
• Quality Assurance: Como garantir agent não dá respostas erradas? (safety)
• Governance: Como manter dados atualizados? Quem é dono? (ops)

Unified Agent Support | MCP | Knowledge Layer | Portal Friction | Instant Answers | Case Study →