Your competitors launched a new feature last week. Changed their pricing yesterday. Hired a VP of Sales this morning.

You found out... just now, reading this.

In fast-moving markets, competitive intelligence isn't a quarterly report—it's a real-time feed. This guide shows you how to build an automated competitive intel system using OpenClaw and Claude that monitors competitors 24/7 and alerts your team the moment something changes.

Why Real-Time Competitive Intel Matters​

The traditional approach to competitive intelligence:

1. Sales rep hears something on a call
2. Mentions it in Slack (maybe)
3. Product marketing adds it to a doc (eventually)
4. Battlecard gets updated (quarterly, if lucky)

Result: Your team learns about competitor changes weeks or months after they happen.

The Cost of Slow Intel​

Real-time intel changes the game. Instead of quarterly catch-up, you get:

• Immediate Slack alerts when competitors update pricing pages
• Daily summaries of competitor blog posts and announcements
• Automatic battlecard updates with new objection handling
• Early warning on strategic moves (funding, hiring, partnerships)

The Architecture​

Here's what we're building:

[Competitor Websites] → [OpenClaw Monitors] → [Claude Analysis] → [Alerts]
        ↓                      ↓                    ↓              ↓
   - Pricing pages         - Browser               - Change        - Slack
   - Feature pages         - Cron jobs             - Summarize     - Email
   - Blog/News             - Snapshots             - Assess        - CRM
   - LinkedIn                                      - Recommend
   - Job postings

Step 1: Define What to Monitor​

Start by listing your top competitors and what to track:

# competitors.yml
competitors:
  warmly:
    name: "Warmly"
    website: "https://warmly.ai"
    monitors:
      - type: pricing
        url: "https://warmly.ai/pricing"
        check: daily
        alert_on: any_change
      - type: features
        url: "https://warmly.ai/features"
        check: daily
        alert_on: new_content
      - type: blog
        url: "https://warmly.ai/blog"
        check: hourly
        alert_on: new_posts
      - type: linkedin
        url: "https://linkedin.com/company/warmly-ai"
        check: daily
        alert_on: new_posts, employee_changes
      - type: jobs
        url: "https://warmly.ai/careers"
        check: weekly
        alert_on: new_roles
        
  sixsense:
    name: "6sense"
    website: "https://6sense.com"
    monitors:
      - type: pricing
        url: "https://6sense.com/pricing"
        check: daily
      # ... etc

Priority Monitoring Matrix​

Not all intel is equal. Prioritize:

Step 2: Build the Monitoring Agent​

Create an OpenClaw agent dedicated to competitive intelligence:

# agents/recon.md - Competitive Intelligence Agent

You are Recon 🔭, MarketBetter's competitive intelligence specialist.

## Your Mission

Monitor competitors and surface actionable intelligence for the GTM team.

## What You Track

