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.

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.
"

4. Competitor Analysis​

Research competitors systematically:

codex --interactive "
Research these competitors and create a comparison matrix:
- Warmly
- 6sense
- Apollo
- ZoomInfo

For each, find:
1. Pricing (actual prices, not just 'contact us')
2. Key features
3. G2 rating and top complaints
4. Recent product updates
5. Where MarketBetter wins

I'll guide you as you research.
"

With --interactive, you can steer:

• "Dig deeper on Warmly's pricing—check G2 reviews for price mentions"
• "Skip ZoomInfo, we have that already"
• "Focus more on their visitor identification capabilities"

5. Meeting Prep​

Prepare for sales calls:

codex "
I have a demo call with Sarah Chen, VP Sales at DataFlow Inc.

Research:
1. Sarah's LinkedIn background
2. DataFlow Inc recent news/funding
3. Their current tech stack (from job postings)
4. Common challenges for companies their size
5. 3 personalized talking points

Also draft 3 discovery questions specific to their situation.
"

6. Content Generation​

Generate blog post outlines:

codex "
Create an outline for a blog post: 'Why Intent Data Fails Without Action'

Target keyword: intent data for sales
Word count: 2000 words
Audience: VP Sales, SDR Managers

Include:
- Compelling intro hook
- 5-7 main sections with subheadings
- Data points to research
- CTA to MarketBetter demo

Make it contrarian—most content says intent data is magic. 
We say it's useless without the action layer.
"

7. CRM Data Cleanup​

Fix messy CRM data:

codex --include "contacts.csv" "
Clean this contact list:
1. Standardize company names (remove Inc., LLC variants)
2. Fix obvious email typos (@gmial.com, etc.)
3. Parse full names into first/last
4. Flag likely duplicates
5. Validate phone number formats

Output as cleaned CSV with a 'changes_made' column.
"

Advanced Codex Patterns​

Chaining Commands​

Build complex workflows:

# Research → Enrich → Generate sequence
codex "research DataFlow Inc" > /tmp/research.txt && \
codex --include /tmp/research.txt "generate 3 personalized email openers based on this research"

Template-Based Generation​

Create reusable prompt templates:

# Save as ~/.codex/templates/competitor-analysis.txt
cat << 'EOF' > ~/.codex/templates/competitor-analysis.txt
Research {{COMPETITOR}} and provide:
1. Company overview (employees, funding, HQ)
2. Product positioning
3. Pricing structure
4. Key differentiators
5. Customer complaints (from G2/Capterra)
6. How we beat them

Format as markdown with clear sections.
EOF

# Use the template
codex --template competitor-analysis COMPETITOR=Warmly

Integration with Other Tools​

Combine Codex with your existing stack:

# Pull from HubSpot, analyze with Codex, push back
hubspot contacts list --limit 100 --format csv > leads.csv
codex --include leads.csv "score these leads 1-100 based on fit for AI SDR tools"
# Parse output and update HubSpot via API

Codex CLI vs Claude Code vs ChatGPT​

When to use each:

The real answer? Use them together. Codex for structured tasks and code, Claude for nuanced writing and analysis.

Cost Considerations​

Codex CLI usage is charged per token:

For most GTM teams, budget $50-100/month for heavy CLI usage. Compare that to the hours saved.

Common Gotchas​

1. Rate Limits​

Free tier: 20 requests/minute. Paid: 100 requests/minute.

For batch processing:

# Add delays between requests
for company in $(cat companies.txt); do
  codex "research $company"
  sleep 3
done

2. Context Limits​

Even with 100K tokens, large files need chunking:

# Process large CSV in chunks
split -l 100 huge_leads.csv chunk_
for chunk in chunk_*; do
  codex --include $chunk "process this batch"
done

3. Output Consistency​

For structured output, be explicit:

# Bad: "analyze this data"
# Good:
codex "analyze this data and return JSON with fields: 
{insights: string[], recommendations: string[], priority: high|medium|low}"

The MarketBetter Integration​

MarketBetter uses the same AI models under the hood—but packages them into a complete GTM platform:

• Daily Playbook — Codex-style analysis of your entire pipeline, delivered as actionable tasks
• AI Chatbot — GPT-5.3 powers real-time lead qualification
• Smart Dialer — AI-prioritized call lists based on intent signals
• Email Automation — Personalized sequences generated at scale

The difference? MarketBetter eliminates the prompting and integration work. Your SDRs get AI-powered insights without touching a command line.

See how MarketBetter turns AI into pipeline →

Quick Reference Card​

# Installation
npm install -g @openai/codex
codex auth login

# Basic usage
codex "<task>"

# With file context
codex --include "data.csv" "<task>"

# Interactive mode (mid-turn steering)
codex --interactive "<task>"

# JSON output
codex --output json "<task>"

# Specific directory
codex --cwd /path/to/project "<task>"

# Help
codex --help

Getting Started Checklist​

• Install Codex CLI (npm install -g @openai/codex)
• Authenticate (codex auth login)
• Test basic command
• Try --interactive mode
• Export CRM data for analysis
• Create first prompt template
• Set up shell alias for common tasks
• Budget token usage

The Codex CLI puts GPT-5.3's power directly in your terminal. For GTM teams, that means faster research, smarter analysis, and more personalized outreach—all from the command line.

Want more AI automation for GTM? Check out Codex vs Claude Code for sales automation and building AI agents with OpenClaw.

Here's a brutal truth about B2B demos: 68% of prospects say demos are too generic. They sit through 45 minutes of features they don't care about, waiting for the one capability that actually solves their problem. Most never make it to that point—they've already mentally checked out.

The companies winning in 2026 don't run generic demos. They run shows that feel custom-built for each prospect. And with OpenAI's GPT-5.3 Codex (released February 5, 2026), building that personalization engine is now accessible to any GTM team.

This guide shows you how to use Codex's agentic capabilities to automatically generate personalized demo scripts, custom slide decks, and industry-specific talking points—all from your CRM data and meeting notes.

Why Generic Demos Lose Deals​

The data is clear:

• 68% of buyers say demos don't address their specific needs
• 52% of prospects decide within the first 5 minutes if they'll buy
• 44% of buyers abandon vendors who can't explain relevance to their business
• Personalized demos have a 45% higher close rate than generic ones

The problem isn't that AEs don't want to personalize—it's that personalization takes time they don't have. Research the company, customize the slides, reorder features for relevance, find the right case study, rehearse the new flow... that's 1-2 hours of prep per demo.

