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.

Wondering whether Claude can plug into LinkedIn directly? It can't — there is no native connector, and the workarounds carry very different risk levels. We break down all three options in Can Claude connect to LinkedIn? before you commit to a workflow.

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')

Step 2: Cultural Context Injection​

This is where AI shines. Claude Code can incorporate cultural business norms:

# Cultural context for outreach generation
CULTURAL_CONTEXTS = {
    'de-DE': {
        'formality': 'high',
        'greeting': 'Sehr geehrte/r {title} {last_name}',
        'sign_off': 'Mit freundlichen Grüßen',
        'tone': 'professional, direct, data-driven',
        'avoid': ['humor in first touch', 'overly casual language', 'first name without permission'],
        'include': ['company credentials', 'specific numbers', 'clear next steps'],
        'timing': 'Avoid Friday afternoon, Germans leave early',
        'title_importance': 'Always use Dr., Prof., etc. if applicable'
    },
    'fr-FR': {
        'formality': 'high',
        'greeting': 'Bonjour {title} {last_name}',
        'sign_off': 'Cordialement',
        'tone': 'elegant, relationship-focused, sophisticated',
        'avoid': ['jumping to business immediately', 'aggressive follow-ups'],
        'include': ['mutual connections', 'thoughtful opening', 'respect for their time'],
        'timing': 'Never during August (vacances), lunch is sacred (12-14h)',
        'title_importance': 'Use Monsieur/Madame always'
    },
    'ja-JP': {
        'formality': 'very_high',
        'greeting': '{last_name}様',
        'sign_off': 'よろしくお願いいたします',
        'tone': 'humble, respectful, group-oriented',
        'avoid': ['direct criticism', 'rushing decisions', 'singling out individuals'],
        'include': ['company introduction first', 'consensus-building language', 'long-term perspective'],
        'timing': 'Respect hierarchy—contact appropriate level',
        'title_importance': 'San (様) required, company name before person'
    },
    'es-MX': {
        'formality': 'medium-high',
        'greeting': 'Estimado/a {title} {last_name}',
        'sign_off': 'Saludos cordiales',
        'tone': 'warm, personal, relationship-oriented',
        'avoid': ['rushing', 'cold/impersonal tone', 'ignoring small talk'],
        'include': ['personal touch', 'reference to mutual benefit', 'flexibility in timing'],
        'timing': 'Meetings often start late, be patient',
        'title_importance': 'Licenciado/Ingeniero common for professionals'
    },
    'pt-BR': {
        'formality': 'medium',
        'greeting': 'Prezado/a \{first_name\}',
        'sign_off': 'Atenciosamente',
        'tone': 'friendly, enthusiastic, personal',
        'avoid': ['being too formal', 'negative framing'],
        'include': ['relationship building', 'optimism', 'personal connection'],
        'timing': 'Carnaval and major holidays are dead periods',
        'title_importance': 'First names common after initial contact'
    }
}

def get_cultural_context(language_code):
    return CULTURAL_CONTEXTS.get(language_code, CULTURAL_CONTEXTS['en-US'])

Step 3: Native-Quality Generation with Claude​

This is the key insight: Claude doesn't translate. Claude creates.

When you ask Claude to write a cold email in German, it doesn't write in English and translate. It thinks in German business culture and generates natively.

# Native-language outreach generation with Claude Code
async def generate_localized_outreach(prospect, language_code):
    """
    Generates culturally-appropriate outreach in target language
    """
    
    cultural_context = get_cultural_context(language_code)
    
    prompt = f"""
    Generate a cold outreach email for a B2B SaaS product.
    
    LANGUAGE: {language_code}
    
    PROSPECT:
    - Name: {prospect['name']}
    - Title: {prospect['title']}
    - Company: {prospect['company']}
    - Industry: {prospect['industry']}
    
    CULTURAL REQUIREMENTS:
    - Formality level: {cultural_context['formality']}
    - Greeting format: {cultural_context['greeting']}
    - Sign-off: {cultural_context['sign_off']}
    - Tone: {cultural_context['tone']}
    - AVOID: {', '.join(cultural_context['avoid'])}
    - INCLUDE: {', '.join(cultural_context['include'])}
    
    PRODUCT VALUE PROP:
    - Automates SDR workflows
    - 70% reduction in manual research time
    - 2x faster lead response
    
    CONSTRAINTS:
    - Write NATIVELY in {language_code}, do not translate from English
    - Respect all cultural norms listed above
    - Keep under 150 words
    - Include ONE clear call to action
    - Do not use English words unless they are standard industry terms
    
    Generate the complete email including subject line.
    """
    
    response = await claude.generate(
        prompt=prompt,
        model='claude-3-opus',
        max_tokens=500
    )
    
    return {
        'language': language_code,
        'subject': extract_subject(response),
        'body': extract_body(response),
        'cultural_notes': cultural_context
    }

Example output (German):

Betreff: Effizienzsteigerung im Vertrieb bei {Company}

Sehr geehrter Herr Dr. Müller,