- Pricing pages (changes, new tiers, discounts)
- Feature announcements (new capabilities, deprecations)
- Blog content (positioning, case studies, thought leadership)
- Job postings (what roles = what they're building)
- LinkedIn activity (announcements, key hires)
- Funding/M&A news
- Customer wins/losses

## Daily Routine

1. Check all competitor pricing pages for changes
2. Scan competitor blogs for new posts
3. Review LinkedIn company pages
4. Search news for competitor mentions
5. Summarize findings in #competitive-intel Slack channel

## Alert Priorities

🚨 IMMEDIATE (Slack + ping team):
- Pricing changes
- Major feature launches
- Funding announcements
- Key executive hires

📊 DAILY DIGEST:
- New blog posts
- Minor feature updates
- Job posting changes
- LinkedIn activity

📋 WEEKLY SUMMARY:
- Positioning shifts
- Content strategy analysis
- Market share signals

## Output Format

For each finding:
1. What changed (be specific)
2. Why it matters (business impact)
3. Recommended action (update battlecard, adjust messaging, etc.)

Step 3: The Monitoring Cron Jobs​

Set up OpenClaw cron jobs for each monitoring frequency:

// cron-config.js - Competitive monitoring schedule

const monitors = [
  {
    name: "pricing-monitor",
    schedule: "0 */4 * * *", // Every 4 hours
    task: `
      Check these competitor pricing pages for changes:
      - https://warmly.ai/pricing
      - https://6sense.com/pricing  
      - https://apollo.io/pricing
      
      Compare to last snapshot. If ANY pricing, tier, or feature change detected:
      1. Summarize what changed
      2. Assess competitive impact
      3. Alert #competitive-intel immediately
      4. Update competitor database
    `
  },
  {
    name: "blog-monitor",
    schedule: "0 */2 * * *", // Every 2 hours
    task: `
      Check competitor blogs for new posts:
      - https://warmly.ai/blog
      - https://6sense.com/resources/blog
      - https://apollo.io/blog
      
      For new posts:
      1. Summarize key points
      2. Identify positioning/messaging themes
      3. Note any customer mentions or case studies
      4. Add to daily digest
    `
  },
  {
    name: "linkedin-monitor", 
    schedule: "0 9 * * *", // Daily at 9am
    task: `
      Check competitor LinkedIn pages for:
      - New announcements
      - Employee count changes
      - Key hire announcements
      - Customer testimonial posts
      
      Flag anything significant for review.
    `
  },
  {
    name: "jobs-monitor",
    schedule: "0 9 * * 1", // Weekly on Monday
    task: `
      Analyze competitor job postings:
      - What roles are they hiring for?
      - What skills/technologies mentioned?
      - What does hiring pattern suggest about strategy?
      
      Summarize strategic implications.
    `
  }
];

Step 4: Page Change Detection​

Use OpenClaw's browser capabilities to detect changes:

// competitor-monitor.js

const monitorPricingPage = async (competitor) => {
  const { url, name } = competitor;
  
  // Fetch current page content
  const browser = await openclaw.browser.launch();
  const page = await browser.newPage();
  await page.goto(url);
  
  // Get pricing content
  const content = await page.evaluate(() => {
    // Extract pricing-specific elements
    const pricing = document.querySelectorAll('[class*="pricing"], [class*="plan"], [class*="tier"]');
    return Array.from(pricing).map(el => el.textContent).join('\n');
  });
  
  // Get previous snapshot
  const previousSnapshot = await db.getSnapshot(name, 'pricing');
  
  // Compare with Claude
  if (previousSnapshot) {
    const analysis = await claude.analyze({
      prompt: `
        Compare these two versions of ${name}'s pricing page.
        
        PREVIOUS:
        ${previousSnapshot.content}
        
        CURRENT:
        ${content}
        
        Identify:
        1. Any pricing changes (amounts, tiers, features per tier)
        2. New or removed plans
        3. Messaging/positioning changes
        4. New social proof or customer logos
        
        If significant changes found, format as an ALERT.
        If no meaningful changes, respond with "NO_CHANGES"
      `
    });
    
    if (!analysis.includes('NO_CHANGES')) {
      await alertTeam(name, 'pricing', analysis);
    }
  }
  
  // Save current snapshot
  await db.saveSnapshot(name, 'pricing', content);
  
  await browser.close();
};

Step 5: Claude Analysis Layer​

Raw change detection isn't enough. Claude adds the "so what?":

// analyze-change.js

const analyzeCompetitorChange = async (competitor, changeType, rawChange) => {
  const context = await db.getCompetitorContext(competitor);
  
  const analysis = await claude.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 1500,
    messages: [{
      role: "user",
      content: `
        You are a competitive intelligence analyst for MarketBetter.
        
        COMPETITOR: ${competitor}
        CHANGE TYPE: ${changeType}
        
        CHANGE DETECTED:
        ${rawChange}
        
        COMPETITOR CONTEXT:
        ${JSON.stringify(context, null, 2)}
        
        Provide analysis in this format:
        
        ## Summary
        [One sentence: what changed]
        
        ## Business Impact
        [How does this affect MarketBetter competitively?]
        
        ## Recommended Actions
        - [Action 1 with owner]
        - [Action 2 with owner]
        
        ## Talking Points for Sales
        [2-3 bullet points sales can use immediately]
        
        ## Battlecard Update
        [Specific text to add/update in battlecard]
      `
    }]
  });
  
  return analysis.content[0].text;
};

Step 6: Alert System​

Send alerts through the right channels:

// alert-system.js

const alertTeam = async (competitor, changeType, analysis) => {
  const severity = getSeverity(changeType);
  
  // Slack alert
  await slack.send('#competitive-intel', {
    text: `${severity.emoji} Competitive Intel: ${competitor}`,
    blocks: [
      {
        type: "header",
        text: {
          type: "plain_text",
          text: `${severity.emoji} ${competitor}: ${changeType.toUpperCase()} Change Detected`
        }
      },
      {
        type: "section",
        text: {
          type: "mrkdwn",
          text: analysis
        }
      },
      {
        type: "divider"
      },
      {
        type: "context",
        elements: [{
          type: "mrkdwn",
          text: `Detected at ${new Date().toISOString()} | <${competitor.website}|View page>`
        }]
      }
    ]
  });

  // If critical, also ping key people
  if (severity.level === 'critical') {
    await slack.send('#sales-leadership', {
      text: `🚨 @channel Competitor pricing change detected: ${competitor}. Check #competitive-intel for details.`
    });
  }

  // Log to database for trending
  await db.logCompetitorChange({
    competitor,
    changeType,
    analysis,
    severity: severity.level,
    timestamp: new Date()
  });
};

