Your CRM is a mess.

Duplicate contacts everywhere. Job titles that say "VP Sales" next to "Vice President of Sales" next to "vp, sales." Phone numbers in 47 different formats. Company names spelled three different ways.

You know it's killing your sales team. You've tried to fix it. Maybe you even hired an intern to manually clean records for a summer.

It's still a mess.

Here's the truth: CRM hygiene is an automation problem, not a manual labor problem. And with OpenAI Codex (GPT-5.3, released February 5, 2026), you can finally solve it.

This guide shows you how to build an automated CRM cleaning system that runs continuously, catches duplicates before they spread, and standardizes data as it enters your system.

Why Your CRM Data Is Always Dirty​

Before we fix it, let's understand why CRM hygiene is so hard:

The Compounding Problem​

Every week, your team adds new contacts. Every contact has slightly different formatting:

• Web forms let users type anything
• Integrations pull data in their own format
• Manual entry follows no standard
• Imported lists vary wildly

One dirty record isn't a problem. A thousand is chaos. Ten thousand makes your CRM nearly useless.

The Hidden Costs​

Bad CRM data costs more than you think:

Direct costs:

• Sales reps waste 30+ minutes daily searching for the right contact
• Marketing sends duplicate emails (annoying prospects)
• Lead routing breaks when data doesn't match rules
• Reporting becomes unreliable

Opportunity costs:

• Deals fall through the cracks
• Follow-ups get missed
• Personalization fails when data is wrong
• Territory assignments break down

Research shows the average B2B company loses $15M annually due to bad data. For a 50-person sales team, that's $300K per rep.

The Codex Approach to CRM Hygiene​

Instead of manual cleanup or rigid rule-based tools, GPT-5.3-Codex lets you build intelligent data cleaning that:

1. Understands context — Knows "IBM" and "International Business Machines" are the same company
2. Handles edge cases — Figures out complex duplicates humans would miss
3. Scales infinitely — Processes thousands of records per minute
4. Learns patterns — Gets better at catching your specific data issues

What You Can Automate​

Building Your CRM Hygiene System​

Here's the architecture for an automated cleaning pipeline:

Step 1: Extract Data for Cleaning​

First, pull records that need attention:

# Install Codex CLI
npm install -g @openai/codex

# Create extraction script
codex "Write a Node.js script that:
1. Connects to HubSpot API
2. Fetches contacts created in the last 24 hours
3. Exports to JSON with fields: id, email, firstname, lastname, company, jobtitle, phone
4. Handles pagination for large result sets"

Step 2: Duplicate Detection​

The hardest hygiene problem is finding duplicates that aren't exact matches. Codex excels here:

codex "Create a duplicate detection function that:
1. Takes an array of contact objects
2. Groups potential duplicates using fuzzy matching on:
   - Email (exact and domain-based)
   - Name (Levenshtein distance < 3)
   - Phone (normalized comparison)
3. Scores each potential match 0-100
4. Returns clusters of likely duplicates with confidence scores
5. Use the fuzzball library for string matching"

The key insight: Codex understands that "John Smith at Acme" and "J. Smith at ACME Inc." are probably the same person, even though a simple rule would miss it.

Step 3: Field Standardization​

Job titles are the worst. Everyone writes them differently. Here's how to standardize:

codex "Build a job title standardization function:

Input: Raw job title string
Output: Standardized title from this list:
- CEO / Founder
- VP Sales
- VP Marketing  
- Sales Director
- Marketing Director
- SDR Manager
- Account Executive
- SDR / BDR
- Marketing Manager
- Other

Examples to handle:
- 'Vice President of Sales Operations' → 'VP Sales'
- 'Head of Demand Gen' → 'VP Marketing'
- 'Sr. Account Exec' → 'Account Executive'
- 'Business Development Rep' → 'SDR / BDR'

Use Claude or GPT-4 for classification when rules are ambiguous."

Step 4: Phone Number Normalization​

Phone numbers are surprisingly complex. International formats, extensions, typos:

codex "Create a phone normalization function using libphonenumber:
1. Parse any phone format
2. Detect country from context (default to US)
3. Output E.164 format: +15551234567
4. Handle extensions separately
5. Return null for unparseable numbers
6. Add validation flag for likely invalid numbers"

Step 5: Company Name Matching​

Match company variations to canonical records:

codex "Build a company name matcher:

1. Maintain a lookup table of known companies with variations:
   {'salesforce': ['Salesforce', 'salesforce.com', 'SFDC', 'Salesforce Inc.']}

2. For new company names:
   - Check against lookup table
   - Use fuzzy matching for close matches
   - Query Clearbit or similar for enrichment
   - Add new variations to lookup table

3. Return canonical company name or flag for manual review"

Step 6: Continuous Cleaning Pipeline​

Now connect everything into an automated pipeline:

codex "Create a cron job that runs every hour:

1. Fetch new/modified contacts from last hour
2. Run duplicate detection against existing database
3. Standardize job titles
4. Normalize phone numbers
5. Match company names
6. Write cleaned data back to CRM
7. Flag high-confidence duplicates for merge
8. Alert on data quality issues via Slack

Use OpenClaw for scheduling and Slack integration."

Real-World Results​

When you implement automated CRM hygiene:

Before​

• 23% duplicate rate
• 47 different job title variations
• 12% invalid phone numbers
• 3 hours/week per rep spent searching

After​

• 2% duplicate rate (new duplicates caught in <1 hour)
• 12 standardized job titles
• Phone numbers normalized, invalid flagged
• Search time reduced by 80%

ROI Calculation​

For a 10-person sales team:

• Time saved: 3 hours/week × 10 reps × $50/hour = $1,500/week
• Annual savings: $78,000
• Implementation time: ~8 hours with Codex
• Ongoing cost: ~$50/month in API calls

Payback period: Less than 1 week

Pro Tips for CRM Hygiene Automation​

Start with the Worst Fields​

Don't try to clean everything at once. Identify your biggest data quality problems:

1. What fields break your lead routing?
2. What data issues cause the most rep complaints?
3. Which fields are used in reporting but known to be unreliable?

Clean those first. Get wins. Expand.

Build a Review Queue​

Not everything should be auto-merged. Create a review workflow:

• Auto-merge: Exact email duplicates with same company
• Review queue: Fuzzy matches over 80% confidence
• Ignore: Low-confidence matches

Version Control Your Rules​

Keep your standardization logic in git:

// job-titles.config.js
module.exports = {
  mappings: {
    'vp sales': 'VP Sales',
    'vice president sales': 'VP Sales',
    'head of sales': 'VP Sales',
    // ... hundreds more
  },
  
  // Version for tracking changes
  version: '2.3.1',
  lastUpdated: '2026-02-09'
};

When someone complains about a miscategorization, you can track and fix it.

Monitor Data Quality Metrics​

Build a dashboard that shows:

• Duplicate rate over time
• Field completeness percentages
• Standardization coverage
• Records flagged for review

Alert when metrics drift outside acceptable ranges.

Integrating with MarketBetter​

If you're using MarketBetter's Daily SDR Playbook, clean CRM data makes it dramatically more effective:

• Lead routing works — Contacts reach the right rep
• Personalization hits — Job titles and company names are accurate
• Deduplication prevents spam — Prospects don't get double-contacted
• Reporting is reliable — You can trust your pipeline numbers

MarketBetter integrates with HubSpot to pull contact data. The cleaner that data, the better your playbook recommendations.