als Leiter des Vertriebsteams bei {Company} kennen Sie die Herausforderung: Ihr Team verbringt mehr Zeit mit Recherche als mit Verkaufsgesprächen.

Unsere Kunden berichten von einer 70%igen Reduzierung des manuellen Aufwands bei der Lead-Qualifizierung. Für ein Unternehmen Ihrer Größe bedeutet das durchschnittlich 15 zusätzliche Stunden pro Woche für wertschöpfende Aktivitäten.

Wäre ein kurzes Gespräch nächste Woche möglich, um zu besprechen, wie dies auch bei {Company} funktionieren könnte?

Mit freundlichen Grüßen, [Name]

Notice: No "Hi Thomas!" No casual American tone. Professional German business communication.

Step 4: Localized Follow-Up Cadences​

Different cultures have different expectations for follow-up:

# Culture-specific follow-up cadences
cadences:
  de-DE:
    name: "German Professional"
    steps:
      - day: 0
        channel: email
        note: "Initial outreach, formal"
      - day: 5
        channel: email
        note: "Value-add follow-up with data/case study"
      - day: 12
        channel: linkedin
        note: "Connection request with personalized note"
      - day: 18
        channel: email
        note: "Final attempt, offer alternative contact"
    notes: "Germans appreciate persistence but not pressure. Data > emotion."
    
  fr-FR:
    name: "French Relationship"
    steps:
      - day: 0
        channel: email
        note: "Thoughtful introduction, reference mutual connection if possible"
      - day: 7
        channel: linkedin
        note: "Connect and engage with their content first"
      - day: 14
        channel: email
        note: "Reference their recent work/news, suggest coffee"
      - day: 21
        channel: call
        note: "If engaged, phone call (never cold)"
    notes: "Relationship first. Never rush. August is dead."
    
  ja-JP:
    name: "Japanese Formal"
    steps:
      - day: 0
        channel: email
        note: "Formal introduction of company and purpose"
      - day: 10
        channel: email
        note: "Follow-up with additional company credentials"
      - day: 21
        channel: introduction
        note: "Seek warm introduction through mutual contact"
      - day: 35
        channel: email
        note: "Gentle follow-up, offer to meet at their convenience"
    notes: "Patience is essential. Group decision-making takes time. Warm intros > cold."

Automating with OpenClaw​

Here's how to tie it all together with continuous multi-language campaigns:

# Multi-language outreach automation with OpenClaw
schedule:
  kind: cron
  expr: "0 8 * * *"  # Daily at 8am

payload:
  kind: agentTurn
  message: |
    Process today's international outreach queue:
    
    1. LANGUAGE DETECTION
       For each new prospect without assigned language:
       - Detect appropriate language
       - Assign cultural context
       - Log decision reasoning
    
    2. CONTENT GENERATION
       For prospects needing outreach:
       - Generate native-language email using cultural context
       - Ensure compliance with regional requirements (GDPR for EU, etc.)
       - Queue for review if confidence < 90%
    
    3. TIMING OPTIMIZATION
       Adjust send times for recipient timezone:
       - DE/FR/EU: 9-10am local
       - JP: 10-11am local
       - LATAM: 10-11am local
       - Respect cultural no-send times (Friday PM for DE, August for FR)
    
    4. FOLLOW-UP MANAGEMENT
       Check prospects in active sequences:
       - Advance to next step if appropriate
       - Adjust based on engagement signals
       - Flag any responses for native review
    
    Report: Languages processed, emails generated, cultural flags raised

Quality Assurance: When to Get Human Review​

AI-generated foreign language outreach is good—but not perfect. Build in review for:

High-stakes situations:

• Enterprise deals (> $100K potential)
• Sensitive industries (government, healthcare)
• Cultures with high formality requirements (Japan, Korea)

Low-confidence scenarios:

• Mixed signals on language preference
• Unusual name origins
• Multi-national companies (HQ vs local office)

# Quality assurance routing
def route_for_review(outreach, prospect):
    """
    Determines if AI-generated outreach needs human review
    """
    
    needs_review = False
    reasons = []
    
    # High-value deals
    if prospect['estimated_acv'] > 100000:
        needs_review = True
        reasons.append('High ACV - enterprise touch required')
    
    # High-formality cultures
    if outreach['language'] in ['ja-JP', 'ko-KR', 'zh-CN']:
        needs_review = True
        reasons.append('High-formality culture - native review recommended')
    
    # Low confidence detection
    if outreach['language_confidence'] < 0.85:
        needs_review = True
        reasons.append(f"Language detection confidence: {outreach['language_confidence']}")
    
    # First outreach in new language
    if not has_previous_success(outreach['language']):
        needs_review = True
        reasons.append('First campaign in this language - establish baseline')
    
    return {
        'needs_review': needs_review,
        'reasons': reasons,
        'reviewer_type': 'native_speaker' if needs_review else None
    }

Measuring Success Across Languages​

Track these metrics by language:

Expected benchmarks:

Lower absolute numbers in Japan are normal—decision cycles are longer but deal sizes often larger.

Implementation Roadmap​

Week 1: Market Selection

• Identify top 3-5 target markets beyond English
• Research cultural business norms for each
• Document language-specific requirements

Week 2: Detection & Context

• Build language detection pipeline
• Create cultural context files for each market
• Test detection accuracy on existing prospects

Week 3: Generation & Testing

• Configure Claude prompts for each language
• Generate sample outreach, get native review
• Refine based on feedback

Week 4: Launch & Measure

• Deploy multi-language campaigns
• Track metrics by language
• Iterate on underperforming regions

The Global Opportunity​

Most B2B companies leave international markets to competitors because "we don't have German speakers."

That's no longer an excuse.

With Claude Code generating native-quality outreach and OpenClaw automating the workflow, your 5-person SDR team can cover markets that used to require 50.

The companies expanding fastest aren't the ones with the biggest teams. They're the ones with the smartest systems.

Build yours.

Want to see how MarketBetter helps teams scale personalized outreach globally?

Book a Demo →

OpenAI released GPT-5.3-Codex on February 5, 2026—their most capable agentic coding model yet. The Codex CLI puts this power at your fingertips, letting you automate GTM tasks directly from your terminal.

This guide covers everything GTM teams need to know: installation, essential commands, and real workflows for sales automation, content generation, and pipeline management. For ready-to-run prompts, pair it with our 30 best Codex prompts for sales and GTM.

What's New in GPT-5.3 Codex​

Before diving into the CLI, here's why GPT-5.3 matters:

The killer feature? Mid-turn steering—you can direct Codex while it's working, correcting course without starting over.

Installing the Codex CLI​

Get started in 60 seconds:

# Install globally via npm
npm install -g @openai/codex

# Verify installation
codex --version
# codex 1.4.0 (gpt-5.3-codex)

# Authenticate
codex auth login
# Opens browser for OpenAI authentication

First Run​

Test your installation:

codex "explain what you can do for a sales team"

You should see Codex describe its capabilities for sales automation, data analysis, and content generation.

Essential Codex Commands for GTM​

Basic Syntax​

codex "<natural language task>"

Codex interprets your request and executes the appropriate actions. You can also:

# Run in a specific directory
codex --cwd /path/to/project "<task>"

# Include files for context
codex --include "*.csv" "<task>"

# Set output format
codex --output json "<task>"

# Enable mid-turn steering
codex --interactive "<task>"

The --interactive Flag (Mid-Turn Steering)​

This is GPT-5.3's superpower. Instead of waiting for Codex to finish, you can course-correct in real-time:

codex --interactive "analyze our pipeline and suggest improvements"

While Codex works, you can type commands like:

• focus on deals stuck longer than 30 days
• ignore deals under $10K
• also check for missing next steps

Codex adjusts its analysis mid-stream without starting over.

GTM Workflows with Codex CLI​

1. Pipeline Analysis​

Analyze your CRM data directly:

# Export pipeline from your CRM first (or connect via API)
codex --include "pipeline.csv" "
Analyze this sales pipeline and identify:
1. Deals that have been stuck in the same stage for >30 days
2. Deals with no recent activity
3. Deals missing next steps
4. Predicted close rates by stage

Output as a prioritized action list for the sales manager.
"

Sample output:

## Pipeline Health Report

### 🚨 Stuck Deals (30+ days same stage)
1. Acme Corp - Proposal stage for 47 days - $85K
   → Action: Escalate to VP Sales, consider discount strategy
2. TechStart Inc - Demo stage for 38 days - $32K
   → Action: Re-engage champion, check for competing eval

### ⚠️ Missing Next Steps (23 deals)
- Priority 1: Deals >$50K with no activity last 14 days
- Recommend: Mandatory next-step field in CRM

### 📊 Stage Conversion Rates
- Lead → Discovery: 42% (healthy)
- Discovery → Demo: 68% (above benchmark)
- Demo → Proposal: 31% (⚠️ below benchmark 45%)
- Proposal → Closed Won: 28% (needs attention)

2. Lead Research at Scale​

Research a list of leads:

codex --include "leads.csv" --output json "
For each company in this list:
1. Find their LinkedIn company page
2. Get employee count and recent funding
3. Identify likely decision makers in Sales/Marketing
4. Note any recent news or hiring signals

Output as enriched JSON with research_notes for each lead.
"

3. Email Sequence Generation​

Generate personalized email sequences:

codex "
Create a 5-email sequence for SDR outreach to VP of Sales at mid-market SaaS companies.

Context: We're MarketBetter, an AI-powered SDR platform.
Pain point: SDR productivity and lead prioritization
Differentiator: We tell SDRs WHO to contact AND WHAT to do

Requirements:
- Email 1: Cold intro, <100 words
- Email 2: Value-add (share relevant content)
- Email 3: Social proof (customer results)
- Email 4: Direct ask for meeting
- Email 5: Breakup email

Include subject lines and personalization tokens.
"