const getSeverity = (changeType) => {
  const severities = {
    pricing: { level: 'critical', emoji: '🚨' },
    features: { level: 'high', emoji: '⚡' },
    leadership: { level: 'high', emoji: '👔' },
    blog: { level: 'medium', emoji: '📝' },
    jobs: { level: 'low', emoji: '💼' }
  };
  return severities[changeType] || { level: 'low', emoji: 'ℹ️' };
};

Step 7: Automatic Battlecard Updates​

The best intel system updates sales materials automatically:

// battlecard-updater.js

const updateBattlecard = async (competitor, analysis) => {
  // Get current battlecard from Notion/Google Docs
  const battlecard = await notion.getPage(competitor.battlecardId);
  
  // Have Claude suggest specific updates
  const updates = await claude.analyze({
    prompt: `
      Current battlecard for ${competitor}:
      ${battlecard.content}
      
      New intelligence:
      ${analysis}
      
      Suggest SPECIFIC edits to the battlecard:
      1. What to add
      2. What to update
      3. What to remove (if outdated)
      
      Format as diff-style changes.
    `
  });
  
  // Create draft update (human reviews before publish)
  await notion.createComment(competitor.battlecardId, {
    text: `🤖 Suggested updates based on new intel:\n\n${updates}\n\n_Review and apply as needed._`
  });
  
  // Notify product marketing
  await slack.send('@product-marketing', {
    text: `Battlecard update suggested for ${competitor}. Check Notion for details.`
  });
};

Daily Digest Format​

Aggregate lower-priority intel into a daily digest:

# 📊 Competitive Intel Digest - Feb 9, 2026

## Pricing Changes
None detected today ✅

## New Content
- **Warmly**: "How We Helped Acme Corp 3x Pipeline" (case study)
  - Key claim: 3x pipeline in 60 days
  - Our counter: Our average is 2.5x in 30 days with playbook
  
- **6sense**: "The Death of the MQL" (thought leadership)
  - Positioning: Intent data makes MQLs obsolete
  - Our angle: Intent without action is just noise

## Job Postings
- **Apollo**: Hiring 5 SDR positions in EMEA
  - Signal: Expanding European presence
  - Action: Monitor for EMEA pricing/features

## LinkedIn Activity
- **Warmly** CEO posted about "exciting news coming next week"
  - Monitor closely for announcement

---
*Generated by Recon 🔭 | Next digest: Tomorrow 9am*

Connecting to MarketBetter​

MarketBetter's competitive intelligence goes deeper than monitoring:

• Real-time battlecards in the SDR playbook
• Competitive mentions flagged from call recordings
• Win/loss analysis tied to specific competitors
• Rep coaching on competitor objection handling

Your SDRs don't check a separate doc—competitive intel is embedded in their daily workflow.

See how MarketBetter arms your team against competitors →

Implementation Checklist​

Ready to build your competitive intel system?

• List top 5-10 competitors to monitor
• Identify pages to track (pricing, features, blog, jobs)
• Set up OpenClaw agent with monitoring prompts
• Configure cron jobs for each monitor type
• Build change detection with browser automation
• Add Claude analysis layer
• Set up Slack alerts by severity
• Create daily digest template
• Connect to battlecard system
• Test with manual changes

The best competitive intel isn't collected—it's automated. With OpenClaw + Claude, your team knows about competitor moves in hours, not months.

Building more GTM automation? Check out our guides on pricing intelligence automation and training custom AI agents.

You just lost a $75K deal to Gong.

The rep says "they went with a cheaper option." But was it really price? Or was it features? Timeline? A relationship with the competitor's AE?

Without a system to capture and analyze this, you'll lose the next deal the same way.

Most companies have:

• Scattered Slack messages about losses
• A battlecard doc nobody updates
• Tribal knowledge in the heads of senior reps
• CRM fields that say "Closed Lost - Competitor" with no detail

What you need is a living competitive intelligence repository that:

• Automatically captures win/loss reasons from every deal
• Identifies patterns across hundreds of outcomes
• Generates and updates battlecards based on real data
• Surfaces insights before your next competitive deal

Let's build it.

The Cost of Not Knowing Why You Lose​

Quick math:

• You lose 40% of deals to competitors
• Average deal size: $50K
• 100 competitive deals per year
• That's $2M lost to competitors annually

If you could win just 5 more of those deals by understanding why you're losing, that's $250K in new revenue.

But most teams can't answer basic questions:

• Which competitor do we lose to most often?
• At what stage do competitive deals usually slip?
• What objections appear before we lose to Competitor X?
• What do we do differently in deals we WIN against competitors?

The Repository Architecture​

Here's what we're building:

┌─────────────────────────────────────────────────────────┐
│                    DATA SOURCES                          │
├────────────────┬────────────────┬───────────────────────┤
│  CRM Outcomes  │  Call Records  │  Exit Surveys         │
│  (Win/Loss)    │  (Gong/Chorus) │  (Lost Deal Forms)    │
└───────┬────────┴───────┬────────┴───────────┬───────────┘
        │                │                    │
        ▼                ▼                    ▼