Want to see clean data powering intelligent SDR workflows? Book a demo and we'll show you how the Daily SDR Playbook turns accurate CRM data into closed deals.

Common Mistakes to Avoid​

Over-Automating Too Fast​

Don't auto-merge everything on day one. Build confidence:

1. Week 1: Run in audit mode (log what would change)
2. Week 2: Auto-fix obvious issues, queue ambiguous ones
3. Week 3: Lower thresholds as you validate accuracy
4. Ongoing: Refine based on rep feedback

Ignoring the Source​

Cleaning dirty data is treating symptoms. Also fix the sources:

• Tighten web form validation
• Standardize integration mappings
• Train reps on data entry standards
• Add validation to manual entry

Not Tracking What Changed​

Always log changes:

{
  recordId: 'contact_12345',
  field: 'jobtitle',
  oldValue: 'VP, Sales & Marketing',
  newValue: 'VP Sales',
  rule: 'job_title_standardization_v2.3',
  timestamp: '2026-02-09T04:15:00Z'
}

When someone asks "why did this change?", you can answer.

Getting Started Today​

You don't need a massive project to start improving CRM hygiene:

This week:

1. Install Codex CLI (npm install -g @openai/codex)
2. Export your contacts to JSON
3. Use Codex to identify duplicates
4. Manually review and merge the worst offenders

This month:

1. Build automated duplicate detection
2. Standardize your top 3 problem fields
3. Set up daily cleaning cron job

This quarter:

1. Full pipeline automation
2. Source-level validation
3. Quality dashboards and alerting

The goal isn't perfection—it's continuous improvement. Get 1% better every day.

Further Reading​

• Build a 24/7 Pipeline Monitor with OpenClaw — Catch pipeline issues in real-time
• OpenClaw + HubSpot: Ultimate CRM Automation — Full CRM integration guide
• GPT-5.3-Codex: What GTM Teams Need to Know — Overview of Codex capabilities

Clean CRM data is the foundation of effective sales. Stop letting dirty data slow your team down.

Your CSM team is drowning.

They're manually checking dashboards, writing one-off emails, and reacting to churn signals instead of preventing them. Meanwhile, expansion opportunities slip through the cracks because nobody noticed the usage spike.

The math doesn't work: a typical CSM manages 50-200 accounts. They can't possibly give each one proactive attention.

AI can.

This guide shows you how to build a customer success automation system with OpenClaw that monitors, alerts, and acts — 24/7.

Why Customer Success Needs Automation​

The stakes are high:

• Acquiring a new customer costs 5-25x more than retaining one
• A 5% increase in retention can boost profits by 25-95%
• 70% of companies say it's cheaper to retain than acquire

The problem:

• CSMs spend 40% of time on admin tasks (Gainsight research)
• 67% of churn is preventable if addressed early
• Expansion signals are missed because CSMs are firefighting

The opportunity: What if AI handled the monitoring, alerting, and routine outreach — freeing CSMs for high-value strategic conversations?

The Customer Success Automation Stack​

Component 1: Health Score Monitoring​

Track these signals continuously:

Product usage metrics:

• Login frequency (daily, weekly, monthly active)
• Feature adoption (are they using what they bought?)
• Depth of usage (power users vs. surface-level)
• Usage trends (growing, stable, declining)

Engagement metrics:

• Support ticket volume and sentiment
• NPS/CSAT responses
• Email open and response rates
• Meeting attendance with CSM

Business metrics:

• Contract value and renewal date
• Expansion opportunities (usage nearing limits)
• Invoice payment patterns
• Contact turnover (champion still there?)

Component 2: Signal Detection​

Configure alerts for critical moments:

Churn risk signals:

• Usage dropped 30%+ week-over-week
• No login in 14+ days
• Support tickets increased with negative sentiment
• Champion left the company
• Competitor mentioned in support tickets
• Approaching renewal with low engagement

Expansion signals:

• Usage at 80%+ of contracted limits
• New team members being added
• Power user emerging
• Requests for new features (they want more)
• Positive NPS response with expansion interest

Lifecycle signals:

• Onboarding milestone missed
• 90-day mark approaching (critical adoption window)
• Renewal in 60 days
• Customer anniversary (good time for check-in)

Component 3: Automated Actions​

Not every signal needs a human. Automate:

Tier 1 (Full automation):

• Usage tips based on behavior
• Feature announcement emails
• Milestone celebration messages
• Resource recommendations
• Renewal reminder sequences

Tier 2 (AI draft + human review):

• Churn intervention emails
• Expansion opportunity outreach
• Escalation to management
• Personalized QBR prep

Tier 3 (Human-led, AI-assisted):

• High-value renewal negotiations
• Executive sponsor relationships
• Crisis management
• Strategic account planning

Building with OpenClaw​

Here's the complete automation setup:

Agent Configuration​

# customer-success-agent.yaml
name: Customer Success Monitor
schedule: "*/30 * * * *"  # Every 30 minutes

data_sources:
  - product_analytics: "amplitude"
  - crm: "hubspot"
  - support: "zendesk"
  - billing: "stripe"

triggers:
  churn_risk:
    - usage_drop: ">30% week_over_week"
    - no_login: ">14 days"
    - support_sentiment: "negative + >3 tickets"
    - champion_left: true
    
  expansion_opportunity:
    - usage_limit: ">80% contracted"
    - user_growth: ">20% month_over_month"
    - feature_request: "upgrade tier"
    
  lifecycle:
    - onboarding_incomplete: ">30 days"
    - renewal_approaching: "<60 days"
    - anniversary: "annual"

actions:
  churn_risk:
    - calculate_health_score
    - generate_rescue_playbook
    - draft_outreach_email
    - notify_csm_slack
    - escalate_if_high_value
    
  expansion_opportunity:
    - identify_expansion_path
    - draft_expansion_email
    - create_crm_opportunity
    - notify_csm_slack
    
  lifecycle:
    - check_milestone_completion
    - send_appropriate_content
    - schedule_csm_touchpoint

Health Score Calculation​

// Claude-powered health score with reasoning
const calculateHealthScore = async (account) => {
  const metrics = await gatherMetrics(account);
  
  const prompt = `
    Analyze this customer's health and provide:
    1. Overall health score (0-100)
    2. Breakdown by category
    3. Primary risk factors
    4. Recommended actions
    
    Account: ${account.name}
    Contract Value: ${account.arr}
    Renewal Date: ${account.renewalDate}
    
    Usage Metrics:
    - DAU trend: ${metrics.dauTrend}
    - Feature adoption: ${metrics.featureAdoption}
    - Login frequency: ${metrics.loginFrequency}
    
    Engagement Metrics:
    - Last CSM meeting: ${metrics.lastMeeting}
    - Support tickets (30d): ${metrics.recentTickets}
    - Email response rate: ${metrics.emailResponseRate}
    
    Business Metrics:
    - NPS score: ${metrics.nps}
    - Expansion history: ${metrics.expansionHistory}
    - Champion status: ${metrics.championStatus}
    
    Historical context:
    - Similar accounts that churned showed: ${patterns.churnIndicators}
    - Similar accounts that expanded showed: ${patterns.expansionIndicators}
  `;
  
  const analysis = await claude.analyze(prompt);
  
  return {
    score: analysis.score,
    breakdown: analysis.breakdown,
    risks: analysis.risks,
    actions: analysis.recommendedActions,
    reasoning: analysis.reasoning
  };
};