Most reps are running 3-5 demos per day. The math doesn't work.

What Makes a Demo Feel Personalized?​

Before automating, let's break down what "personalized" actually means:

1. Relevant Opening​

Don't start with your product. Start with their world:

• Recent company news or announcements
• Industry-specific challenges
• Reference to their stated pain points

2. Reordered Feature Sequence​

Show them what they care about first:

• Lead with the capability they asked about
• Skip or minimize features irrelevant to their use case
• Save "nice-to-haves" for Q&A

3. Industry-Specific Language​

Speak their language:

• Use their industry's terminology
• Reference their competitive landscape
• Cite metrics that matter in their world

4. Relevant Social Proof​

Show them peers, not just logos:

• Case studies from similar company size
• Same industry or use case
• Metrics that map to their goals

5. Custom Demo Environment​

When possible, show their reality:

• Their company name in the demo
• Realistic sample data for their industry
• Workflows that match their process

GPT-5.3 Codex: Built for Agentic Personalization​

OpenAI's Codex (released February 5, 2026) is specifically designed for agentic tasks like demo personalization. Key capabilities:

• Mid-turn steering — Direct the agent while it works, perfect for iterative customization
• 25% faster — Get personalization outputs in seconds, not minutes
• Multi-file context — Understands your entire demo deck + CRM data simultaneously
• Code + content — Can generate both slides content AND automation scripts

Here's the architecture for an automated demo personalization system:

Building the Demo Personalization Engine​

Step 1: Gather Prospect Intelligence​

First, compile everything you know about the prospect:

async function gatherDemoContext(dealId) {
  // CRM data
  const deal = await crm.getDeal(dealId);
  const company = await crm.getCompany(deal.companyId);
  const contacts = await crm.getContacts(deal.contactIds);
  
  // Meeting history
  const meetings = await crm.getMeetings(dealId);
  const discoveryNotes = meetings
    .filter(m => m.type === 'discovery')
    .map(m => m.notes)
    .join('\n');
  
  // Enrich with external data
  const companyNews = await newsApi.search({
    company: company.name,
    daysBack: 30
  });
  
  const industryTrends = await getIndustryInsights(company.industry);
  
  // Find relevant case studies
  const relevantCaseStudies = await caseStudyDb.find({
    industry: company.industry,
    size: company.employeeRange,
    useCase: deal.primaryUseCase
  });
  
  // Get competitor intel
  const competitorMentions = extractCompetitors(discoveryNotes);
  const competitorIntel = await getCompetitorBattlecards(competitorMentions);
  
  return {
    company,
    contacts,
    deal,
    discoveryNotes,
    companyNews,
    industryTrends,
    caseStudies: relevantCaseStudies,
    competitors: competitorIntel
  };
}

Step 2: Generate the Demo Script with Codex​

Use GPT-5.3 Codex to generate a personalized demo flow:

const { OpenAI } = require('openai');
const codex = new OpenAI({ model: 'gpt-5.3-codex' });

async function generateDemoScript(context) {
  const response = await codex.chat.completions.create({
    model: 'gpt-5.3-codex',
    messages: [
      {
        role: 'system',
        content: `You are an expert sales demo strategist. Generate a 
personalized demo script that will resonate with this specific prospect.

DEMO STRUCTURE:
1. Personalized Opening (2 min) - Reference their world
2. Pain Validation (3 min) - Confirm what you heard in discovery  
3. Priority Feature #1 (10 min) - What they care most about
4. Priority Feature #2 (8 min) - Second most relevant
5. Integration/Workflow (5 min) - How it fits their stack
6. Social Proof (3 min) - Case study from similar company
7. Pricing Context (2 min) - Frame value, not cost
8. Next Steps (2 min) - Clear path forward

OUTPUT FORMAT:
- Include speaker notes for each section
- Add talk tracks for common objections
- Include specific data points to mention
- Flag areas needing live customization`
      },
      {
        role: 'user',
        content: `Create a demo script for this opportunity:

COMPANY: ${context.company.name}
INDUSTRY: ${context.company.industry}
SIZE: ${context.company.employeeCount} employees
REVENUE: $${context.company.revenue}M

DISCOVERY INSIGHTS:
${context.discoveryNotes}

KEY PAIN POINTS IDENTIFIED:
${extractPainPoints(context.discoveryNotes).join('\n- ')}

RECENT COMPANY NEWS:
${context.companyNews.map(n => `- ${n.headline}`).join('\n')}

RELEVANT CASE STUDY:
${JSON.stringify(context.caseStudies[0])}

COMPETITORS MENTIONED:
${context.competitors.map(c => c.name).join(', ')}

Generate a complete, personalized demo script.`
      }
    ],
    max_tokens: 4000,
    response_format: { type: 'json_object' }
  });
  
  return JSON.parse(response.choices[0].message.content);
}

Step 3: Customize the Slide Deck​

Codex can also modify your master deck for each prospect:

async function customizeSlideDeck(masterDeck, context, demoScript) {
  // Parse the master deck (Google Slides, PowerPoint, etc.)
  const slides = await parseDeck(masterDeck);
  
  const customizations = await codex.chat.completions.create({
    model: 'gpt-5.3-codex',
    messages: [
      {
        role: 'system',
        content: `You are customizing a sales demo deck. For each slide,
determine what changes are needed for this specific prospect.

Types of customizations:
1. TEXT_REPLACE - Swap placeholder text
2. REORDER - Move slide to different position
3. SKIP - Mark slide to hide
4. ADD_DATA - Insert prospect-specific data
5. CASE_STUDY_SWAP - Replace case study content`
      },
      {
        role: 'user',
        content: `MASTER DECK SLIDES:
${slides.map((s, i) => `[${i}] ${s.title}: ${s.content.substring(0, 200)}`).join('\n')}

PROSPECT CONTEXT:
Company: ${context.company.name}
Industry: ${context.company.industry}
Pain Points: ${extractPainPoints(context.discoveryNotes).join(', ')}

DEMO SCRIPT FLOW:
${demoScript.sections.map(s => s.title).join(' → ')}

RELEVANT CASE STUDY:
${JSON.stringify(context.caseStudies[0])}

Output a JSON array of customization instructions.`
      }
    ]
  });
  
  // Apply customizations
  const customizedDeck = applyCustomizations(slides, customizations);
  
  return customizedDeck;
}

Step 4: Generate Talking Points and Objection Handlers​

Pre-arm your AE with responses to likely objections:

async function generateObjectionHandlers(context) {
  const handlers = await codex.chat.completions.create({
    model: 'gpt-5.3-codex',
    messages: [
      {
        role: 'system',
        content: `Generate objection handling scripts specific to this 
prospect's context. Include:
- The likely objection based on their situation
- Why they might raise it
- Data-backed response
- Reframe to positive

Be specific, not generic.`
      },
      {
        role: 'user',
        content: `PROSPECT CONTEXT:
Industry: ${context.company.industry}
Company Size: ${context.company.employeeCount}
Current Tools: ${context.deal.currentSolution}
Budget Range: ${context.deal.budget}
Competitors Evaluating: ${context.competitors.map(c => c.name).join(', ')}

DISCOVERY CONCERNS:
${extractConcerns(context.discoveryNotes).join('\n')}

Generate 5 likely objections with tailored responses.`
      }
    ]
  });
  
  return handlers.choices[0].message.content;
}

Real-World Example: Manufacturing Company Demo​

Input:

• Company: Precision Parts Inc. (450 employees, manufacturing)
• Pain Points: "Reps don't know which accounts to prioritize" + "No visibility into what competitors are doing"
• Current Tools: Salesforce + spreadsheets
• Competitor Evaluating: ZoomInfo

Generated Demo Script (excerpt):

{
  "opening": {
    "duration": "2 minutes",
    "personalizedHook": "I saw Precision Parts just announced the expansion into aerospace components last month—congratulations. That kind of move into a new vertical is exactly where prioritization becomes critical. You mentioned your reps don't know which accounts to focus on—let me show you how that changes today.",
    "speakerNotes": "Reference their Jan 15 press release. Don't dwell—use as credibility builder that you did your homework."
  },
  
  "painValidation": {
    "duration": "3 minutes",
    "talkTrack": "In our discovery call, you mentioned two things that stuck with me: first, your 8-person sales team is essentially flying blind on account prioritization. Second, you're concerned about what competitors are doing in the aerospace space. Did I capture that right?",
    "transition": "Let me show you how we solve both of those—starting with prioritization since you said that's the bigger fire right now."
  },
  
  "featurePriority1": {
    "feature": "Account Prioritization & ICP Scoring",
    "duration": "10 minutes",
    "customization": "Show manufacturing-specific signals: plant expansions, equipment purchases, regulatory filings",
    "industryLanguage": "Use terms: 'tier-1 supplier', 'OEM relationships', 'MRO contracts'",
    "relevantMetric": "Manufacturing companies see 34% faster deal cycles with intent-based prioritization"
  },
  
  "featurePriority2": {
    "feature": "Competitive Intelligence Dashboard",
    "duration": "8 minutes",
    "customization": "Pre-load demo environment with aerospace competitors they mentioned",
    "differentiator": "Unlike ZoomInfo (which they're evaluating), show real-time monitoring vs static database"
  },
  
  "socialProof": {
    "caseStudy": "Allied Manufacturing",
    "relevance": "Same size (500 emp), same industry, same Salesforce integration",
    "metric": "2.3x increase in qualified pipeline within 90 days",
    "quote": "'Finally, my team knows where to focus without me micromanaging.'"
  },
  
  "objectionPrep": [
    {
      "objection": "ZoomInfo has more data",
      "context": "They mentioned evaluating ZoomInfo",
      "response": "ZoomInfo has great contact data—we actually integrate with them. The difference is what you DO with that data. ZoomInfo tells you WHO exists. We tell you WHO to call and WHAT to say. For manufacturers entering new verticals like aerospace, it's the prioritization layer that moves the needle.",
      "proof": "Allied Manufacturing uses both. They said ZoomInfo fills the top of funnel, we tell them where to focus."
    }
  ]
}

Mid-Turn Steering: Codex's Killer Feature​

What makes GPT-5.3 Codex special for demo personalization is mid-turn steering. You can direct the agent while it's generating:

// Start generation
const stream = codex.chat.completions.create({
  model: 'gpt-5.3-codex',
  messages: [...],
  stream: true
});

// Monitor and steer mid-generation
for await (const chunk of stream) {
  const partialOutput = chunk.choices[0].delta.content;
  
  // If going off-track, inject steering
  if (partialOutput.includes('generic feature list')) {
    await stream.steer({
      instruction: 'Focus on manufacturing-specific capabilities only'
    });
  }
}

This means you can build interactive personalization tools where AEs can guide the AI in real-time—combining human judgment with AI speed.

Integration with Demo Workflow​

Pre-Demo Automation​

// Trigger 2 hours before scheduled demo
cron.schedule('0 */1 * * *', async () => {
  const upcomingDemos = await calendar.getDemos({
    timeWindow: '2-3 hours from now'
  });
  
  for (const demo of upcomingDemos) {
    const context = await gatherDemoContext(demo.dealId);
    const script = await generateDemoScript(context);
    const deck = await customizeSlideDeck(MASTER_DECK, context, script);
    const handlers = await generateObjectionHandlers(context);
    
    // Send prep package to AE
    await slack.sendDM(demo.ownerId, {
      text: `🎯 Demo prep ready for ${context.company.name} in 2 hours`,
      attachments: [
        { title: 'Personalized Script', content: script },
        { title: 'Custom Deck', url: deck.url },
        { title: 'Objection Handlers', content: handlers }
      ]
    });
  }
});

Post-Demo Follow-Up Generation​

// After demo ends, generate follow-up
async function postDemoAutomation(demoId, demoNotes) {
  const context = await gatherDemoContext(demoId);
  
  // Generate personalized follow-up based on what happened
  const followUp = await codex.chat.completions.create({
    model: 'gpt-5.3-codex',
    messages: [{
      role: 'user',
      content: `Based on this demo, generate follow-up:

DEMO NOTES:
${demoNotes}

ORIGINAL CONTEXT:
${JSON.stringify(context)}

Generate:
1. Follow-up email addressing specific questions raised
2. Relevant resources to send
3. Suggested next step with timeline`
    }]
  });
  
  return followUp;
}

Measuring Personalization ROI​

Track these metrics to prove the value:

The math: If personalization increases your demo-to-close rate by 20% and you run 50 demos/month at $40K ACV, that's an additional $400K in ARR annually.

Getting Started with MarketBetter​

Building demo personalization is powerful, but it's just one piece of the puzzle. MarketBetter provides the complete AI-powered sales enablement stack:

• Automated demo prep — Personalized scripts and decks generated before every call
• Real-time battle cards — Competitor intel surfaced when you need it
• CRM integration — Pulls from HubSpot/Salesforce, no manual context gathering
• Meeting analysis — Learns from every demo to improve recommendations

The goal isn't to replace AEs—it's to give them superpowers. Let AI handle the personalization heavy-lifting so your team can focus on building relationships and closing deals.

Book a Demo →

Key Takeaways​

1. Generic demos lose deals — 68% of buyers say demos don't address their needs
2. Personalization takes time — 1-2 hours per demo prep doesn't scale
3. GPT-5.3 Codex enables automation — Generate scripts, customize decks, prepare objection handlers
4. Mid-turn steering is the differentiator — Real-time direction gives you control over AI output
5. ROI is measurable — 20% close rate improvement = significant revenue impact

Your demo is often the make-or-break moment in the sales cycle. Make sure every prospect feels like you built the whole product just for them. With Codex, you practically did.

You've heard OpenClaw can turn AI into your always-on sales assistant. You're intrigued by the $0 price tag versus $40K enterprise alternatives.

But you're staring at a GitHub page wondering: "How do I actually make this work for my sales team?"

This guide takes you from zero to a working AI SDR in under an hour. No engineering degree required. If you can copy-paste commands and edit a text file, you can do this.

What You'll Build​

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

✅ OpenClaw running on your machine (or a cloud server) ✅ AI assistant connected to WhatsApp or Slack ✅ Basic CRM integration with HubSpot ✅ Web search capability for prospect research ✅ Your first automated workflow (daily pipeline summary)

Total time: 45-60 minutes.

Prerequisites​

You need:

• A computer (Mac, Windows, or Linux)
• An Anthropic API key (get one at console.anthropic.com)
• A WhatsApp account OR Slack workspace
• (Optional) HubSpot account for CRM integration

You don't need:

• Programming experience
• DevOps knowledge
• A computer science degree

Part 1: Installing OpenClaw (15 minutes)​

Step 1: Install Node.js​

OpenClaw runs on Node.js. Install it first:

Mac:

brew install node

Windows: Download from nodejs.org and run the installer.

Linux (Ubuntu/Debian):

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt-get install -y nodejs

Verify it worked:

node --version
# Should show v22.x.x or similar

Step 2: Install OpenClaw​

One command:

npx openclaw@latest init

This downloads OpenClaw and runs the setup wizard.

The wizard asks:

1. API Key: Paste your Anthropic API key
2. Model: Select Claude Sonnet 4 (best balance of speed and capability)
3. Channels: Select WhatsApp or Slack (we'll configure in Part 2)

When it finishes, you'll see:

✅ OpenClaw initialized!
Run 'openclaw gateway start' to begin.

Step 3: Start the Gateway​

openclaw gateway start

OpenClaw is now running. You'll see:

🚀 Gateway started
📡 Listening for connections...

Leave this terminal open. OpenClaw runs here.

Part 2: Connecting a Messaging Channel (10 minutes)​

Your AI needs a way to communicate. Let's connect WhatsApp (easiest) or Slack.

Option A: WhatsApp (Personal or Business)​

In a new terminal:

openclaw whatsapp link

A QR code appears. Scan it with WhatsApp on your phone (Settings → Linked Devices → Link a Device).

Once linked:

✅ WhatsApp connected!
Send any message to your own number to test.

Test it: Send "Hello" to yourself on WhatsApp. Your AI should respond!

Option B: Slack​

1. Create a Slack App at api.slack.com/apps
2. Add these Bot Token Scopes:
   • chat:write
   • channels:history
   • channels:read
   • app_mentions:read
3. Install the app to your workspace
4. Copy the Bot Token

Add to your OpenClaw config (~/.openclaw/config.yaml):

channels:
  slack:
    token: "xoxb-your-bot-token"
    appToken: "xapp-your-app-token"  # For Socket Mode

Restart OpenClaw:

openclaw gateway restart

Test it: Mention your bot in Slack. It should respond!

Part 3: Configuring Your AI Persona (10 minutes)​

Your AI shouldn't sound like a generic chatbot. Let's give it personality.

Creating Your Sales Assistant Persona​

Open ~/.openclaw/workspace/SOUL.md and customize:

# SOUL.md - Your Sales AI

You are a sales assistant for [Your Company].

## Your Role
- Help SDRs research prospects
- Draft personalized outreach
- Monitor pipeline and alert on important changes
- Answer questions about our product and competitors

## Your Tone
- Professional but not stiff
- Concise—you value people's time
- Confident—you know the product well
- Helpful—you anticipate what's needed

## What You Know
- Our product: [Brief description]
- Our ICP: [Who we sell to]
- Our competitors: [Main competitors]
- Our differentiators: [What makes us unique]

## Rules
- Never make up information about prospects
- Always cite sources when researching
- Ask clarifying questions if a request is ambiguous
- Protect customer data—never share externally

Save the file. OpenClaw reads this automatically.

Testing the Persona​

Message your AI:

"What can you help me with?"

It should respond based on your SOUL.md configuration.

Part 4: Adding Web Research (5 minutes)​

For your AI to research prospects, it needs web access.

Enable Brave Search​

1. Get a free API key at brave.com/search/api/
2. Add to your environment:

# Add to ~/.bashrc or ~/.zshrc
export BRAVE_API_KEY="your-brave-api-key"

3. Restart OpenClaw:

openclaw gateway restart

Test It​

Message your AI:

"Research Acme Corp for me—what do they do and any recent news?"

It should search the web and return a summary.

Part 5: HubSpot Integration (10 minutes)​

Now let's connect your CRM so your AI can access real prospect data.

Getting HubSpot API Access​

1. Go to HubSpot → Settings → Integrations → Private Apps
2. Create a new private app
3. Grant these scopes:
   • crm.objects.contacts.read
   • crm.objects.contacts.write
   • crm.objects.companies.read
   • crm.objects.deals.read
4. Copy the access token

Configure OpenClaw​

Add to your environment:

export HUBSPOT_ACCESS_TOKEN="your-token"

Create a HubSpot integration script (~/.openclaw/workspace/scripts/hubspot.js):

const hubspot = require('@hubspot/api-client');

const client = new hubspot.Client({ 
  accessToken: process.env.HUBSPOT_ACCESS_TOKEN 
});

// Search contacts
async function searchContacts(query) {
  const response = await client.crm.contacts.searchApi.doSearch({
    query: query,
    limit: 10,
    properties: ['firstname', 'lastname', 'email', 'company']
  });
  return response.results;
}

// Get deal pipeline
async function getDeals() {
  const response = await client.crm.deals.basicApi.getPage(100, undefined, [
    'dealname', 'amount', 'dealstage', 'closedate'
  ]);
  return response.results;
}

module.exports = { searchContacts, getDeals };

Install the HubSpot SDK:

cd ~/.openclaw/workspace
npm install @hubspot/api-client

Test It​

Message your AI:

"Look up John Smith in our CRM"

It should search HubSpot and return matching contacts.

Part 6: Your First Automation (10 minutes)​

Let's set up a daily pipeline summary that runs automatically.

Create the Cron Job​

OpenClaw uses cron jobs for scheduled tasks. Add to your config:

# ~/.openclaw/config.yaml
cron:
  - name: "Daily Pipeline Summary"
    schedule: 
      kind: cron
      expr: "0 9 * * *"  # 9 AM daily
      tz: "America/Chicago"  # Your timezone
    payload:
      kind: systemEvent
      text: |
        Generate a morning pipeline briefing:
        1. Check HubSpot for deals closing this week
        2. List any deals that haven't been updated in 7+ days
        3. Highlight the top 3 deals by value
        4. Send summary to the sales channel
    sessionTarget: main

Restart to Apply​

openclaw gateway restart

Tomorrow at 9 AM, your AI will automatically generate and send a pipeline summary.

Test It Now​

Don't want to wait? Trigger manually:

openclaw cron run "Daily Pipeline Summary"

Part 7: Common GTM Workflows​

Here are ready-to-use workflows for sales teams:

Prospect Research on Demand​

When someone messages:

"Research [Company Name]"

Your AI will:

1. Search the web for company information
2. Find recent news
3. Check for relevant job postings
4. Summarize findings

Pre-Call Briefing​

When someone messages:

"Prep me for my call with [Name] at [Company]"

Your AI will:

1. Research the person and company
2. Check your CRM for history
3. Generate talking points
4. Suggest opening questions

Email Draft​

When someone messages:

"Draft an email to [Name] at [Company] about [topic]"

Your AI will:

1. Research the prospect
2. Draft a personalized email
3. Suggest subject lines
4. Format for copy-paste

Deal Alert​

Set up an alert for stale deals:

cron:
  - name: "Stale Deal Alert"
    schedule:
      kind: cron
      expr: "0 10 * * 1-5"  # 10 AM weekdays
    payload:
      kind: systemEvent
      text: |
        Check HubSpot for deals not updated in 7+ days.
        For each stale deal, send an alert with:
        - Deal name and value
        - Days since last activity
        - Suggested next action
    sessionTarget: main

Troubleshooting Common Issues​

"Command not found: openclaw"​

Make sure Node.js is in your PATH:

export PATH=$PATH:$(npm bin -g)

WhatsApp QR Code Won't Scan​

1. Make sure you're scanning with WhatsApp (not camera app)
2. Try regenerating: openclaw whatsapp link --force
3. Check your phone has internet

AI Not Responding​

1. Check the gateway is running: openclaw gateway status
2. Check API key is set: echo $ANTHROPIC_API_KEY
3. Check logs: openclaw gateway logs

HubSpot Integration Not Working​

1. Verify token: curl -H "Authorization: Bearer $HUBSPOT_ACCESS_TOKEN" https://api.hubapi.com/crm/v3/objects/contacts?limit=1
2. Check scopes in HubSpot private app settings
3. Ensure token isn't expired

What's Next?​

You now have a working AI SDR foundation. Here's how to expand:

Week 1 additions:

• Add more team members to the WhatsApp/Slack channel
• Create 2-3 custom prompts for common requests
• Set up one more automated daily report

Week 2 additions:

• Add email integration for outbound drafts
• Create a competitor research template
• Build an objection handling reference

Week 3 additions:

• Add Salesforce or other CRM if needed
• Create multi-step workflows
• Train team on best prompts

Resources​

• OpenClaw Docs: docs.openclaw.ai
• Community Discord: discord.com/invite/clawd
• GitHub: github.com/openclaw/openclaw
• Skill Library: clawhub.com (pre-built automations)

Want a Head Start?​

MarketBetter builds on OpenClaw's foundation with pre-built GTM workflows, native HubSpot integration, and a complete SDR playbook—no setup required.

Book a Demo to see how we've productized the best of OpenClaw for sales teams.

Related reading:

• How to Build an AI SDR with OpenClaw
• OpenClaw + HubSpot: Ultimate CRM Automation
• Build vs Buy: Should You Build Your Own AI Stack?

Your competitor just dropped their prices by 20%.

You find out when a prospect emails: "Why are you so much more expensive than [Competitor]?"

By then, you've already lost deals. Your sales team is blindsided. Your positioning is outdated.

Pricing intelligence used to require expensive tools or manual monitoring. Now, AI agents can track competitor pricing 24/7 — and alert you the moment something changes.

Why Pricing Intelligence Matters More Than Ever​

The reality of B2B pricing:

• 62% of buyers compare pricing before talking to sales (Gartner)
• 78% expect price transparency on websites (McKinsey)
• Pricing page changes often signal strategy shifts
• Your prospects are comparing you to 3-5 alternatives

What you're missing without monitoring:

• New pricing tiers competitors launch
• Promotional discounts and limited offers
• Feature bundling changes
• Free tier adjustments
• Usage-based pricing tweaks
• Contract term variations

The cost of being slow:

• Lost deals to cheaper alternatives
• Discounting when you didn't need to
• Missing opportunities to raise prices
• Sales conversations going sideways

Building Your AI Pricing Intelligence System​

Component 1: Data Collection​

What to monitor for each competitor:

Public pricing pages:

• Tier names and prices
• Feature lists per tier
• Usage limits
• Add-on pricing
• Enterprise "contact us" language changes

Secondary sources:

• G2/Capterra pricing mentions
• LinkedIn posts about pricing
• Press releases
• Job postings (pricing analyst = incoming changes)
• Customer reviews mentioning price
• Discount codes circulating

Deal intelligence:

• What prospects tell you they're being quoted
• Win/loss analysis pricing mentions
• Customer interview feedback

Component 2: Change Detection​

Use AI to detect meaningful changes:

const analyzePricingChange = async (competitor, previous, current) => {
  const prompt = `
    Analyze this competitor pricing change:
    
    Competitor: ${competitor.name}
    
    Previous pricing (captured ${previous.date}):
    ${JSON.stringify(previous.pricing, null, 2)}
    
    Current pricing (captured ${current.date}):
    ${JSON.stringify(current.pricing, null, 2)}
    
    Determine:
    1. What specifically changed?
    2. Significance level (major/moderate/minor)
    3. Likely strategic intent
    4. Impact on our competitive position
    5. Recommended actions for our team
    
    Consider:
    - Price changes > 10% are significant
    - New tier additions signal market expansion
    - Feature changes indicate positioning shifts
    - "Contact us" changes often precede price increases
  `;
  
  return await claude.analyze(prompt);
};

Sample output:

🚨 PRICING CHANGE DETECTED: Apollo
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Change Type: MAJOR
Detected: Feb 8, 2026 at 3:42 PM UTC

What Changed:
├─ Professional tier: $79 → $99/user/month (+25%)
├─ Team tier: $39 → $49/user/month (+26%)  
├─ New "Starter" tier added at $29/user/month
└─ Annual discount reduced from 25% to 20%

Strategic Analysis:
Apollo is shifting upmarket while adding an entry-level tier. The 25% 
price increase on Professional signals confidence in their enterprise 
positioning. The new Starter tier suggests they're also protecting 
against low-end competition (likely us and Seamless.AI).

Impact on MarketBetter:
- Our pricing now 15% lower than Apollo Professional (was 8%)
- We're competing directly with their new Starter tier
- Their annual discount cut improves our relative annual value

Recommended Actions:
1. Update sales battlecards — highlight our pricing advantage
2. Consider marketing campaign around "Apollo raised prices" angle
3. Target Apollo Starter users for upgrade messaging
4. Brief SDR team on change before tomorrow's calls

Confidence: 94%

Component 3: Automated Monitoring with OpenClaw​

# pricing-intelligence-agent.yaml
name: Pricing Intelligence Monitor
schedule: "0 */4 * * *"  # Every 4 hours

competitors:
  - name: Apollo
    url: https://www.apollo.io/pricing
    selectors:
      tiers: ".pricing-tier"
      prices: ".tier-price"
      features: ".feature-list"
      
  - name: ZoomInfo
    url: https://www.zoominfo.com/pricing
    selectors:
      tiers: ".pricing-card"
      prices: ".price-amount"
      
  - name: Outreach
    url: https://www.outreach.io/pricing
    selectors:
      tiers: ".plan"
      prices: ".plan-price"

workflow:
  1_scrape:
    action: web_scrape
    targets: competitors
    capture: [tiers, prices, features, last_modified]
    
  2_compare:
    action: ai_compare
    model: claude-3-5-sonnet
    against: previous_snapshot
    threshold: any_change
    
  3_analyze:
    action: ai_analyze
    model: claude-3-5-sonnet
    prompt: pricing_change_analysis
    
  4_alert:
    condition: change_detected
    actions:
      - slack_notify: "#competitive-intel"
      - email: ["sales-leadership@company.com"]
      - update_battlecards: true
      - log_to_database: true
      
  5_archive:
    action: save_snapshot
    storage: pricing_history

Component 4: Trend Analysis​

Don't just track changes — understand patterns:

const analyzePricingTrends = async (competitor, history) => {
  const prompt = `
    Analyze pricing trends for ${competitor.name}:
    
    Historical pricing data (last 12 months):
    ${JSON.stringify(history, null, 2)}
    
    Identify:
    1. Overall price trajectory (increasing/stable/decreasing)
    2. Pricing strategy pattern (premium/value/penetration)
    3. Common timing of changes (quarterly? annual?)
    4. Feature vs price trade-offs
    5. Market positioning shifts
    6. Predicted next move
    
    Context:
    - Industry average price increase: 5-8% annually
    - Funding rounds often precede price changes
    - Product launches typically add new tiers
  `;
  
  return await claude.analyze(prompt);
};

Output example:

📊 PRICING TREND ANALYSIS: ZoomInfo (12-month view)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Trajectory: ↗️ INCREASING
12-month change: +18% across all tiers
Pattern: Quarterly adjustments (Jan, Apr, Jul, Oct)

Key Observations:
1. Removed lowest tier in Q2 2025 (forcing upgrades)
2. Added "Lite" tier in Q3 2025 (response to competition)
3. Enterprise pricing became "contact us" only
4. Credits system introduced to limit data access

Strategy Assessment:
ZoomInfo is executing a classic "land and expand" price strategy:
- Entry tier for acquisition
- Usage limits force upgrades
- Enterprise opacity allows deal-specific pricing

Predicted Next Move:
Based on pattern, expect Q1 2026 adjustment:
- 5-10% increase on mid-tier (Professional)
- Possible new AI/enrichment add-on tier
- Further credit restrictions

Recommended Positioning:
Position against their credit model:
"Unlimited vs. ZoomInfo's metered access"

Advanced Use Cases​

Use Case 1: Real-Time Deal Intelligence​

When a prospect mentions competitor pricing:

const handlePricingMention = async (deal, competitorQuote) => {
  const currentPricing = await getPricingSnapshot(competitorQuote.competitor);
  const ourPricing = await calculateOurQuote(deal);
  
  const analysis = await claude.analyze(`
    Deal: ${deal.name} (${deal.value})
    
    Competitor quote mentioned:
    - Vendor: ${competitorQuote.competitor}
    - Amount: ${competitorQuote.amount}
    - Terms: ${competitorQuote.terms}
    
    Our current pricing:
    ${JSON.stringify(ourPricing)}
    
    Latest competitor public pricing:
    ${JSON.stringify(currentPricing)}
    
    Determine:
    1. Is their quote consistent with public pricing?
    2. What discount % are they likely offering?
    3. What's our competitive position?
    4. Should we match, beat, or hold firm?
    5. What value differentiation should we emphasize?
  `);
  
  return {
    recommendation: analysis.recommendation,
    discountSuggestion: analysis.discountSuggestion,
    talkingPoints: analysis.talkingPoints,
    riskLevel: analysis.riskLevel
  };
};

Use Case 2: Win/Loss Pricing Analysis​

const analyzePricingWinLoss = async (deals) => {
  const prompt = `
    Analyze our win/loss data for pricing patterns:
    
    Last 100 deals:
    ${JSON.stringify(deals.map(d => ({
      outcome: d.outcome,
      ourPrice: d.ourPrice,
      competitorPrice: d.competitorMentioned,
      competitor: d.competitor,
      lossReason: d.lossReason,
      dealSize: d.value,
      segment: d.segment
    })))}
    
    Find patterns:
    1. Price sensitivity by segment
    2. Competitors we lose to on price vs. value
    3. Discount patterns in wins vs. losses
    4. Optimal pricing by deal size
    5. Feature gaps that justify price premium
    
    Actionable insights for sales and pricing strategy.
  `;
  
  return await claude.analyze(prompt);
};

Output:

💰 WIN/LOSS PRICING ANALYSIS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Key Findings:

1. PRICE SENSITIVITY BY SEGMENT
   - SMB (<50 employees): HIGH sensitivity
     Lost 68% of deals where we were >20% more expensive
   - Mid-market (50-500): MODERATE sensitivity
     Won 55% even when 15% more expensive (value sold)
   - Enterprise (500+): LOW sensitivity
     Price mentioned in only 23% of losses

2. COMPETITOR-SPECIFIC PATTERNS
   - vs. Apollo: Lost 70% when price-focused; Won 80% when value-focused
   - vs. ZoomInfo: Price rarely competitive; Win on features
   - vs. Seamless.AI: Must be within 10% to compete

3. OPTIMAL DISCOUNT STRATEGY
   - SMB: Offer 15% discount proactively (win rate +34%)
   - Mid-market: Hold firm, discount only for annual (win rate same)
   - Enterprise: Discount range 10-25% acceptable

4. VALUE DIFFERENTIATION THAT JUSTIFIES PREMIUM
   - Playbook feature: +22% price tolerance
   - Visitor ID: +15% price tolerance
   - Integration depth: +18% price tolerance

RECOMMENDATIONS:
├─ Create SMB-specific pricing tier
├─ Train SDRs on value selling for Apollo comparisons
├─ Develop "Total Cost of Ownership" calculator
└─ Document feature premium justifications

Use Case 3: Pricing Change Simulations​

Before making your own pricing changes:

const simulatePriceChange = async (proposedChange) => {
  const prompt = `
    Simulate the impact of this pricing change:
    
    Current pricing: ${JSON.stringify(currentPricing)}
    Proposed change: ${JSON.stringify(proposedChange)}
    
    Consider:
    1. Competitor likely response
    2. Customer segment impact
    3. New customer acquisition effect
    4. Existing customer reaction
    5. Revenue impact (short and long-term)
    
    Historical context:
    - Last price increase: ${lastPriceChange.date} (${lastPriceChange.reaction})
    - Competitor recent moves: ${competitorMoves}
    - Market conditions: ${marketConditions}
    
    Provide scenario analysis: best case, expected, worst case.
  `;
  
  return await claude.analyze(prompt);
};

Implementation Guide​

Phase 1: Setup (Week 1)​

Day 1-2: Identify competitors

• List 5-10 direct competitors
• Document their pricing page URLs
• Note their pricing models (per seat, usage, flat)

Day 3-4: Configure scraping

• Set up web scraping for each pricing page
• Test selector accuracy
• Handle dynamic content (JavaScript rendering)

Day 5: Baseline capture

• Capture current pricing for all competitors
• Verify accuracy against manual checks
• Store initial snapshots

Phase 2: Automation (Week 2)​

Day 1-2: OpenClaw agent setup

• Configure monitoring schedule
• Set up change detection thresholds
• Test alert workflows

Day 3-4: Alert configuration

• Slack integration for real-time alerts
• Email digest for leadership
• CRM integration for deal context

Day 5: Team training

• Brief sales on using pricing intel
• Show how to access competitor comparisons
• Practice responding to pricing objections

Phase 3: Advanced (Week 3+)​

• Add secondary source monitoring (G2, press, social)
• Build historical trend dashboards
• Integrate with deal intelligence
• Train win/loss pricing models

ROI Calculation​

Costs:

• AI API: ~$50/month (monitoring + analysis)
• Web scraping infrastructure: ~$20/month
• Setup time: ~20 hours

Benefits:

• Faster response to pricing changes: Save 1 deal/month = $10K+ ARR
• Better discounting decisions: Reduce unnecessary discounts by 3% = $15K/year
• Competitive positioning: Win 2 extra deals/quarter = $40K ARR
• Strategic pricing moves: 5% price increase enabled = Variable

Conservative ROI: $50K+ annual value vs. $1K annual cost = 50x ROI

Start Tracking Today​

Your competitors are changing their pricing constantly. Without intelligence, you're always reacting.

AI makes pricing intelligence accessible to any team — not just enterprises with dedicated competitive intelligence staff.

Your next steps:

1. List your top 5 competitors and their pricing URLs
2. Set up basic web monitoring
3. Book a demo with MarketBetter to see competitive intelligence automation in action

Because the best pricing strategy starts with knowing what you're competing against.

Your CRO asks: "Are we going to hit the number this month?"

You spend 4 hours pulling data from HubSpot, cross-referencing with finance, adjusting for pipeline weighting, and building a slide deck. By the time you present it, the data is 3 days old.

This is RevOps in 2025. It doesn't have to be RevOps in 2026.

With Claude Code, you can build a real-time revenue dashboard that:

• Pulls live data from CRM, marketing, and finance systems
• Automatically weights pipeline by historical close rates
• Surfaces risks before they become surprises
• Updates continuously, not monthly

Here's exactly how to build it.

Why Your Current Dashboards Fail​

Problem 1: Data silos Pipeline is in HubSpot. Bookings are in the finance system. Marketing attribution is in Marketo. Usage data is in the product. Getting a complete picture requires manual assembly.

Problem 2: Stale data Weekly pipeline reviews use data that's already a week old. Monthly board decks are historical artifacts by the time they're presented.

Problem 3: No intelligence Dashboards show what happened, not what's likely to happen. They can't answer "should I be worried about this deal?"

Problem 4: Too many dashboards HubSpot has reports. Tableau has dashboards. Looker has boards. Nobody knows which one is "the truth."

The RevOps Dashboard Architecture​

Here's what we're building:

┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   HubSpot   │    │   Stripe    │    │  Marketo    │
│   (CRM)     │    │ (Revenue)   │    │ (Marketing) │
└──────┬──────┘    └──────┬──────┘    └──────┬──────┘
       │                  │                  │
       ▼                  ▼                  ▼
┌────────────────────────────────────────────────────┐
│              Data Normalization Layer               │
│         (Claude Code - ETL + Enrichment)           │
└───────────────────────┬────────────────────────────┘
                        │
                        ▼
┌────────────────────────────────────────────────────┐
│               Analytics Engine                      │
│    - Pipeline weighting                            │
│    - Forecasting models                            │
│    - Risk scoring                                  │
│    - Attribution analysis                          │
└───────────────────────┬────────────────────────────┘
                        │
                        ▼
┌────────────────────────────────────────────────────┐
│              Executive Dashboard                    │
│    - Real-time metrics                             │
│    - Drill-down capability                         │
│    - AI-generated insights                         │
└────────────────────────────────────────────────────┘

Step 1: Data Integration with Claude Code​

Let Claude Code build your data pipeline:

claude "Create a TypeScript module that:
1. Pulls deal data from HubSpot (all deals, all stages, with history)
2. Pulls revenue data from Stripe (MRR, ARR, churn, expansion)
3. Pulls campaign data from HubSpot Marketing (attribution, source)
4. Normalizes dates and amounts to consistent formats
5. Handles pagination and rate limiting
6. Stores in PostgreSQL with proper indexing

Use environment variables for API keys. Include comprehensive error handling."

Claude's 200K context window means you can provide full API documentation and get back production-ready code—not snippets that need assembly.

Sample Data Normalization​

// data-pipeline.ts - Claude Code generated

interface UnifiedDeal {
  id: string;
  name: string;
  company: string;
  amount: number;
  currency: 'USD';
  stage: string;
  stageHistory: StageChange[];
  probability: number;
  owner: User;
  source: MarketingSource;
  closeDate: Date;
  createdAt: Date;
  daysInStage: number;
  lastActivity: Date;
  contacts: Contact[];
}

const normalizeDeal = (hubspotDeal: HubSpotDeal): UnifiedDeal => {
  return {
    id: hubspotDeal.id,
    name: hubspotDeal.properties.dealname,
    company: hubspotDeal.associations?.companies?.[0]?.name || 'Unknown',
    amount: normalizeAmount(
      hubspotDeal.properties.amount,
      hubspotDeal.properties.deal_currency_code
    ),
    currency: 'USD',
    stage: mapStage(hubspotDeal.properties.dealstage),
    stageHistory: parseStageHistory(hubspotDeal),
    probability: calculateProbability(hubspotDeal),
    owner: await getOwner(hubspotDeal.properties.hubspot_owner_id),
    source: await getAttribution(hubspotDeal),
    closeDate: new Date(hubspotDeal.properties.closedate),
    createdAt: new Date(hubspotDeal.properties.createdate),
    daysInStage: calculateDaysInStage(hubspotDeal),
    lastActivity: await getLastActivity(hubspotDeal.id),
    contacts: await getContacts(hubspotDeal.id)
  };
};

Step 2: Intelligent Pipeline Weighting​

Raw pipeline is a fantasy number. Weighted pipeline predicts reality:

// pipeline-weighting.ts

interface WeightingModel {
  byStage: Record<string, number>;        // Historical close rates by stage
  byAgeInStage: (stage: string, days: number) => number;  // Decay factor
  bySource: Record<string, number>;       // Source quality multiplier
  byDealSize: (amount: number) => number; // Large deal discount
}

const buildWeightingModel = async (): Promise<WeightingModel> => {
  // Analyze last 12 months of closed deals
  const closedWon = await getClosedWonDeals('12m');
  const closedLost = await getClosedLostDeals('12m');
  
  // Calculate actual close rates by stage
  const byStage = calculateStageConversion(closedWon, closedLost);
  // Example result:
  // { 'Discovery': 0.12, 'Demo': 0.34, 'Proposal': 0.62, 'Negotiation': 0.78 }
  
  // Calculate age decay
  const byAgeInStage = buildDecayFunction(closedWon, closedLost);
  // Example: Deals 2x average time in stage close at 40% the rate
  
  // Calculate source quality
  const bySource = calculateSourceQuality(closedWon);
  // Example: { 'Inbound': 1.2, 'Outbound': 0.8, 'Partner': 1.1, 'Event': 0.7 }
  
  // Calculate deal size impact
  const byDealSize = buildSizeFunction(closedWon, closedLost);
  // Example: Deals >$100K close at 70% the rate of average deals
  
  return { byStage, byAgeInStage, bySource, byDealSize };
};

const weightDeal = (deal: UnifiedDeal, model: WeightingModel): number => {
  const baseWeight = model.byStage[deal.stage] || 0.1;
  const ageMultiplier = model.byAgeInStage(deal.stage, deal.daysInStage);
  const sourceMultiplier = model.bySource[deal.source.channel] || 1;
  const sizeMultiplier = model.byDealSize(deal.amount);
  
  return deal.amount * baseWeight * ageMultiplier * sourceMultiplier * sizeMultiplier;
};

Step 3: Risk Scoring​

Identify deals that need attention before they slip:

// risk-scoring.ts

interface DealRisk {
  dealId: string;
  score: number;        // 0-100, higher = more risk
  factors: RiskFactor[];
  recommendation: string;
}

const calculateDealRisk = async (deal: UnifiedDeal): Promise<DealRisk> => {
  const factors: RiskFactor[] = [];
  let score = 0;
  
  // Time in stage risk
  const avgTimeInStage = await getAverageTimeInStage(deal.stage);
  if (deal.daysInStage > avgTimeInStage * 1.5) {
    score += 25;
    factors.push({
      type: 'stale',
      description: `${deal.daysInStage} days in ${deal.stage} (avg: ${avgTimeInStage})`,
      severity: 'high'
    });
  }
  
  // Activity recency risk
  const daysSinceActivity = daysBetween(deal.lastActivity, new Date());
  if (daysSinceActivity > 14) {
    score += 20;
    factors.push({
      type: 'inactive',
      description: `No activity in ${daysSinceActivity} days`,
      severity: 'medium'
    });
  }
  
  // Close date risk
  const daysToClose = daysBetween(new Date(), deal.closeDate);
  if (daysToClose < 14 && deal.stage !== 'Negotiation') {
    score += 30;
    factors.push({
      type: 'unrealistic_date',
      description: `Closing in ${daysToClose} days but still in ${deal.stage}`,
      severity: 'high'
    });
  }
  
  // Champion identified
  const hasChampion = deal.contacts.some(c => c.role === 'Champion');
  if (!hasChampion && deal.amount > 50000) {
    score += 15;
    factors.push({
      type: 'no_champion',
      description: 'No champion identified on $50K+ deal',
      severity: 'medium'
    });
  }
  
  // Generate recommendation
  const recommendation = await generateRecommendation(deal, factors);
  
  return { dealId: deal.id, score, factors, recommendation };
};