┌─────────────────────────────────────────────────────────┐
│              AI ANALYSIS ENGINE                          │
│  - Reason extraction from transcripts                   │
│  - Pattern detection across deals                       │
│  - Competitor strength/weakness mapping                 │
│  - Win factor identification                            │
└─────────────────────────┬───────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│            COMPETITIVE KNOWLEDGE BASE                    │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐     │
│  │ Competitor  │  │ Battlecards │  │  Win/Loss   │     │
│  │  Profiles   │  │ (Dynamic)   │  │  Patterns   │     │
│  └─────────────┘  └─────────────┘  └─────────────┘     │
└─────────────────────────┬───────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│                    OUTPUTS                               │
│  - Real-time deal alerts                                │
│  - Rep coaching recommendations                         │
│  - Auto-updating battlecards                            │
│  - Competitive trends dashboard                         │
└─────────────────────────────────────────────────────────┘

Step 1: Capture Win/Loss Data​

From CRM (Structured Data)​

Set up required fields for closed deals:

// hubspot-fields.js

const requiredClosedLostFields = {
  primary_loss_reason: {
    type: 'enumeration',
    options: [
      'Competitor - Lost on Price',
      'Competitor - Lost on Features',
      'Competitor - Lost on Relationship',
      'Competitor - Lost on Brand/Trust',
      'No Decision - Status Quo',
      'No Decision - Budget Cut',
      'No Decision - Priority Shift',
      'Timing - Not Ready',
      'Internal - Poor Qualification'
    ]
  },
  competitor_lost_to: {
    type: 'enumeration',
    options: ['Gong', 'Outreach', 'Salesloft', 'Apollo', 'ZoomInfo', '6sense', 'Other']
  },
  loss_detail_notes: {
    type: 'textarea',
    description: 'Specific details about why we lost'
  }
};

const requiredClosedWonFields = {
  primary_win_reason: {
    type: 'enumeration',
    options: [
      'Product Fit - Features',
      'Product Fit - Integration',
      'Pricing/Value',
      'Relationship/Trust',
      'Speed/Timeline',
      'No Competitor (Greenfield)'
    ]
  },
  competitors_beaten: {
    type: 'enumeration',
    options: ['Gong', 'Outreach', 'Salesloft', 'Apollo', 'ZoomInfo', '6sense', 'None', 'Other'],
    multiple: true
  },
  win_detail_notes: {
    type: 'textarea'
  }
};

From Call Recordings (Unstructured Data)​

This is where AI really shines—extracting competitive intel from conversation transcripts:

// transcript-analysis.js

const analyzeTranscriptForCompetitiveIntel = async (transcript) => {
  const prompt = `
    Analyze this sales call transcript for competitive intelligence.
    
    Extract:
    1. Competitors mentioned (explicitly or implied)
    2. Comparison statements made by the prospect
    3. Objections raised that relate to competitors
    4. Features or capabilities the prospect compared
    5. Pricing discussions involving competitors
    6. Sentiment toward us vs competitors
    
    Format as JSON:
    {
      "competitors_mentioned": ["name"],
      "comparisons": [
        {
          "competitor": "name",
          "topic": "what was compared",
          "prospect_preference": "us|them|neutral",
          "quote": "relevant quote from transcript"
        }
      ],
      "competitive_objections": [
        {
          "objection": "the objection",
          "competitor_context": "how competitor relates",
          "how_handled": "what rep said" | null
        }
      ],
      "feature_gaps_mentioned": ["feature we lack that competitor has"],
      "our_advantages_mentioned": ["things prospect liked about us vs them"]
    }
    
    Transcript:
    ${transcript}
  `;
  
  const analysis = await claude.complete(prompt);
  return JSON.parse(analysis);
};

From Exit Surveys​

Create a simple lost deal survey that captures qualitative data:

// lost-deal-survey.js

const lostDealSurvey = {
  questions: [
    {
      id: 'primary_reason',
      text: 'What was the main reason you chose not to move forward with us?',
      type: 'single_choice',
      options: [
        'Went with a competitor',
        'Decided to keep current solution',
        'Project/budget was cancelled',
        'Timing wasn\'t right',
        'Product didn\'t meet our needs',
        'Pricing was too high',
        'Other'
      ]
    },
    {
      id: 'competitor_chosen',
      text: 'If you went with a competitor, which one?',
      type: 'text',
      conditional: { question: 'primary_reason', value: 'Went with a competitor' }
    },
    {
      id: 'competitor_advantage',
      text: 'What did they offer that we didn\'t?',
      type: 'textarea',
      conditional: { question: 'primary_reason', value: 'Went with a competitor' }
    },
    {
      id: 'what_would_change',
      text: 'What would have made you choose us instead?',
      type: 'textarea'
    }
  ]
};

Step 2: Pattern Analysis​