Sample Output​

🏥 CUSTOMER HEALTH REPORT: DataFlow Inc.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Overall Health: 62/100 ⚠️ AT RISK

Category Breakdown:
├─ Usage:      45/100 🔴 Declining
├─ Engagement: 70/100 🟡 Moderate  
├─ Business:   78/100 🟢 Healthy
└─ Sentiment:  55/100 🟡 Concerned

Risk Factors:
1. Usage dropped 35% over past 3 weeks
2. Champion (VP Sales) left 2 weeks ago
3. 4 support tickets this month (up from avg 1)
4. No login from executive sponsor in 45 days

What's Working:
✓ Contract renewed 8 months ago
✓ Invoice payments on time
✓ 3 power users still active

Recommended Actions:
1. URGENT: Identify new champion (old VP's replacement)
2. Schedule health check call within 5 days
3. Send personalized "we noticed" email addressing usage drop
4. Review support tickets for common themes
5. Consider executive-to-executive outreach

Draft Email (Ready to send):
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Subject: Quick check-in on MarketBetter

Hi [New VP Name],

Congrats on the new role at DataFlow! I'm [CSM Name], your success manager at MarketBetter.

I noticed some changes in how your team's using the platform lately. I'd love to spend 15 minutes understanding your priorities and making sure we're aligned.

Any chance you're free [suggested time] this week?

[CSM Name]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Expansion Detection​

const detectExpansionOpportunity = async (account) => {
  const signals = {
    usageLimits: await checkUsageLimits(account),
    userGrowth: await analyzeUserGrowth(account),
    featureRequests: await getFeatureRequests(account),
    engagementTrend: await calculateEngagementTrend(account)
  };
  
  const prompt = `
    Analyze this account for expansion readiness:
    
    Account: ${account.name}
    Current Plan: ${account.plan}
    Contract Value: ${account.arr}
    
    Signals:
    - Usage vs limits: ${signals.usageLimits}
    - User growth (90d): ${signals.userGrowth}
    - Recent feature requests: ${signals.featureRequests}
    - Engagement trend: ${signals.engagementTrend}
    
    Determine:
    1. Is there an expansion opportunity? (yes/no/maybe)
    2. What type? (seats, tier upgrade, new product)
    3. Estimated value
    4. Best timing
    5. Recommended approach
    
    Our expansion playbooks:
    - Seat expansion: triggered at 80% user utilization
    - Tier upgrade: triggered by feature requests + high adoption
    - New product: triggered by adjacent need expressed
  `;
  
  return await claude.analyze(prompt);
};

Slack Notifications​

const notifyCSM = async (alert) => {
  const message = {
    channel: "#cs-alerts",
    blocks: [
      {
        type: "header",
        text: { type: "plain_text", text: alert.emoji + " " + alert.title }
      },
      {
        type: "section",
        fields: [
          { type: "mrkdwn", text: `*Account:*\n${alert.account}` },
          { type: "mrkdwn", text: `*CSM:*\n${alert.csm}` },
          { type: "mrkdwn", text: `*ARR:*\n$${alert.arr}` },
          { type: "mrkdwn", text: `*Risk Level:*\n${alert.riskLevel}` }
        ]
      },
      {
        type: "section",
        text: { type: "mrkdwn", text: `*Why:*\n${alert.reasoning}` }
      },
      {
        type: "actions",
        elements: [
          { type: "button", text: "View Account", url: alert.crmUrl },
          { type: "button", text: "Draft Email", value: `draft_${alert.accountId}` },
          { type: "button", text: "Dismiss", value: `dismiss_${alert.alertId}` }
        ]
      }
    ]
  };
  
  await slack.postMessage(message);
};

Real-World Workflows​

Workflow 1: Churn Prevention​

Day 0: Usage drops 40% week-over-week
       └─ AI detects anomaly
       └─ Checks: no holiday, no known issue
       └─ Health score: 62 → 48
       └─ Alert sent to CSM

Day 1: AI drafts "checking in" email
       └─ CSM reviews and sends
       └─ Opens but no reply

Day 3: No response
       └─ AI drafts follow-up with value reminder
       └─ CSM adds personal touch, sends
       └─ Customer replies: "Busy with reorg"

Day 4: AI schedules call for next week
       └─ Prepares talking points based on account history
       └─ Flags potential champion change risk

Day 10: Call happens
        └─ CSM uses AI-prepared playbook
        └─ Identifies new champion
        └─ Gets commitment on re-engagement plan

Day 30: Usage recovered to baseline
        └─ Health score: 48 → 72
        └─ Renewal risk reduced
        └─ AI logs successful intervention

Workflow 2: Expansion Capture​

Week 1: User count at 85% of contracted seats
        └─ AI detects expansion trigger
        └─ Checks: positive sentiment, stable usage
        └─ Creates expansion opportunity in CRM
        └─ Drafts "planning for growth" email

Week 2: 2 feature requests for advanced tier
        └─ AI correlates with expansion opportunity
        └─ Updates opportunity with feature data
        └─ Drafts custom proposal outline

Week 3: CSM presents expansion proposal
        └─ AI provided: usage stats, ROI calculation, feature mapping
        └─ Customer interested, needs budget approval

Week 4: AI monitors for decision signals
        └─ Detects new finance contact viewing pricing page
        └─ Alerts CSM: "Finance reviewing — good sign"
        └─ Drafts ROI summary for finance review

Week 5: Expansion closed
        └─ 20 additional seats + tier upgrade
        └─ $45K ARR increase
        └─ AI logs successful playbook for future reference

Measuring Success​

Track these metrics:

The math for a $5M ARR company:

• Reducing churn from 8.5% to 5.2% = $165K saved annually
• Increasing expansion from 12% to 24% = $600K additional ARR
• Total impact: $765K

Implementation cost: ~$50K (tooling + setup time) ROI: 15x in year one.

Implementation Roadmap​

Phase 1: Foundation (Weeks 1-2)​

• Connect data sources (product analytics, CRM, support)
• Define health score components
• Set initial alert thresholds
• Configure Slack integration

Phase 2: Automation (Weeks 3-4)​

• Deploy OpenClaw agent
• Build email templates
• Create escalation rules
• Test with pilot CSM

Phase 3: Intelligence (Weeks 5-6)​

• Add Claude-powered analysis
• Build expansion detection
• Create proactive playbooks
• Train CSM team

Phase 4: Scale (Ongoing)​

• Refine thresholds based on outcomes
• Expand automation coverage
• Build predictive models
• Add new use cases

Get Started Today​

Customer success is too important for spreadsheets and gut feelings.

AI doesn't replace your CSM team — it makes them superhuman. Every account gets proactive attention. Every signal gets detected. Every opportunity gets captured.

Your next steps:

1. Map your current health score components
2. Identify your top 3 automation opportunities
3. Book a demo with MarketBetter to see customer success automation in action

Your best customers shouldn't churn because you were too busy with the squeaky wheels.

Every minute a hot lead waits for a response, your conversion rate drops by 7%. But you can't have SDRs working 24/7—or can you?

This guide walks you through building an AI-powered lead qualification bot using OpenClaw that works around the clock: asking the right questions, scoring leads in real-time, and instantly routing qualified prospects to your sales team.

Why Lead Qualification Bots Win​

The math is brutal:

• 78% of deals go to the company that responds first
• Average response time for web leads: 47 hours
• Lead conversion drops 80% after the first 5 minutes

Traditional chatbots don't solve this. They're glorified FAQ systems that frustrate prospects with "I'll have someone contact you." By the time someone contacts them, they've already booked a demo with your competitor.

An AI qualification bot does real work:

The OpenClaw Advantage​

Why OpenClaw for lead qualification?

1. Always-on operation — Cron jobs keep your bot responsive 24/7
2. Memory persistence — Bot remembers conversation context across sessions
3. Multi-channel — Works on website chat, WhatsApp, Slack, or wherever leads arrive
4. Browser automation — Can research leads in real-time (check LinkedIn, company website)
5. CRM integration — Direct HubSpot, Salesforce, and API connections
6. Free and self-hosted — No per-conversation pricing that scales badly

Let's build it.

Step 1: Define Your Qualification Criteria​

Before writing any code, define what makes a qualified lead for your business.

BANT Framework (Classic)​

• Budget: Can they afford your solution?
• Authority: Are they a decision-maker?
• Need: Do they have a problem you solve?
• Timeline: When are they looking to buy?

Modern Qualification Criteria​

For most B2B SaaS, focus on:

qualification_criteria:
  must_have:
    - Company size: 50-500 employees
    - Role: Director+ in Sales, Marketing, or RevOps
    - Use case: Lead generation or SDR efficiency
    - Timeline: Active evaluation (next 3 months)
  
  nice_to_have:
    - Using competitor: Apollo, 6sense, ZoomInfo
    - Pain point: SDR productivity or lead quality
    - Trigger event: New funding, hiring SDRs
  
  disqualifiers:
    - Company size: <20 employees
    - No budget authority
    - Looking for free tools only
    - Student/job seeker

Scoring Matrix​

Score thresholds:

• 0-30: Nurture (add to email sequence)
• 31-60: Qualified (route to SDR)
• 61+: Hot (route to AE, alert Slack)

Step 2: Create the OpenClaw Agent​

Set up your qualification bot in OpenClaw's AGENTS.md:

# lead-qualifier agent config
name: lead-qualifier
model: claude-sonnet-4-20250514
channels:
  - webchat
  - whatsapp
  
memory:
  - QUALIFICATION_RULES.md
  - ICP.md
  
cron:
  # Check for new leads every minute
  - schedule: "* * * * *"
    task: "Check for new unqualified leads in CRM and initiate qualification"

Step 3: The Qualification Conversation Flow​

Here's the soul of your bot—the qualification prompt:

# QUALIFICATION_RULES.md

You are a friendly, professional lead qualification specialist for MarketBetter.
Your job is to have natural conversations that qualify leads while being helpful.

## CONVERSATION RULES

1. NEVER sound like a bot. Be conversational and human.
2. Ask ONE question at a time. Don't interrogate.
3. If they ask product questions, answer them—then continue qualifying.
4. Match their communication style (casual/formal).
5. If they're clearly not a fit, be respectful and offer resources.

## QUALIFICATION QUESTIONS

Ask these naturally throughout the conversation (not all at once):

1. **Company/Role**: "What company are you with? And what's your role there?"
2. **Team size**: "How big is your sales/SDR team currently?"
3. **Pain point**: "What brought you to MarketBetter today? What are you trying to solve?"
4. **Current tools**: "What tools are you using today for [their pain point]?"
5. **Timeline**: "Are you actively evaluating solutions, or just researching for now?"
6. **Budget**: "Do you have budget allocated for this, or would this be a new initiative?"

## SCORING (internal, don't share with lead)

After each response, update your internal score:
- Director/VP/C-level: +20
- 50-500 employees: +15
- 10-50 SDRs: +10
- Pain point matches our ICP: +20
- Active evaluation: +25
- Using competitor: +15
- Budget confirmed: +30
- Timeline < 3 months: +20

Disqualify immediately if:
- Student/researcher
- Company < 20 employees
- No commercial intent
- Competitor employee

## ROUTING ACTIONS

Score 0-30 (Nurture):
- Thank them warmly
- Offer to add to newsletter for tips
- Create lead in CRM as "Marketing Qualified"

Score 31-60 (Qualified):
- Offer to schedule a call with an SDR
- Use Calendly link: [link]
- Create opportunity in CRM

Score 61+ (Hot):
- Immediately alert Slack channel #hot-leads
- Offer to connect them with AE now
- Create high-priority task for AE

## EXAMPLE CONVERSATION

Lead: "Hi, I'm looking at lead generation tools"

You: "Hey! Happy to help. I'm Alex from MarketBetter. 
What's got you looking at lead gen tools right now—any specific challenge you're trying to solve?"

Lead: "Our SDR team is spending too much time researching leads"

You: "Ah, that's a super common one. How big is your SDR team? Just trying to get a sense of the scale."

Lead: "We have about 15 SDRs"

You: "Got it—15 SDRs is a solid team. And you mentioned research is eating up their time... 
are you using any tools today for lead research, or is it mostly manual?"

[Continue naturally until qualified]

Step 4: CRM Integration​

Connect your bot to your CRM so qualified leads get created automatically:

// In your OpenClaw skills or scripts
const qualifyLead = async (conversation) => {
  // Extract qualification data from conversation
  const qualData = await claude.analyze({
    prompt: `Extract qualification data from this conversation:
    ${conversation}
    
    Return JSON: {
      name, email, company, role, teamSize, painPoint, 
      currentTools, timeline, budgetConfirmed, score, notes
    }`
  });

  // Create/update lead in HubSpot
  const lead = await hubspot.createContact({
    email: qualData.email,
    firstname: qualData.name.split(' ')[0],
    lastname: qualData.name.split(' ').slice(1).join(' '),
    company: qualData.company,
    jobtitle: qualData.role,
    lifecyclestage: qualData.score > 30 ? 'salesqualifiedlead' : 'marketingqualifiedlead',
    lead_score: qualData.score,
    hs_lead_status: qualData.score > 60 ? 'HOT' : 'QUALIFIED',
    notes: qualData.notes
  });

  // Route based on score
  if (qualData.score > 60) {
    await slack.send('#hot-leads', {
      text: `🔥 Hot lead just qualified!`,
      blocks: [
        {
          type: "section",
          text: {
            type: "mrkdwn",
            text: `*${qualData.name}* from *${qualData.company}*\n` +
              `Score: ${qualData.score}/100\n` +
              `Pain: ${qualData.painPoint}\n` +
              `Timeline: ${qualData.timeline}`
          }
        },
        {
          type: "actions",
          elements: [
            {
              type: "button",
              text: { type: "plain_text", text: "View in HubSpot" },
              url: `https://app.hubspot.com/contacts/${lead.id}`
            }
          ]
        }
      ]
    });
  }

  return lead;
};

Step 5: Real-Time Lead Research​

Here's where OpenClaw shines—your bot can research leads during the conversation:

// When lead provides company name
const enrichLead = async (companyName) => {
  // Use browser to research
  const research = await openclaw.browser.research({
    queries: [
      `${companyName} linkedin company`,
      `${companyName} crunchbase funding`,
      `${companyName} careers hiring`
    ]
  });

  // Claude summarizes findings
  const enrichment = await claude.analyze({
    prompt: `Summarize this company research for sales qualification:
    ${research}
    
    Extract: employee count, funding stage, recent news, tech stack hints, hiring signals`
  });

  return enrichment;
};

Now your bot can say things like:

"Oh nice, I see Acme Corp just raised a Series B—congrats! Are you looking at tools to help scale the team with that new funding?"

This level of personalization makes leads forget they're talking to a bot.

Step 6: Multi-Channel Deployment​

Deploy your qualification bot across channels:

Website Chat​

Embed OpenClaw's webchat widget on high-intent pages:

• Pricing page
• Demo request page
• Feature comparison pages

WhatsApp Business​

For leads who prefer messaging:

# OpenClaw whatsapp channel config
whatsapp:
  number: "+1-XXX-XXX-XXXX"
  webhook: /api/whatsapp
  qualify_on: first_message

Slack Connect​

For enterprise prospects already in Slack:

slack:
  workspace: marketbetter
  channel: #shared-[company]
  qualify_on: join

Step 7: Handle Edge Cases​

Good bots handle the unexpected:

Product Questions Mid-Qualification​

## PRODUCT QUESTIONS

If the lead asks product questions during qualification, ANSWER THEM.
Don't deflect with "let me have someone call you."

Use this knowledge base:
- [Link to product docs]
- [Link to feature matrix]
- [Link to pricing info]

After answering, naturally transition back to qualification:
"Does that answer your question? By the way, I want to make sure 
I connect you with the right person—what's your role at [company]?"

Impatient Leads​

## FAST QUALIFICATION

If lead seems impatient or says "just get me to sales":
- Don't force all questions
- Ask ONLY: company, role, and main use case
- Immediately offer calendar link
- Note in CRM: "Fast-tracked, needs full qualification on call"

Off-Hours Handling​

## AFTER HOURS

If it's outside business hours (6pm-8am local):
- Still fully qualify
- Offer next-day call booking
- Set expectation: "Great! [AE name] will reach out first thing tomorrow morning"
- Create high-priority task for morning

Measuring Success​

Track these metrics for your qualification bot:

The MarketBetter Connection​

MarketBetter's AI chatbot uses similar qualification intelligence—but goes further by connecting to your entire GTM stack:

• Website visitor identification to enrich leads before they chat
• Intent signals from their browsing behavior
• Seamless handoff to SDR playbook for follow-up
• Closed-loop reporting on which leads convert

The result? Leads are qualified, scored, and routed in seconds—not hours.

See MarketBetter's AI qualification in action →

Implementation Checklist​

Ready to build your qualification bot?

• Define qualification criteria and scoring
• Create OpenClaw agent with qualification prompt
• Set up CRM integration (HubSpot/Salesforce)
• Configure Slack alerts for hot leads
• Deploy to website chat
• Add WhatsApp channel (optional)
• Set up lead enrichment research
• Configure off-hours handling
• Test with sample conversations
• Monitor and tune scoring thresholds

The best SDRs still beat bots in complex sales conversations. But for initial qualification? A well-built AI bot responds faster, works 24/7, and never forgets to ask the important questions.

Building more AI automation for GTM? Check out our guides on CRM hygiene automation and the complete OpenClaw setup guide.

LinkedIn is where B2B deals start.

Your best prospects are there. Decision-makers scroll it daily. A well-crafted message can open doors that cold email never could.

But here's the problem: personalization doesn't scale.

You can either send 100 generic messages (and get ignored) or send 10 deeply personalized ones (and miss 90% of your prospects).

Claude Code changes that equation.

This guide shows you how to build an AI-powered LinkedIn outreach system that researches prospects deeply, crafts genuinely personalized messages, and sequences follow-ups—all while staying within LinkedIn's terms of service.

Why Most LinkedIn Outreach Fails​

Before we build the solution, let's understand the problem:

The Generic Message Problem​

Hi [Name],

I noticed we're both in the [Industry] space. I'd love to connect 
and learn more about what you're working on at [Company].

Best,
[SDR Name]

Every decision-maker sees this 50 times a day. The acceptance rate? Under 5%.

The "I Checked Your Profile for 2 Seconds" Problem​

Hi Sarah,

I see you're the VP of Sales at Acme Corp—impressive background!
I'd love to share how we help sales leaders like you...

The prospect knows you didn't really research them. You just read their headline. This performs marginally better than full generic, but still gets ignored.

The Actually Personalized Message​

Hi Sarah,

Caught your comment on Mark Roberge's post about PLG motions last week.
The point about enterprise sales teams struggling to adapt to product-led 
signals resonated—we see the same pattern with our customers in IoT.

Curious how you're handling that transition at Acme, especially 
after the Globex acquisition. Happy to share what's working for 
companies in similar situations if helpful.

No pitch, just genuinely interested in your take.

This gets responses. But it took 15 minutes to research and write.

The goal: Get the third message's quality at the first message's scale.

The Claude Code Approach​

Claude's 200K context window and nuanced writing make it perfect for this:

1. Research deeply — Pull prospect's recent posts, comments, company news
2. Identify angles — Find genuine connection points (not fake ones)
3. Write naturally — Match the prospect's communication style
4. Avoid AI tells — No corporate speak, no obvious templates

What You'll Build​

By the end of this guide, you'll have a system that:

• Researches prospects using public LinkedIn data
• Identifies personalization hooks from their activity
• Generates connection request messages (300 char limit)
• Creates follow-up sequences based on profile type
• Tracks sent messages and responses

Step 1: Prospect Research with Claude​

First, gather intelligence. You need:

• Recent posts and comments
• Company news
• Shared connections
• Background/experience

Building the Research Prompt​

// prospect-research.js
const researchPrompt = `You are a sales research assistant. 
Given information about a LinkedIn prospect, identify:

1. **Recent Activity Hooks**
   - Posts they've written (topics, opinions expressed)
   - Comments on others' posts (what caught their attention)
   - Articles shared (what they find valuable)

2. **Company Context**
   - Recent news (funding, acquisitions, product launches)
   - Likely challenges given their industry/stage
   - Competitor activity they'd care about

3. **Personal Connection Points**
   - Shared experiences (schools, past companies, interests)
   - Mutual connections worth mentioning
   - Career transitions that show priorities

4. **Communication Style**
   - Formal vs casual tone
   - Direct vs relationship-first
   - Technical vs business-focused

Return a JSON object with these categories and specific examples.
Only include REAL information—never fabricate details.
If you can't find something, say "Not found" rather than guessing.`;

Gathering Public Data​

Use Claude Code to build a research aggregator:

codex "Create a prospect research function that:

1. Takes a LinkedIn profile URL or name + company
2. Searches for their recent public posts using web search
3. Finds recent company news
4. Identifies mutual connections from a provided list
5. Returns structured research data

Use Brave Search API for web searches.
Parse LinkedIn public profiles (no scraping private data).
Respect rate limits and don't hammer any single source."

Step 2: Message Generation​

Now the magic—turning research into messages:

Connection Request Messages​

LinkedIn limits connection requests to 300 characters. Every word counts.

const connectionRequestPrompt = `Write a LinkedIn connection request 
based on this prospect research:

{{research}}

CONSTRAINTS:
- Maximum 300 characters (including spaces)
- No salesy language
- Reference ONE specific thing from their activity
- End with a reason to connect, not a pitch
- Match their communication style (see research)

EXAMPLES OF GOOD MESSAGES:

"Your comment on the PLG debate resonated—we're seeing similar 
tension between product-led and sales-led at IoT companies. 
Would love to compare notes."

"Saw Acme's Series C announcement—congrats! Curious how you're 
thinking about scaling the sales team. Happy to share patterns 
from similar stage companies."

"Your post about SDR burnout hit home. Building tools to help 
with exactly that. Would value your perspective."

Write 3 options ranked by quality. Explain why each works.`;

First Follow-Up Messages​

After they accept, the first message sets the tone:

const firstFollowUpPrompt = `Write a follow-up message for a 
prospect who just accepted my connection request.

Original connection request:
{{original_message}}

Prospect research:
{{research}}

GUIDELINES:
- Thank them for connecting (briefly, not effusively)
- Expand on the topic from the connection request
- Offer specific value (insight, introduction, resource)
- End with a soft question, not a meeting request
- Keep under 500 characters

The goal is to start a conversation, not close a meeting.`;

Step 3: Sequence Building​

Different prospects need different sequences:

Decision Maker Sequence​

const dmSequence = {
  day0: 'connection_request',
  day3: 'first_followup',
  day7: 'value_message', // Share relevant content
  day14: 'soft_ask',     // Suggest a call if engaged
  day21: 'breakup'       // Graceful close
};

const valueMessagePrompt = `Create a value-add message for this prospect.

Research: {{research}}
Previous messages: {{thread}}

Find ONE piece of content (post, article, report) that would 
genuinely help them. Explain briefly why it's relevant to 
their specific situation.

NOT: "Here's our latest whitepaper"
YES: "This analysis of PLG sales models reminded me of your 
comment about enterprise motion challenges. Section 3 on 
hybrid approaches might be relevant for Acme's situation."

Keep under 400 characters.`;

IC (Individual Contributor) Sequence​

const icSequence = {
  day0: 'connection_request',
  day2: 'peer_followup',  // More casual, peer-to-peer
  day5: 'resource_share', // Tool, template, or tip
  day10: 'dm_intro_ask'   // Ask for intro if there's a DM target
};

Step 4: Automating the Pipeline​

Bring it together with OpenClaw for scheduling:

Daily Research Job​

# openclaw config
cron:
  - name: "LinkedIn Research"
    schedule: "0 6 * * 1-5"  # 6am weekdays
    task: |
      For each prospect in my outreach queue:
      1. Run research function
      2. Generate appropriate message
      3. Queue for sending
      4. Log to tracking sheet

Message Queue and Tracking​

codex "Create a LinkedIn outreach tracker that:

1. Maintains a queue of prospects to contact
2. Tracks sent messages and dates
3. Logs responses and engagement
4. Calculates acceptance and reply rates
5. Alerts when a prospect engages

Store in Supabase with these fields:
- prospect_id, name, company, title
- research_json
- messages_sent (array with dates)
- status (queued/sent/accepted/replied/converted)
- notes

Generate weekly report showing:
- Messages sent, accepted, replied
- Best-performing message templates
- Prospects needing follow-up"

Real Performance Numbers​

When you implement AI-assisted LinkedIn outreach properly:

Generic Approach​

• Connection acceptance: 5-10%
• Reply rate: 2-5%
• Meeting rate: 0.5-1%

AI-Personalized Approach​

• Connection acceptance: 35-50%
• Reply rate: 15-25%
• Meeting rate: 5-10%

That's a 10x improvement in meetings booked.

Sample Week​

Five meetings from 100 prospects, with maybe 2 hours of actual work (review and approve messages).

Avoiding LinkedIn Jail​

LinkedIn's algorithms detect automation. Here's how to stay safe:

Activity Limits​

• Connection requests: 20-25/day max
• Messages: 50-75/day max
• Profile views: 100-150/day max
• Searches: Spread throughout the day

Human Patterns​

• Don't send at exactly the same time daily
• Vary message lengths
• Take weekends off (mostly)
• Accept requests manually sometimes

Quality Signals​

LinkedIn rewards engagement:

• Post your own content weekly
• Comment thoughtfully on others' posts
• Complete your profile fully
• Have a reasonable network size

Red Flags to Avoid​

• Identical messages to multiple people
• Sending from a brand new account
• Mass connection requests in short bursts
• Never posting your own content

Integrating with Your Sales Stack​

LinkedIn outreach works best when integrated:

CRM Sync​

codex "Create a HubSpot integration that:

1. Creates/updates contacts when LinkedIn connections accept
2. Logs LinkedIn messages as activities
3. Updates deal stage when replies indicate interest
4. Triggers sales sequences for qualified prospects"

Routing to AEs​

When a prospect engages:

1. Research reply — Check sentiment, interest level
2. Update CRM — Add notes on what they said
3. Notify AE — Slack alert with context
4. Queue handoff message — Draft intro from SDR to AE

Pro Tips from Top Performers​

Tip 1: Engage Before Connecting​

Before sending a connection request:

• Like 2-3 of their posts
• Leave a thoughtful comment
• Share something of theirs with your take

Now when you connect, they recognize your name.

Tip 2: Use Their Words​

If they wrote a post about "sales efficiency," use that exact phrase. If they call themselves a "revenue leader" not a "sales leader," mirror that.

Claude is great at this when you provide the source material.

Tip 3: Give Before Asking​

The ratio should be 3:1 — three value-adds for every ask:

1. Connection request (light ask)
2. Useful article/insight (give)
3. Relevant introduction (give)
4. Industry tip (give)
5. Meeting request (ask)

Tip 4: Warm Up the DM​

Your best prospects probably follow influencers in your space. Engage with those influencers' content where your prospects are commenting.

Now you've "met" in public before sliding into DMs.

Common Mistakes to Avoid​

Over-Relying on AI​

AI generates the message, but you should:

• Review every message before sending
• Add personal touches you genuinely know
• Skip prospects where you can't find real hooks
• Adjust based on responses

Fake Personalization​

# BAD
"I see you're passionate about sales—me too!"

# GOOD  
"Your post last week about discounting during 
enterprise negotiations changed how I think 
about pricing conversations."

If you can't find real personalization, use a honest generic:

"Expanding my network of sales leaders in IoT. 
Your background at [Company] caught my eye. 
Happy to connect and share what I'm seeing 
in the space."

Honest generic beats fake personal every time.

Pitching Too Soon​

The sequence matters:

1. Connect
2. Acknowledge
3. Provide value
4. Ask

Skipping to step 4 kills the relationship.

Getting Started This Week​

Day 1: Set Up Tools​

• Install Claude Code / Codex CLI
• Set up tracking spreadsheet or Supabase table
• Create your prospect list (50 targets)

Days 2-3: Build Research Flow​

• Create research prompt
• Test on 5 prospects manually
• Refine based on what's useful

Days 4-5: Generate Messages​

• Create message prompts for each sequence step
• Generate messages for 20 prospects
• Review and improve prompt

Week 2: Launch​

• Send 10-15 connection requests daily
• Track acceptance and reply rates
• Iterate on messages based on performance

Next Steps​

LinkedIn outreach is just one piece of the prospecting puzzle. To see how AI-powered outreach fits into a complete SDR workflow:

Book a MarketBetter demo — We'll show you how the Daily SDR Playbook combines LinkedIn signals, email outreach, and CRM data to tell your reps exactly who to contact and what to say.

Related Reading​

• AI Email Personalization at Scale — Same techniques for email outreach
• How to Automate Lead Research with Claude — Deep dive on prospect research
• 10 Codex Prompts That 10x SDR Productivity — Copy-paste prompts for sales teams

The best LinkedIn outreach doesn't feel like outreach. It feels like a human who did their homework. Now you can do that homework in seconds.

The best sales sequences aren't single-channel. They're coordinated attacks across email, LinkedIn, and phone—timed perfectly based on prospect behavior.

But managing multi-channel sequences manually? Chaos. You're toggling between 4 tools, copy-pasting data, and hoping you don't accidentally call someone you just emailed. Or worse—reaching out on LinkedIn after they already replied to your email.

OpenClaw changes this. As an open-source AI gateway, it can orchestrate touchpoints across every channel, making decisions in real-time based on prospect response. No more rigid "Day 1 email, Day 3 LinkedIn" sequences. Instead: intelligent orchestration that adapts.

The Problem with Linear Sequences​

Traditional multi-channel sequences look like this:

Day 1: Email #1
Day 3: LinkedIn connection request
Day 5: Email #2
Day 7: Phone call
Day 10: Email #3
Day 14: LinkedIn message

The problems:

1. Ignores responses - Prospect replies on Day 2? Sequence keeps blasting.
2. No channel preference detection - Some people live on LinkedIn, others on email
3. Rigid timing - Day 5 might be a holiday or their busiest day
4. Coordination gaps - Your dialer doesn't know what your email tool sent
5. Manual overrides - Reps spend more time managing the sequence than selling

AI orchestration solves these by making real-time decisions:

Day 1: Email #1
  → If reply: Stop sequence, alert rep
  → If LinkedIn engagement: Prioritize LinkedIn next
  → If website visit: Trigger call immediately
  
Day 3: [Conditional]
  → If email opened 3x: Send email #2
  → If no email engagement: Try LinkedIn
  → If already connected on LinkedIn: Direct message

Building an Orchestration Engine with OpenClaw​

Here's the architecture:

┌─────────────────────────────────────────────────────────┐
│                    PROSPECT ENTERS                       │
│              (new lead from any source)                  │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                 INITIAL RESEARCH                         │
│  Claude enriches: title, company size, social presence  │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│              CHANNEL PREFERENCE SCORING                  │
│  - LinkedIn active? (posts, engagement)                  │
│  - Email deliverable? (bounce risk)                      │
│  - Phone available? (direct dial vs. HQ)                │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│                ORCHESTRATION ENGINE                      │
│  OpenClaw decides: which channel, what message, when    │
└─────────────────────────────────────────────────────────┘
          │                    │                    │
          ▼                    ▼                    ▼
    ┌─────────┐          ┌─────────┐          ┌─────────┐
    │  EMAIL  │          │ LINKEDIN│          │  PHONE  │
    └─────────┘          └─────────┘          └─────────┘
          │                    │                    │
          └────────────────────┴────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│               RESPONSE MONITORING                        │
│  - Email opens/clicks/replies                           │
│  - LinkedIn accepts/views/responds                      │
│  - Call outcomes (connected, VM, callback requested)    │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
              [Loop back to orchestration engine]

Implementation: Step by Step​

Step 1: Define Your Sequence Logic​

Create a sequence configuration that OpenClaw can execute:

# sequence-config.yaml
name: "Enterprise Outbound"
target: "VP/Director Sales @ B2B SaaS 100-500 employees"

stages:
  - name: "initial_outreach"
    duration: "3 days"
    actions:
      - channel: "email"
        template: "cold_intro_v2"
        priority: 1
      - channel: "linkedin_connect"
        note_template: "connection_note"
        priority: 2
        condition: "has_linkedin_profile"
    
    exit_conditions:
      - type: "reply"
        next_stage: "conversation"
      - type: "meeting_booked"
        next_stage: "complete"

  - name: "follow_up"
    duration: "7 days"
    entry_condition: "no_response_after_initial"
    actions:
      - channel: "email"
        template: "follow_up_value_add"
        delay: "2 days"
        condition: "email_opened_count >= 2"
      - channel: "linkedin_message"
        template: "linkedin_follow_up"
        delay: "2 days"
        condition: "linkedin_connected"
      - channel: "phone"
        script: "discovery_call_script"
        delay: "3 days"
        priority: 1
        condition: "has_direct_phone"

  - name: "nurture"
    entry_condition: "no_response_after_follow_up"
    actions:
      - channel: "email"
        template: "content_share"
        frequency: "weekly"
        max_attempts: 4

Step 2: Build the Orchestration Agent​

// orchestration-agent.js

const OpenClaw = require('openclaw');

const agent = new OpenClaw.Agent({
  name: 'Sequencer',
  triggers: ['prospect_added', 'response_received', 'daily_check']
});

agent.on('prospect_added', async (prospect) => {
  // Enrich prospect data
  const enriched = await enrichProspect(prospect);
  
  // Score channel preferences
  const channels = await scoreChannelPreferences(enriched);
  
  // Start sequence
  await startSequence(prospect.id, 'enterprise_outbound', channels);
});

agent.on('response_received', async (event) => {
  const { prospectId, channel, responseType } = event;
  
  if (responseType === 'reply' || responseType === 'meeting_booked') {
    // Stop automated sequence
    await pauseSequence(prospectId);
    
    // Alert assigned rep
    await notify.slack({
      channel: '#hot-leads',
      message: `🎯 ${event.prospectName} responded via ${channel}!`
    });
    
    // Create follow-up task
    await createTask(prospectId, 'respond_to_inquiry', {
      priority: 'high',
      deadline: '4 hours'
    });
  }
  
  if (responseType === 'engagement') {
    // Engagement but no response - adjust strategy
    await adjustSequence(prospectId, {
      preferChannel: channel,
      increaseFrequency: true
    });
  }
});

agent.on('daily_check', async () => {
  const activeProspects = await getActiveSequences();
  
  for (const prospect of activeProspects) {
    const nextAction = await determineNextAction(prospect);
    
    if (nextAction) {
      await scheduleAction(prospect.id, nextAction);
    }
  }
});

Step 3: Channel Preference Scoring​

Not all prospects respond equally to each channel:

async function scoreChannelPreferences(prospect) {
  const scores = {
    email: 50, // Base score
    linkedin: 50,
    phone: 50
  };
  
  // LinkedIn activity signals
  if (prospect.linkedin_posts_last_90_days > 5) {
    scores.linkedin += 25; // Active on LinkedIn
  }
  if (prospect.linkedin_engagement_score > 70) {
    scores.linkedin += 15;
  }
  if (!prospect.linkedin_profile) {
    scores.linkedin = 0; // Can't use what doesn't exist
  }
  
  // Email signals
  if (prospect.email_bounce_risk === 'high') {
    scores.email -= 30;
  }
  if (prospect.previous_email_opens > 0) {
    scores.email += 20; // Has opened our emails before
  }
  if (prospect.company_size > 1000) {
    scores.email -= 10; // Enterprise = more gatekeeping
  }
  
  // Phone signals
  if (prospect.has_direct_dial) {
    scores.phone += 30;
  }
  if (prospect.has_mobile) {
    scores.phone += 20;
  }
  if (prospect.title.includes('C-level')) {
    scores.phone -= 15; // Harder to reach
    scores.linkedin += 15; // But responsive on LinkedIn
  }
  
  return scores;
}

Step 4: Smart Timing​

Don't just blast—time it right:

async function determineOptimalSendTime(prospect, channel) {
  // Time zone awareness
  const prospectTz = prospect.timezone || await inferTimezone(prospect.location);
  
  // Historical engagement data
  const engagement = await getEngagementHistory(prospect.id);
  
  // Find optimal window
  if (channel === 'email') {
    // Best open rates: Tue-Thu, 9-11am local
    return findNextWindow(prospectTz, {
      preferredDays: [2, 3, 4], // Tue, Wed, Thu
      preferredHours: [9, 10, 11],
      avoidHours: [12, 13] // Lunch
    });
  }
  
  if (channel === 'phone') {
    // Best connect rates: early morning or end of day
    // But respect Do Not Call hours
    return findNextWindow(prospectTz, {
      preferredHours: [8, 9, 16, 17],
      avoidHours: [12, 13],
      respectDNC: true
    });
  }
  
  if (channel === 'linkedin') {
    // LinkedIn engagement peaks: breakfast, lunch, commute
    return findNextWindow(prospectTz, {
      preferredHours: [7, 8, 12, 18, 19]
    });
  }
}

Step 5: Response Handling​

The magic happens when prospects respond:

// Response handler
async function handleResponse(event) {
  const { prospect, channel, content, sentiment } = event;
  
  // Analyze response with Claude
  const analysis = await claude.analyze({
    prompt: `Analyze this sales response and classify:
    
    Response: "${content}"
    
    Categories:
    - POSITIVE: Interested, wants to learn more
    - NEGATIVE: Not interested, timing not right
    - REFERRAL: Suggests talking to someone else
    - QUESTION: Has questions, needs info
    - OOO: Out of office / automated reply
    
    Also extract: any mentioned dates, preferences, or objections.`
  });
  
  switch (analysis.category) {
    case 'POSITIVE':
      await pauseSequence(prospect.id);
      await createTask('schedule_call', {
        prospect,
        urgency: 'high',
        context: analysis.extractedInfo
      });
      break;
      
    case 'NEGATIVE':
      await endSequence(prospect.id, 'not_interested');
      await scheduleNurture(prospect.id, '90 days');
      break;
      
    case 'REFERRAL':
      await createReferralLead(analysis.referredPerson);
      await sendThankYou(prospect);
      break;
      
    case 'QUESTION':
      await pauseSequence(prospect.id);
      await createTask('answer_question', {
        prospect,
        question: analysis.extractedInfo.question
      });
      break;
      
    case 'OOO':
      const returnDate = analysis.extractedInfo.returnDate;
      await pauseSequenceUntil(prospect.id, returnDate);
      break;
  }
}

Real-World Sequence Example​

Here's a complete sequence that adapts:

PROSPECT: Sarah Chen, VP Sales at TechCorp (450 employees)

Day 1, 9:04am EST
→ Channel preference: LinkedIn (83), Email (71), Phone (65)
→ Action: Email intro sent (personalized to B2B SaaS pain points)

Day 1, 2:15pm EST  
→ Signal: Email opened (mobile device)
→ Decision: Wait for click/reply before next action

Day 2, 8:30am EST
→ Signal: Email opened again, clicked pricing link
→ Decision: Accelerate LinkedIn connection

Day 2, 9:12am EST
→ Action: LinkedIn connection request sent

Day 2, 3:45pm EST
→ Signal: LinkedIn accepted
→ Decision: Send LinkedIn message (more personal than email)

Day 3, 8:05am EST
→ Action: LinkedIn message sent (referenced pricing visit)

Day 3, 11:30am EST
→ Signal: LinkedIn message read, no reply
→ Decision: Give breathing room, prepare phone call

Day 4, 4:15pm EST
→ Action: Phone call attempted
→ Outcome: Voicemail left

Day 5, 9:30am EST
→ Signal: Website visit (case studies page)
→ Decision: Send value-add email with case study

Day 5, 9:45am EST
→ Action: Email sent (case study)

Day 5, 10:22am EST
→ Signal: Email reply! "This looks interesting. Can we talk Thursday?"
→ Decision: STOP sequence, create booking task

Day 5, 10:25am EST
→ Task created: "Schedule call with Sarah Chen - Thursday"
→ Sequence status: PAUSED - Conversation active

Metrics That Matter​

Track these to optimize your sequences:

Integration with MarketBetter​

If you're using MarketBetter, multi-channel orchestration is built in:

• Daily SDR Playbook automatically sequences touches
• Smart Dialer knows what emails/LinkedIn you've sent
• Unified timeline shows all touchpoints in one view
• AI prioritization decides which prospect needs which channel next

No need to build from scratch—just configure your sequence rules and let the platform orchestrate.

Conclusion​

Single-channel sequences are relics. In 2026, the winning outbound strategy is coordinated, adaptive, multi-channel orchestration that responds to prospect behavior in real-time.

OpenClaw makes this possible for any GTM team—without the $50K/year enterprise platform price tag. Build your orchestration agent, define your logic, and let AI handle the complexity of timing, channel selection, and response handling.

Your prospects don't live in one channel. Your outreach shouldn't either.

Want multi-channel orchestration without building it yourself? MarketBetter's platform coordinates email, LinkedIn, phone, and more—with AI deciding the optimal next touch. Book a demo to see it in action.

Here's a paradox: B2B companies want to expand internationally, but their SDR teams only speak English.

The traditional solutions—hire native speakers, use translation agencies, or (worst) run English outreach in non-English markets—are either expensive, slow, or ineffective.

But AI has changed this. Claude Code can generate culturally-aware, professionally-translated outreach in 50+ languages—with the nuance that Google Translate will never achieve.

Let me show you how to build a multi-language outreach system that scales globally without scaling headcount.

Why English-Only Outreach Fails Internationally​

Let's look at the data:

• 72% of consumers prefer buying from sites in their native language (CSA Research)
• 56% say language is more important than price
• Response rates drop 60-80% when using English in non-English markets

The math is brutal: your German prospects are 3-5x more likely to respond to German outreach.

But it's not just translation. It's localization:

AI doesn't just translate words. It adapts tone, formality, and cultural expectations.

The Multi-Language Outreach Framework​

Here's how to build it:

1. Language detection (identify prospect's language)
2. Cultural context injection (regional norms, business etiquette)
3. Native-quality generation (not translation—creation)
4. Localized follow-ups (appropriate cadence for culture)

Step 1: Intelligent Language Detection​

Before generating outreach, you need to know what language to use:

# Language detection and regional analysis
def detect_prospect_language(prospect):
    """
    Determines appropriate outreach language based on multiple signals
    """
    
    signals = {
        'company_hq': prospect.get('company_country'),
        'linkedin_language': prospect.get('linkedin_language_setting'),
        'website_language': detect_website_language(prospect.get('company_website')),
        'name_origin': analyze_name_origin(prospect.get('full_name')),
        'email_domain': extract_country_from_domain(prospect.get('email'))
    }
    
    # Country to language mapping (with regional variants)
    language_map = {
        'Germany': 'de-DE',
        'Austria': 'de-AT',
        'Switzerland': 'de-CH',  # Could also be French or Italian
        'France': 'fr-FR',
        'Canada': 'en-CA',  # Or fr-CA if Quebec
        'Mexico': 'es-MX',
        'Spain': 'es-ES',
        'Brazil': 'pt-BR',
        'Japan': 'ja-JP',
        # ... expanded mapping
    }
    
    # Weighted decision
    primary_country = signals['company_hq'] or signals['linkedin_language']
    
    # Special cases
    if primary_country == 'Switzerland':
        # Check region for language
        return detect_swiss_language(prospect)
    
    if primary_country == 'Canada':
        # Check if Quebec
        if prospect.get('province') == 'Quebec':
            return 'fr-CA'
        return 'en-CA'
    
    return language_map.get(primary_country, 'en-US')