Now we analyze across all data sources to find patterns:

// pattern-analysis.js

const analyzeCompetitorPatterns = async (competitor) => {
  // Get all deals where this competitor was involved
  const lostToCompetitor = await getDealsLostTo(competitor);
  const wonAgainstCompetitor = await getDealsWonAgainst(competitor);
  
  const analysis = {
    competitor,
    summary: {
      totalDeals: lostToCompetitor.length + wonAgainstCompetitor.length,
      winRate: wonAgainstCompetitor.length / (lostToCompetitor.length + wonAgainstCompetitor.length),
      avgDealSizeWon: average(wonAgainstCompetitor.map(d => d.amount)),
      avgDealSizeLost: average(lostToCompetitor.map(d => d.amount))
    },
    
    // Why we lose
    lossReasons: groupAndCount(lostToCompetitor, 'primary_loss_reason'),
    // Example: { 'Lost on Price': 12, 'Lost on Features': 8, 'Lost on Relationship': 3 }
    
    // Why we win
    winReasons: groupAndCount(wonAgainstCompetitor, 'primary_win_reason'),
    // Example: { 'Product Fit - Integration': 15, 'Speed/Timeline': 9 }
    
    // Stage analysis
    lossStageDistribution: groupAndCount(lostToCompetitor, 'stage_when_lost'),
    winStageDistribution: groupAndCount(wonAgainstCompetitor, 'stage_when_won'),
    
    // Feature gaps (aggregated from transcripts)
    featureGaps: await aggregateFeatureGaps(competitor),
    
    // Our advantages
    ourAdvantages: await aggregateAdvantages(competitor),
    
    // Common objections
    commonObjections: await aggregateObjections(competitor)
  };
  
  // Generate AI summary
  analysis.aiSummary = await generateCompetitorSummary(analysis);
  
  return analysis;
};

Step 3: Dynamic Battlecard Generation​

Static battlecards go stale. Generate them from live data:

// battlecard-generator.js

const generateBattlecard = async (competitor) => {
  const patterns = await analyzeCompetitorPatterns(competitor);
  
  const prompt = `
    Create a sales battlecard for competing against ${competitor}.
    
    Data:
    - Win rate against them: ${(patterns.summary.winRate * 100).toFixed(0)}%
    - Top loss reasons: ${JSON.stringify(patterns.lossReasons)}
    - Top win reasons: ${JSON.stringify(patterns.winReasons)}
    - Feature gaps they exploit: ${JSON.stringify(patterns.featureGaps)}
    - Our key advantages: ${JSON.stringify(patterns.ourAdvantages)}
    - Common objections: ${JSON.stringify(patterns.commonObjections)}
    
    Format the battlecard as:
    
    ## Quick Facts
    [3-4 bullet points a rep needs to know immediately]
    
    ## Where We Win
    [Specific scenarios/criteria where we beat them]
    
    ## Where We Struggle
    [Honest assessment of their advantages]
    
    ## Objection Responses
    [Top 3-5 objections with talk tracks]
    
    ## Landmines to Set
    [Questions to ask that expose their weaknesses]
    
    ## Proof Points
    [Customer quotes/stats that help against this competitor]
    
    Be specific. Use real data. No generic platitudes.
  `;
  
  const battlecard = await claude.complete(prompt);
  
  return {
    competitor,
    generatedAt: new Date(),
    dataPoints: patterns.summary.totalDeals,
    content: battlecard,
    metadata: patterns.summary
  };
};

Example generated battlecard:

Battlecard: vs Gong​

Generated from 47 competitive deals (Last updated: Feb 9, 2026)

Quick Facts​

• Win rate: 38% (improving from 31% last quarter)
• We lose most often in Discovery stage (before we demo)
• They struggle with smaller teams (<20 reps)
• Our integration story is our biggest advantage

Where We Win​

• Teams using HubSpot — Our native integration beats their Salesforce-first approach
• Price-sensitive buyers — We're 40% cheaper at comparable tiers
• Speed to value — Our implementation averages 2 weeks vs their 6-8
• SDR-heavy teams — Our workflow focus resonates more than their analytics focus

Where We Struggle​

• Enterprise sales teams — Their brand recognition wins executive deals
• Call recording as primary need — Their core product is stronger
• Companies with Salesforce — Their integration is tighter
• Existing Gong customers — Switching costs are high

Objection Responses​

"Gong is the market leader"

"They're great for call analytics. But you mentioned your biggest challenge is SDR efficiency, not call scoring. MarketBetter was built specifically for SDR workflows—it tells your reps exactly what to do, not just what happened. Let me show you the Daily Playbook."

"Your call recording isn't as robust"

"You're right—if deep conversation intelligence is your #1 priority, Gong does that well. But from what you've described, you need your reps to book more meetings, not analyze more calls. Would you rather have perfect call transcripts or 2x the meetings to transcribe?"

"We already have Gong"

"Many of our customers use both. Gong for calls, MarketBetter for the workflow. The question is: once Gong shows you what happened on a call, what tells your reps what to do next? That's the gap we fill."

Landmines to Set​

• "How long did Gong implementation take?" (Usually 2+ months)
• "How many of your reps actually log in weekly?" (Often <50%)
• "What happens after Gong scores a call?" (Usually nothing automated)
• "Can you show me your daily SDR workflow in Gong?" (They can't)

Proof Points​

• CallRail switched from Gong: "We needed action, not just analytics"
• 3 customers running both: Use case differentiation
• Implementation time: 14 days average vs 60 for Gong

Step 4: Real-Time Deal Alerts​

When a competitive deal is identified, surface relevant intelligence:

// deal-alerts.js

const onDealUpdated = async (deal) => {
  // Check if competitor was added
  if (deal.changed.competitor && deal.competitor) {
    const battlecard = await getBattlecard(deal.competitor);
    const patterns = await analyzeCompetitorPatterns(deal.competitor);
    
    // Alert rep with relevant intel
    await slack.postMessage({
      channel: deal.owner.slackId,
      blocks: [
        {
          type: 'header',
          text: { type: 'plain_text', text: `⚔️ Competitive Deal: ${deal.name} vs ${deal.competitor}` }
        },
        {
          type: 'section',
          text: {
            type: 'mrkdwn',
            text: `*Win rate vs ${deal.competitor}:* ${(patterns.summary.winRate * 100).toFixed(0)}%\n*Key to winning:* ${patterns.winReasons[0]}\n*Watch out for:* ${patterns.lossReasons[0]}`
          }
        },
        {
          type: 'actions',
          elements: [
            {
              type: 'button',
              text: { type: 'plain_text', text: '📋 Full Battlecard' },
              url: battlecard.url
            },
            {
              type: 'button', 
              text: { type: 'plain_text', text: '🎯 Similar Wins' },
              action_id: 'show_similar_wins',
              value: JSON.stringify({ competitor: deal.competitor, dealId: deal.id })
            }
          ]
        }
      ]
    });
  }
};

Step 5: Continuous Learning​

The repository improves over time:

// learning-loop.js

// Weekly analysis
const weeklyCompetitiveReview = async () => {
  const competitors = await getActiveCompetitors();
  
  for (const competitor of competitors) {
    const currentPatterns = await analyzeCompetitorPatterns(competitor);
    const lastWeekPatterns = await getHistoricalPatterns(competitor, '7d');
    
    // Detect significant changes
    const winRateChange = currentPatterns.summary.winRate - lastWeekPatterns.summary.winRate;
    
    if (Math.abs(winRateChange) > 0.1) {
      // 10% win rate change is significant
      await slack.postMessage({
        channel: '#competitive-intel',
        text: `📊 *Win rate vs ${competitor} ${winRateChange > 0 ? 'improved' : 'declined'}* by ${Math.abs(winRateChange * 100).toFixed(0)}%\n\nNew patterns detected:\n${await summarizeChanges(currentPatterns, lastWeekPatterns)}`
      });
    }
    
    // Check if battlecard needs refresh
    const battlecard = await getBattlecard(competitor);
    const daysSinceUpdate = daysBetween(battlecard.generatedAt, new Date());
    const newDataPoints = currentPatterns.summary.totalDeals - battlecard.dataPoints;
    
    if (daysSinceUpdate > 30 || newDataPoints > 10) {
      // Regenerate battlecard
      const newBattlecard = await generateBattlecard(competitor);
      await saveBattlecard(newBattlecard);
      
      await slack.postMessage({
        channel: '#competitive-intel',
        text: `🔄 Updated battlecard for ${competitor} (${newDataPoints} new data points)\n\n*Key changes:*\n${await summarizeBattlecardChanges(battlecard, newBattlecard)}`
      });
    }
  }
};

Implementation Checklist​

Week 1: Data Capture

• Add required fields to CRM for closed deals
• Create lost deal survey workflow
• Set up transcript analysis pipeline (if using Gong/Chorus)

Week 2: Analysis Engine

• Build pattern analysis functions
• Create competitor profile structure
• Implement aggregation logic

Week 3: Battlecards

• Design battlecard template
• Build generation pipeline
• Set up storage and versioning

Week 4: Distribution

• Create deal alerts
• Build Slack integration
• Set up weekly review automation

The Payoff​

Teams with systematic win/loss analysis see:

That 13-point win rate improvement on competitive deals? On $2M in competitive pipeline, that's $260K in new wins.

What's Next?​

Once your repository is running:

1. Add market intelligence — Pull competitor pricing changes, feature announcements, hiring signals
2. Build coaching workflows — Route reps to training based on loss patterns
3. Create executive reporting — Monthly competitive landscape summaries
4. Enable product feedback — Surface feature gaps to product team systematically

Ready to stop losing deals to the same competitor twice? Book a demo to see how MarketBetter combines competitive intelligence with AI-powered SDR workflows.

Related reading:

• Building competitive battlecards with Claude
• Real-time competitive alerts
• AI objection handling

Your SDRs are alt-tabbing between 8 different tools right now. CRM, email, LinkedIn, enrichment, calendar, Slack, docs, and whatever else lives in their workflow.

What if they could just ask a question in Slack and get an answer?

"Hey, what's the latest on the Acme deal?"
"Who from our team last talked to Sarah at TechCorp?"
"What objections did we hear from manufacturing companies last quarter?"

This isn't science fiction. With OpenClaw and Claude, you can build a conversational sales assistant that:

• Answers natural language questions about your pipeline
• Pulls context from CRM, email, and call transcripts
• Suggests next actions based on deal stage
• Automates the tedious stuff your reps hate

Here's how to build it.

Why Slack? Why Now?​

Slack is where your team already lives. They're not going to adopt another dashboard, but they will ask a question in a channel they're already watching.

The numbers back this up:

• Reps spend 65% of their time on non-selling activities
• Context switching costs 23 minutes of refocus time per interruption
• Questions that take 5 minutes to research in multiple tools take 10 seconds with AI

A Slack-native assistant meets reps where they are. No new tabs. No new logins. Just type and get answers.

What We're Building​

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

1. Answer deal questions — "What stage is Acme Corp at?" pulls from HubSpot
2. Surface contact intel — "Tell me about Sarah Chen" shows enrichment data + interaction history
3. Provide competitive context — "What do we know about Gong?" pulls from your battlecards
4. Suggest next steps — "What should I do with stalled deals?" gives prioritized recommendations
5. Log activities — "Log a call with John at Acme - discussed pricing" updates CRM

Prerequisites​

Before we start:

• OpenClaw installed and configured (setup guide)
• Slack workspace with ability to create apps
• HubSpot or Salesforce API access
• 30 minutes

Step 1: Create Your Slack App​

Head to api.slack.com/apps and create a new app:

1. Click "Create New App" → "From scratch"
2. Name it "Sales Assistant" (or whatever fits your team)
3. Select your workspace

OAuth Scopes needed:

• app_mentions:read — Respond when mentioned
• channels:history — Read channel messages
• channels:read — See channel info
• chat:write — Send messages
• users:read — Look up user info

Install the app to your workspace and grab the Bot Token (xoxb-...).

Step 2: Configure OpenClaw​

Update your OpenClaw config to add Slack as a channel:

# ~/.openclaw/config.yaml
channels:
  slack:
    enabled: true
    botToken: "xoxb-your-token-here"
    signingSecret: "your-signing-secret"
    capabilities:
      - channels
      - directMessages

For detailed Slack setup, check the OpenClaw docs.

Step 3: Connect Your Data Sources​

The magic happens when your assistant can pull from multiple sources. Here's a basic setup:

// agents/sales-assistant/tools.js

// HubSpot connection
const getDeals = async (query) => {
  const deals = await hubspot.crm.deals.searchApi.doSearch({
    filterGroups: [{
      filters: [{
        propertyName: 'dealname',
        operator: 'CONTAINS_TOKEN',
        value: query
      }]
    }]
  });
  return deals.results;
};

// Contact lookup with enrichment
const getContact = async (name) => {
  const contact = await hubspot.crm.contacts.searchApi.doSearch({
    filterGroups: [{
      filters: [{
        propertyName: 'firstname',
        operator: 'CONTAINS_TOKEN', 
        value: name.split(' ')[0]
      }]
    }]
  });
  
  // Enrich with additional context
  const enriched = await enrichContact(contact);
  return enriched;
};

// Activity history
const getRecentActivities = async (dealId) => {
  const activities = await hubspot.crm.deals.associationsApi
    .getAll(dealId, 'engagements');
  return activities;
};

Step 4: Build the Agent Prompt​

This is where you define your assistant's personality and capabilities:

# Sales Assistant - System Prompt

You are a sales assistant for the \{company_name\} team. You live in Slack
and help reps work faster by answering questions and automating tasks.

## Your Capabilities

1. **Deal Intelligence** - Look up any deal by name, company, or rep
2. **Contact Research** - Pull contact info, history, and enrichment data  
3. **Competitive Intel** - Access battlecards and win/loss analysis
4. **Activity Logging** - Create CRM activities from natural language
5. **Next Best Actions** - Suggest what reps should do based on deal stage

## Your Personality

- Concise - Slack isn't the place for essays
- Helpful - Always provide actionable info
- Proactive - If you notice something, mention it

## Response Format

For deal lookups, use:
**{Deal Name}** - {Stage}
- Owner: {rep_name}
- Value: \{amount\}
- Last Activity: {date} - {description}
- Next Step: {recommendation}

For contacts, use:
**{Name}** at {Company}
- Title: {title}
- Last Contact: {date}
- Key Context: {relevant_notes}

Step 5: Add Slash Commands (Optional but Powerful)​

For frequent actions, slash commands are faster than typing questions:

// /deal [name] - Quick deal lookup
app.command('/deal', async ({ command, ack, respond }) => {
  await ack();
  
  const deal = await getDeals(command.text);
  
  if (deal) {
    await respond({
      blocks: formatDealCard(deal)
    });
  } else {
    await respond(`No deal found matching "${command.text}"`);
  }
});

// /log [activity] - Quick activity logging  
app.command('/log', async ({ command, ack, respond }) => {
  await ack();
  
  // Parse natural language: "/log call with John at Acme - discussed pricing"
  const parsed = parseActivity(command.text);
  
  await createActivity(parsed);
  await respond(`✅ Logged: ${parsed.type} with ${parsed.contact}`);
});

Real Conversations with the Bot​

Here's what it looks like in practice:

Rep: @SalesBot what's happening with the Datadog deal?

Bot:

Datadog Enterprise - Proposal Sent

• Owner: Marcus
• Value: $48,000/yr
• Last Activity: Feb 6 - Email: "Shared ROI calculator"
• Days in stage: 8

⚠️ No response in 4 days. Suggest: Follow-up call or champion check-in.

Rep: @SalesBot tell me about Jennifer Walsh

Bot:

Jennifer Walsh at Cloudflare

• Title: VP of Sales Operations
• Reports to: CRO (Mike Chen)
• Last Contact: Jan 28 (Demo call)
• LinkedIn: 2,400 followers, posts about RevOps

Context from CRM: "Budget owner for sales tools. Previous Outreach customer. Concerned about implementation timeline."

Rep: @SalesBot what objections are we hearing from fintech companies?

Bot:

Top objections from Fintech (last 90 days):

1. Security/Compliance (43% of deals) - They need SOC 2, ask about data handling
2. Integration complexity (28%) - Worried about Salesforce custom objects
3. Existing vendor lock-in (21%) - Usually with ZoomInfo or 6sense

Win rate when security objection surfaces: 34% Win rate when handled with compliance deck: 67%

📎 Fintech Security Battlecard

Advanced: Proactive Deal Alerts​

Don't just wait for questions—push insights when they matter:

// OpenClaw cron job - runs every morning at 8am
const morningBriefing = async () => {
  const stuckDeals = await getDealsStuckInStage(7); // 7+ days
  const upcomingRenewals = await getRenewalsNext30Days();
  const hotLeads = await getHighIntentVisitors();
  
  for (const rep of salesTeam) {
    const repDeals = stuckDeals.filter(d => d.owner === rep.id);
    const repRenewals = upcomingRenewals.filter(d => d.owner === rep.id);
    
    if (repDeals.length > 0 || repRenewals.length > 0) {
      await slack.postMessage({
        channel: rep.slackId,
        text: formatMorningBrief(repDeals, repRenewals, hotLeads)
      });
    }
  }
};

Example morning message:

☀️ Morning Brief for Marcus

Stuck Deals (7+ days in stage):

• Datadog Enterprise - Proposal Sent - 8 days
• MongoDB - Demo Scheduled - 12 days

Renewals in 30 days:

• TechCorp ($24K) - Renews Feb 28

Hot Website Visitors:

• Stripe (3 visits yesterday, pricing page)
• Notion (Downloaded case study)

Performance Impact​

Teams using conversational Slack assistants see:

• 40% reduction in time spent looking up information
• 25% increase in CRM data quality (easier to log = more logs)
• 3x faster response to deal questions from leadership
• Happier reps (seriously, they love this)

Common Pitfalls to Avoid​

1. Making the bot too chatty Nobody wants a wall of text in Slack. Keep responses tight.

2. Not handling "I don't know" When the bot can't find something, be clear about it. Don't hallucinate deals.

3. Forgetting permissions Make sure the bot only shows reps their own deals (or team deals if appropriate).

4. Over-automating Some things should stay manual. Don't auto-send emails without human review.

What's Next?​

Once your basic assistant is running:

1. Add more data sources — Connect Gong/Chorus for call insights
2. Build approval workflows — "Draft an email to Jennifer" → rep approves → sends
3. Create team dashboards — Weekly pipeline summaries posted to #sales
4. Enable voice — Let reps dictate notes that get logged to CRM

The goal isn't to replace reps—it's to give them superpowers.

Get Started​

Want to see this in action with your own data? Book a demo and we'll show you how MarketBetter's AI SDR workflows combine with Slack to create a seamless selling experience.

Already using OpenClaw? Check out our other integration guides:

• OpenClaw + HubSpot automation
• Building deal room alerts
• AI meeting follow-ups

The best tool is the one your team actually uses. Meet them in Slack.

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
  };
};