28 posts tagged with "sales automation"

Let's cut through the noise. When you hear "AI sales assistant," don't picture a robot replacing your top SDR. It's not about that. The reality is much more practical—and a lot more powerful.

What Are AI Sales Assistants and Why Do They Matter Right Now?​

Think of an AI sales assistant as an execution engine that lives right inside your CRM, whether that's Salesforce or HubSpot. Its job is brutally simple: take all the data, buyer signals, and noise, and turn it into a clear, prioritized list of actions for your reps. It’s the co-pilot that handles the grunt work so your sellers can focus on selling.

This isn't just another nice-to-have tool. It's become essential. Your SDRs are probably drowning in admin tasks—logging calls, researching prospects on LinkedIn, and just trying to figure out who to contact next. The AI assistant slices right through that chaos.

To make this actionable, let's compare a standard CRM to one enhanced with an AI assistant.

A standard CRM, on its own, is like a map. It shows you all the possible leads, but it doesn't tell you the best route to your destination (hitting quota). An AI sales assistant acts like a GPS for that map. It does a few critical things:

• Analyzes real-time traffic: It monitors buyer signals like website visits, content downloads, or email opens.
• Finds the fastest route: It prioritizes the leads most likely to convert right now, showing you the most efficient path to a closed deal.
• Warns you about dead ends: It helps de-prioritize unresponsive or disqualified leads so reps don't waste time.
• Gives you turn-by-turn directions: It serves up the "next best action" for your rep, removing all guesswork.

This shift from a passive database to an active guide is what eliminates the wasted time that plagues most sales floors.

The Big Shift Toward Intelligent Automation​

The explosion of these tools isn't a random trend. It's a direct answer to a sales world that can't afford to have expensive sellers buried in manual data entry. We need smarter, more efficient workflows, and that need is driving insane growth. The market for this software is set to jump from USD 3.46 billion in 2026 to a wild USD 20.5 billion by 2035.

This isn't just hype. Modern AI can finally deliver on its promises inside the messy reality of B2B sales. If you want to dig deeper into the "why now," this podcast on why AI could replace your sales team is worth a listen, as it unpacks how these roles are fundamentally changing.

The real magic of an AI sales assistant isn't just automation. It’s prioritization at scale. It makes sure every single action a rep takes is the most strategic one they could be taking at that exact moment—based on data, not just a gut feeling.

At the end of the day, these assistants are about making your human talent better. By taking over the repetitive, soul-crushing tasks, they free up your SDRs to do what they were hired for: building relationships, having real conversations, and closing deals. And that's how you build a high-performing sales team today. Learn more about how to apply AI for sales prospecting in our deep-dive guide.

Comparing AI Sales Assistants to Your Existing Sales Tools​

Your sales stack is probably crowded. With so many tools promising to boost productivity, it’s fair to ask where another one could possibly fit. Is an AI sales assistant just a fancier email writer? Or another flavor of your sales engagement platform?

The short answer is no. It fills a very specific—and very important—gap that other tools simply weren't built to address.

The key difference is that a true AI sales assistant is execution-focused and CRM-native. It isn't another tab your reps have to open. Instead, it lives right inside Salesforce or HubSpot to turn buyer signals into immediate, actionable tasks. That subtle shift, from a separate app to an embedded co-pilot, completely changes how your SDRs work.

This map gives you a good visual of how it all connects.

As you can see, the assistant’s whole job is to automate the grunt work, surface the next best action, and deliver insights without making the rep leave their main workspace.

Let's break down how this is different from the tools you're already using.

AI Assistants vs. AI Email Writers​

Plenty of sales teams use AI tools like HubSpot's Breeze Assistant to draft email copy. These are great for getting past writer's block or quickly spinning up a first draft. But at their core, they're content creation tools.

An AI email writer helps you answer the question, "What should I write?"

An AI sales assistant answers a much bigger question: "Who should I contact right now, why should I contact them, and what's the fastest way to get it done?"

Actionable Comparison: An AI writer can help you polish a follow-up email. By contrast, an AI sales assistant sees that a key prospect just hit your pricing page, automatically creates a "High-Priority Follow-Up" task in your CRM, drafts a smart email that references their visit, and queues it up for your rep to send with a single click. No context switching, just action.

AI Assistants vs. Sales Engagement Platforms​

Sales Engagement Platforms (SEPs) like Salesloft or Outreach are absolute beasts for managing large-scale outbound sequences. They’re designed for structured, multi-step campaigns and are fantastic for casting a wide net.

But their focus is on the pre-planned sequence, not on reacting to new buyer signals in real time. Reps end up living inside the SEP, which often leads to annoying data sync issues and a workflow that feels disconnected from your CRM—the actual system of record.

An AI sales assistant doesn't replace your SEP; it makes it smarter. It acts as the intelligent front-end that tells your sequences who to engage right now, ensuring reps strike at the moment of peak interest.

AI Assistants vs. Standalone Dialers​

Standalone dialers are built to do one thing: make a ton of calls, fast. They excel at that. Their biggest limitation, however, is that they're isolated. They’re another app, another login, and another place where reps have to manually log call notes and outcomes back into the CRM. All that friction leads to messy data and wasted time.

An AI sales assistant with a CRM-native dialer completely eliminates this problem. The dialer is just part of the workflow. A rep sees a prioritized task, clicks to call directly from the contact record, and the assistant automatically logs the call, outcome, and notes. No more app-switching.

To make these differences crystal clear, here’s a quick comparison of how these tools stack up.

AI Sales Assistants vs Standard Sales Tools​

When you look at it this way, you can see that AI sales assistants aren't here to replace your stack. They're here to provide the intelligent execution layer it's been missing, finally connecting the dots between your data, your tools, and your reps' daily actions.

The Core Capabilities That Supercharge SDR Productivity​

So, beyond the buzzwords, what does an AI sales assistant actually do to make a sales development representative (SDR) more effective? The real magic isn't in one killer feature. It's how a few core capabilities work together to take the friction and guesswork out of an SDR's day, freeing them up to have more, better conversations.

Think about the typical salesperson's day. It's a mess of non-selling activity. One recent analysis found that reps spend just 25% of their time actually selling. The other 75% gets eaten up by manual data entry, prospect research, and logging notes in the CRM.

This is exactly where AI assistants step in. They can automate up to 65% of that administrative slog and cut the time spent on manual work by 40%. The result? Teams often see a 25% jump in sales productivity and find 25-35% more qualified leads.

The Prioritized Task Engine​

The single biggest time-waster for most SDRs is staring at a long list of leads and asking, "Okay, what now?" They scroll through their CRM, check their inbox for replies, and try to stitch together a plan for the day. It's inefficient and riddled with missed opportunities.

A core feature of any modern AI sales assistant is a prioritized task engine. This isn't just another to-do list. It's a dynamic, living queue that pulls in buyer signals from all over the place—website visits, content downloads, CRM data, and third-party intent signals—to automatically build and rank the next best actions.

• Pain Point Solved: It kills indecision and "analysis paralysis."
• Actionable Example: Instead of a generic list of 100 leads to call, the AI surfaces a single task: "Call Jane Doe at Acme Corp. She just viewed the pricing page for the second time this week." The rep knows exactly who to call, why, and has the context to open the conversation with confidence.

An engine like this transforms your CRM from a passive library of data into an active coaching tool. It serves up the "next best action" based on what's happening right now, making sure reps are always focused on the accounts most likely to engage.

The real power here is the blend of clarity and context. The rep doesn't just see the "what" (call or email); they see the "why" (the buyer just did something important). That's what allows them to act decisively.

Context-Aware AI Outreach​

We all know it: generic, templated emails go straight to the trash. Real outreach needs to be relevant. But who has time to write dozens of highly personalized messages every single day? It's a massive time sink.

AI sales assistants fix this with context-aware AI outreach. The system connects directly to your CRM and pulls in key details—the prospect’s title, their industry, recent activities, or past account history—to draft hyper-relevant emails and call scripts on the fly. It's not just generating random copy; it's using your own data to make the message land.

• Pain Point Solved: It crushes writer's block and the temptation to blast out generic messages.
• Actionable Example: Let's say the prospect is in manufacturing. The AI drafts an email that references a common challenge for plant managers, pulls in a link to a relevant case study, and suggests a specific, pointed call to action. The SDR just has to give it a quick review, maybe add a personal touch, and hit send.

AI-Powered Call Preparation​

Nothing kills a cold call faster than a rep who sounds like they're winging it. Fumbling for information or getting stumped by a basic objection destroys credibility in seconds. This is why the best platforms now include AI-powered call preparation.

Before a rep even picks up the phone, the assistant generates a quick, scannable brief. It includes key talking points, likely objections with suggested responses, and the latest company news or LinkedIn activity. If you want to go deeper on this, we've covered how to streamline your workflow with AI sales call prep automation in another guide. This feature turns what used to be a 15-minute research task into a 30-second review.

CRM-Native Workflow​

Finally, and this might be the most important part, is the CRM-native workflow. Too many sales tools force reps to live in a nightmare of open tabs: the CRM, the dialer, their email client, a research window. Every time they switch contexts, they lose a little focus and momentum. Worse, data gets lost along the way.

An AI sales assistant that lives inside your CRM—whether that's Salesforce or HubSpot—keeps reps in one place. They can click-to-call, send an AI-drafted email, and log every touchpoint without ever leaving the contact record. This simple change ensures every single activity is captured perfectly, which gives sales leaders a crystal-clear picture of what's working and keeps the CRM the undisputed source of truth.

A Practical Guide to Implementing an AI Sales Assistant​

Bringing new tech into the sales floor can feel like open-heart surgery. Productivity is on the line, reps are skeptical, and nobody has time for a three-month science project. But rolling out an AI sales assistant isn't like that. It’s less of a massive overhaul and more like giving your team a cheat sheet.

The key is to aim for quick, noticeable wins. We're not talking about a "rip and replace" of your CRM. This is about adding a layer of intelligence right on top of what you already use, making your SDRs smarter and faster from day one. A good rollout plan cuts through the noise and gets your team productive, fast.

Here’s a simple, four-step playbook to get it done right.

Step 1: Securely Connect Your CRM​

Everything starts here. An AI sales assistant is only as good as the data it can access, which means it needs a solid, secure connection to your CRM—whether that’s Salesforce or HubSpot. Think of your CRM as the central nervous system of your sales motion; the assistant needs to plug directly into it.

Actionable Tip: Before connecting, perform a quick data audit. Check for duplicate contacts or outdated account information. Clean, reliable CRM data is the fuel for the AI engine; a bad connection or messy data will starve it before it can even get started. This part is usually simple, often using secure OAuth. Loop in your RevOps or IT team to confirm the tool gets read-and-write access to the right objects—Leads, Contacts, Accounts, and Activities.

Step 2: Define Your High-Impact Buyer Signals​

Once you're connected, you have to tell the AI what to look for. What are the tell-tale signs that a prospect is ready for a conversation? Don't try to boil the ocean. Start with just a handful of high-impact triggers that are easy to spot and even easier to act on.

Actionable Tip: Pick signals that scream "intent" and map directly to a specific SDR action. Start with these three:

• Website Engagement: A prospect from a target account hits your pricing page.
• Content Downloads: Someone from a key account downloads a bottom-of-funnel case study.
• Time-Based Triggers: It’s been 90 days since you last talked to a high-value account.

The goal is simple: turn your sales playbook's "if-then" logic into automated triggers. If a prospect does X, the AI creates a task for an SDR to do Y. This gets reps out of the business of manual monitoring for good.

Step 3: Configure Your First High-Value Workflow​

Now it's time to build something. For your first workflow, pick a simple, high-impact use case that solves an SDR's biggest daily headache: figuring out who to call next. An AI-prioritized task list is the perfect place to start.

Actionable Tip: Configure the assistant to take the signals from Step 2 and automatically create and rank tasks. For example, a "Pricing Page Visit" signal should instantly generate a "High-Priority Call" task, complete with context about what that person looked at. This first workflow needs to feel like an immediate upgrade from a generic CRM task list. It’s a quick win that proves the tool's value by saving SDRs time and pointing them straight to the warmest leads. For a deeper look at how this fits into your tech strategy, check out the build vs. buy debate for your AI SDR stack.

Step 4: Onboard and Coach Your SDRs​

A tool is only as good as its adoption. A great rollout starts with the "why," not the "how." Show your SDRs that this assistant is here to kill their most boring tasks so they can focus on what matters—and hit their numbers faster.

1. Launch with a Pilot Group: Start small. Pick a few of your most motivated SDRs to be the pioneers. Their feedback and success stories will build momentum and help you iron out the kinks before going team-wide.
2. Focus on One Workflow: In the first training session, talk only about the prioritized task list. For the first week, their only job is to work through their new, intelligent to-do list. Nothing else.
3. Provide a Cheat Sheet: Give them a one-page guide that shows the new workflow. Make it visual, simple, and focused on the exact actions they need to take.
4. Coach, Don't Just Manage: Use your 1:1s to review their AI-powered task list. Ask questions like, "Why do you think the AI flagged this account?" This builds their trust in the system and reinforces the data-driven mindset.

Measuring the ROI of Your AI Sales Assistant​

Look, any time you bring a new tool into the sales floor, the CFO is going to ask one question: "What's the ROI?" It's not enough to say the team feels more productive. You need to show leadership the hard numbers that connect the dots between the software and real business results.

To build a rock-solid business case, you have to move past vanity metrics. The trick is to track KPIs across three critical areas, showing a clear progression from daily rep activity all the way to bottom-line pipeline growth.

Activity and Efficiency Gains​

The first place you'll see a return is in pure, raw output. An AI sales assistant is built to kill the tedious, time-sucking tasks that drain an SDR's day. We're talking about removing the friction that keeps them from their most important job: selling.

Actionable Metrics to Track:

• Daily Outbound Actions Per Rep: How many calls are they making? How many emails are they sending? Compare the before-and-after numbers. A good task engine should light a fire under these metrics.
• Time Spent on Manual CRM Logging: This one is huge. When call notes, outcomes, and task updates log automatically, you get time back. Even saving 30 minutes per rep per day adds up to a massive payroll saving across the team.

The real goal here is to quantify reclaimed time. If your AI assistant helps each SDR make 15 more calls and send 20 more emails every single day, you have a direct, powerful metric that proves its value from week one.

Quality and Engagement Improvements​

More activity is great, but smarter activity is what wins deals. This is where an AI sales assistant starts to separate itself from a simple dialer. It gives reps the context they need, right when they need it, so they can have truly relevant conversations.

Actionable Metrics to Track:

• Connect Rate: When reps call a prospect the moment they hit the pricing page, guess what? More people pick up the phone. You're no longer just burning through a cold list; you're calling with intent.
• Meeting Booked Rate: Keep a close eye on the percentage of conversations that turn into a booked discovery call. Higher-quality outreach and better talking points should push this number up.

This is where the assistant's intelligence really pays off. It's arming your reps with AI-powered talking points and objection-handling tips, helping them turn more cold "hellos" into qualified meetings.

Pipeline and Revenue Impact​

At the end of the day, every sales tool lives or dies by its ability to generate pipeline. This is the final, most important piece of the ROI puzzle. While more calls and better conversations are great leading indicators, new pipeline is the metric that gets executives to sign the check.

Actionable Metrics to Track:

• Qualified Opportunities Sourced: How many new, sales-accepted opportunities is the SDR team generating? This is the clearest measure of their contribution to the business.
• Sales Cycle Velocity: Track how quickly leads sourced by the AI assistant move through the early funnel stages. Faster is always better.

Actionable Tip: Build a custom dashboard in Salesforce or HubSpot. Create a report that pits a group of SDRs using the assistant against a control group that isn't. Tracking their KPIs side-by-side creates a powerful, data-backed story that leaves no doubt about the tool's impact on the bottom line.

Common Questions on AI Sales Assistants​

Even with all the excitement, it's smart to ask tough questions before bringing a new tool into your sales motion. Here are the straight answers to the questions sales and RevOps leaders ask us most.

Will an AI Sales Assistant Replace My SDRs?​

Absolutely not. The real goal is to make your existing team better, not smaller. An AI sales assistant is like a co-pilot for each rep, handling the soul-crushing admin work that eats up their day—logging calls, updating fields, and basic research.

This frees your SDRs to do what humans do best: build real relationships, have smart conversations, and crush their quota. Think of it as giving every rep a personal operations assistant, allowing them to be more strategic and way more effective.

We Already Use a Sales Engagement Platform. Do We Need This Too?​

Yes, because they solve two different problems that actually feed each other. A Sales Engagement Platform (SEP) like Salesloft or Outreach is fantastic for building and managing long-term, pre-planned sequences. It’s a system for campaigns, but it forces reps to live in a separate tab, pulling them away from their CRM.

An AI sales assistant is the execution layer that sits inside your CRM and makes your SEP sequences even smarter. While your SEP runs the long-term plan, the assistant uses real-time buyer signals to tell reps the single most important action to take right now. It helps them execute that call or email instantly from within Salesforce or HubSpot and logs everything perfectly, closing the gap between your planned campaigns and the opportunities that pop up today.

How Do AI-Generated Emails Avoid Sounding Robotic?​

The good ones don't use generic templates. The key is the data they pull from. Instead of working off a simple prompt, a modern AI assistant dives deep into your CRM, analyzing account history, buyer personas, recent company news, and past conversations.

The best platforms don't just spit out a finished email. They provide a smart first draft that the SDR can review and tweak in seconds. This preserves their unique voice and expertise while still saving a ton of time.

This ensures the outreach is hyper-relevant right from the get-go, not just another piece of generic spam.

How Quickly Can We Expect to See a Return on Investment?​

You'll see an immediate ROI on pure efficiency, often in the first few weeks. This shows up as a jump in the number of outbound activities per rep, per day, and a massive improvement in your CRM data quality as tasks like call logging get automated.

The bigger, strategic ROI—the stuff your CFO cares about, like more pipeline and revenue—starts to become clear within one to two quarters. That's the result of your reps consistently connecting with more of the right people and turning those conversations into qualified meetings. We always suggest tracking the initial efficiency gains first, then mapping them directly to pipeline growth to build an undeniable business case.

Ready to stop the busywork and start building more pipeline? marketbetter.ai turns buyer signals into prioritized tasks and helps your SDRs execute instantly with an AI-powered dialer and email writer inside Salesforce and HubSpot. Learn more and book a demo.

Your leads don't sleep. Neither should your follow-up.

The average B2B buyer needs 8-12 touches before they're ready to talk to sales. But here's the problem: your SDR team works 8 hours a day, 5 days a week. That's 40 hours out of 168.

76% of the week, your leads are getting zero attention.

OpenClaw changes this. It's a free, self-hosted gateway that runs AI agents 24/7 with memory, scheduling, and multi-channel reach. Here's how to build lead nurture sequences that never stop working.

Why Traditional Sequences Fail​

Before building the solution, let's understand what's broken:

The "Set and Forget" Problem​

Most email sequences are dumb pipes:

• Day 1: Send email A
• Day 3: Send email B
• Day 7: Send email C

No awareness of:

• Did they open previous emails?
• Did they visit your website?
• Did they engage on LinkedIn?
• Did their company just raise funding?
• Is their competitor in the news?

The Personalization Paradox​

Generic sequences get ignored. But truly personalized sequences at scale require:

• Research time per lead (15-30 minutes)
• Customization time per email (5-10 minutes)
• Monitoring for engagement signals
• Adjusting based on response

That math doesn't work for SDR teams handling 200+ leads.

The Timing Trap​

Your sequence says "send at 9 AM" but:

• The lead is in a different time zone
• They're in meetings all morning
• They check email at 6 AM before the chaos starts
• They're on PTO this week

Static timing = missed opportunities.

The OpenClaw Nurture Architecture​

Here's what we're building:

Lead Enters Sequence → OpenClaw Agent → Intelligent Nurture
                            ↓
                    [Continuously monitors:]
                    - Email engagement
                    - Website visits
                    - Social activity
                    - Intent signals
                    - Competitor moves
                            ↓
                    [Adapts:]
                    - Message content
                    - Send timing
                    - Channel selection
                    - Escalation triggers

Setting Up Your Nurture Agent​

Step 1: Install OpenClaw​

npm install -g @anthropic/openclaw
openclaw init

OpenClaw provides:

• Persistent memory - Your agent remembers every interaction
• Cron scheduling - Trigger actions at any time
• Multi-channel - Email, Slack, WhatsApp, SMS
• Browser control - Monitor websites, scrape signals
• Free & self-hosted - No per-seat pricing

Step 2: Define Your Nurture Sequences​

Create a sequence configuration:

# sequences/inbound-demo-request.yml
name: "Inbound Demo Request"
trigger: "demo_request_form"
duration: 21 # days

stages:
  - name: "immediate_response"
    timing: "+5m"  # 5 minutes after trigger
    channel: "email"
    template: "demo_confirmation"
    
  - name: "value_add_1"
    timing: "+2d"
    channel: "email"
    template: "case_study_relevant"
    condition: "not:demo_scheduled"
    
  - name: "social_touch"
    timing: "+3d"
    channel: "linkedin"
    action: "view_profile"
    condition: "email_opened:value_add_1"
    
  - name: "breakup_soft"
    timing: "+7d"
    channel: "email"
    template: "still_interested"
    condition: "not:replied AND not:demo_scheduled"
    
  - name: "final_attempt"
    timing: "+14d"
    channel: "email"
    template: "breakup"
    condition: "not:any_engagement"

escalation:
  - trigger: "pricing_page_visit"
    action: "alert_sdr"
    priority: "high"
    
  - trigger: "competitor_mention"
    action: "send_comparison"
    
  - trigger: "reply_received"
    action: "pause_sequence"

Step 3: Build the Nurture Agent​

// agents/nurture-agent.js
const { OpenClaw } = require('@anthropic/openclaw');

const nurtureAgent = new OpenClaw.Agent({
  name: 'NurtureBot',
  memory: 'persistent',
  
  async onNewLead(lead) {
    // Store lead context
    await this.memory.set(`lead:${lead.id}`, {
      company: lead.company,
      role: lead.role,
      source: lead.source,
      entered_sequence: new Date(),
      engagement: []
    });
    
    // Start appropriate sequence
    const sequence = this.selectSequence(lead);
    await this.startSequence(lead.id, sequence);
  },
  
  async onEngagementSignal(leadId, signal) {
    // Update lead context
    const lead = await this.memory.get(`lead:${leadId}`);
    lead.engagement.push({
      type: signal.type,
      timestamp: new Date(),
      details: signal.details
    });
    await this.memory.set(`lead:${leadId}`, lead);
    
    // Check for escalation triggers
    await this.checkEscalations(leadId, signal);
    
    // Adapt sequence if needed
    await this.adaptSequence(leadId, signal);
  },
  
  selectSequence(lead) {
    if (lead.source === 'demo_request') return 'inbound-demo-request';
    if (lead.source === 'content_download') return 'content-nurture';
    if (lead.source === 'website_visit') return 'awareness-nurture';
    return 'general-nurture';
  },
  
  async adaptSequence(leadId, signal) {
    const lead = await this.memory.get(`lead:${leadId}`);
    
    // High engagement → accelerate
    if (this.isHighEngagement(lead.engagement)) {
      await this.accelerateSequence(leadId);
    }
    
    // No engagement → adjust channel
    if (this.isLowEngagement(lead.engagement)) {
      await this.tryAlternateChannel(leadId);
    }
    
    // Competitor research → send battlecard
    if (signal.type === 'competitor_page_visit') {
      await this.injectCompetitorResponse(leadId, signal.competitor);
    }
  }
});

Step 4: Configure Intelligent Timing​

// Optimal send time calculation
async function calculateOptimalSendTime(lead) {
  const timezone = await detectTimezone(lead.company);
  const historicalOpens = await getHistoricalEngagement(lead.industry);
  const calendarBusyness = await estimateScheduleBusyness(lead.role);
  
  // Base: business hours in their timezone
  let optimalHour = historicalOpens.peakHour || 9;
  
  // Adjust for role patterns
  if (lead.role.includes('CEO') || lead.role.includes('Founder')) {
    optimalHour = 6; // Executives check email early
  }
  if (lead.role.includes('Engineer') || lead.role.includes('Developer')) {
    optimalHour = 10; // After morning standup
  }
  
  // Avoid meeting-heavy times
  if (calendarBusyness[optimalHour] > 0.7) {
    optimalHour = findLowBusynessHour(calendarBusyness);
  }
  
  return convertToTimezone(optimalHour, timezone);
}

Personalization at Scale​

Dynamic Content Generation​

OpenClaw agents can generate personalized content for each lead:

async function generateNurtureEmail(lead, stage) {
  const context = await gatherLeadContext(lead);
  
  const prompt = `
    Generate a nurture email for:
    - Company: ${context.company}
    - Role: ${context.role}
    - Industry: ${context.industry}
    - Recent activity: ${context.recentActivity}
    - Sequence stage: ${stage.name}
    
    Previous emails sent:
    ${context.previousEmails.map(e => `- ${e.subject}: ${e.opened ? 'Opened' : 'Not opened'}`).join('\n')}
    
    Requirements:
    - 50-100 words
    - One clear CTA
    - Reference something specific to their situation
    - Don't repeat angles from previous emails
    - Match their communication style (formal/casual based on industry)
  `;
  
  return await claude.generate(prompt);
}

Context Gathering​

The agent continuously gathers signals:

async function gatherLeadContext(lead) {
  return {
    // Company research
    company: await fetchCompanyInfo(lead.company),
    recentNews: await searchNews(lead.company, { days: 30 }),
    funding: await checkFundingEvents(lead.company),
    hiring: await checkJobPostings(lead.company),
    
    // Person research
    linkedin: await fetchLinkedInProfile(lead.email),
    publications: await searchPublications(lead.name),
    socialActivity: await monitorSocialMentions(lead.name),
    
    // Engagement data
    emailHistory: await getEmailHistory(lead.id),
    websiteVisits: await getWebsiteVisits(lead.email),
    contentDownloads: await getContentDownloads(lead.email),
    
    // Competitive intel
    competitorMentions: await checkCompetitorActivity(lead.company)
  };
}

Multi-Channel Orchestration​

Channel Selection Logic​

async function selectChannel(lead, stage) {
  const channels = {
    email: await getEmailDeliverability(lead.email),
    linkedin: await getLinkedInConnectivity(lead),
    phone: await getPhoneViability(lead.phone),
    sms: await getSmsConsent(lead)
  };
  
  // Primary channel preference
  if (stage.channel && channels[stage.channel].viable) {
    return stage.channel;
  }
  
  // Fallback based on engagement
  if (channels.email.opens < 0.1) {
    // Low email engagement → try LinkedIn
    if (channels.linkedin.connected) return 'linkedin';
    if (channels.linkedin.canConnect) return 'linkedin_request';
  }
  
  // High intent → phone
  if (lead.intentScore > 80 && channels.phone.viable) {
    return 'phone';
  }
  
  return 'email'; // Default
}

Coordinated Touches​

// Avoid overwhelming the lead
async function scheduleCoordinatedTouch(lead, channel, content) {
  const recentTouches = await getTouchesInWindow(lead.id, { days: 3 });
  
  // Max 2 touches per 3-day window
  if (recentTouches.length >= 2) {
    return scheduleForLater(lead.id, channel, content, { days: 2 });
  }
  
  // Avoid same-channel back-to-back
  const lastTouch = recentTouches[recentTouches.length - 1];
  if (lastTouch?.channel === channel) {
    return scheduleWithChannelSwitch(lead.id, content);
  }
  
  // Good to send
  return sendNow(lead.id, channel, content);
}

Escalation & Handoff​

Intent Signal Detection​

const escalationRules = [
  {
    signal: 'pricing_page_visit',
    action: 'alert_sdr',
    message: '🔥 Hot lead alert: ${lead.company} viewing pricing',
    priority: 'immediate'
  },
  {
    signal: 'demo_video_watched',
    condition: 'watched > 50%',
    action: 'schedule_sdr_call',
    message: 'Demo video engagement - time to reach out'
  },
  {
    signal: 'competitor_comparison_view',
    action: 'send_battlecard',
    followUp: 'sdr_call_in_24h'
  },
  {
    signal: 'multiple_stakeholders',
    condition: 'unique_visitors >= 3',
    action: 'alert_sdr',
    message: 'Buying committee forming at ${lead.company}'
  },
  {
    signal: 'reply_positive',
    action: 'pause_sequence',
    handoff: 'sdr_immediate'
  }
];

Smooth SDR Handoff​

async function handoffToSDR(lead, trigger) {
  // Compile complete context
  const briefing = await generateSDRBriefing(lead);
  
  // Alert via Slack
  await slack.send({
    channel: '#sdr-alerts',
    blocks: [
      {
        type: 'header',
        text: '🎯 Lead Ready for Human Touch'
      },
      {
        type: 'section',
        text: `*${lead.company}* - ${lead.name}\n*Trigger:* ${trigger}`
      },
      {
        type: 'section',
        text: `*Briefing:*\n${briefing.summary}`
      },
      {
        type: 'context',
        text: `Emails sent: ${briefing.emailCount} | Opens: ${briefing.opens} | Last activity: ${briefing.lastActivity}`
      }
    ]
  });
  
  // Assign in CRM
  await crm.assignLead(lead.id, await selectAvailableSDR());
  
  // Pause automation
  await pauseSequence(lead.id);
}

Monitoring Your Sequences​

Key Metrics Dashboard​

Continuous Optimization​

// Weekly sequence optimization
cron.schedule('0 9 * * MON', async () => {
  const metrics = await analyzeSequencePerformance({ weeks: 4 });
  
  for (const sequence of metrics.sequences) {
    // Identify underperforming stages
    const weakStages = sequence.stages.filter(s => s.engagement < 0.15);
    
    for (const stage of weakStages) {
      // Generate improved variant
      const improvement = await generateImprovedStage(stage);
      await createABTest(sequence.id, stage.id, improvement);
    }
  }
  
  // Report to Slack
  await slack.send('#marketing-ops', formatOptimizationReport(metrics));
});

Results to Expect​

Teams running OpenClaw nurture sequences typically see:

The key insight: humans are better at closing deals. Let AI handle the 90% of nurture that's about persistence and timing.

Getting Started​

1. Audit your current sequences - What's the completion rate? Where do leads drop off?

2. Define your escalation triggers - What signals indicate buying intent?

3. Start with one high-volume sequence - Inbound demo requests are perfect

4. Run parallel with manual - Compare AI vs. human performance

5. Expand based on results - Roll out to all sequences once proven

Ready to build always-on lead nurture? Book a demo to see how MarketBetter handles intelligent follow-up at scale.

Related reading:

• OpenClaw Setup Guide for GTM Teams
• Conversational Slack Sales Bot with OpenClaw
• AI Meeting Follow-Up Automation

The average RevOps team spends 40+ hours per month calculating commissions.

Spreadsheets break. Formulas have errors. Reps dispute their payouts. And when comp plans change mid-quarter, everything needs to be rebuilt from scratch.

Meanwhile, your sales team loses trust every time their commission is wrong—even by a few dollars.

Claude Code offers a better way. Its 200K context window can hold your entire comp plan, deal data, and calculation logic in a single session. Here's how to build a commission calculator that handles real-world complexity.

The Commission Calculation Problem​

Before we solve it, let's acknowledge why it's hard:

Complexity Layers​

A "simple" commission structure often includes:

• Base rates that vary by product, region, or segment
• Tiers that accelerate as reps hit quota thresholds
• Splits between AEs, SDRs, SEs, and CSMs
• SPIFs for strategic initiatives (new product push, multi-year deals)
• Clawbacks for churned customers
• Overrides for managers on team deals
• Caps and floors on certain deal types
• Pro-ration for mid-quarter hires or territory changes

The Spreadsheet Trap​

Most teams start with Excel. By month 6, you have:

Commission_Calculator_v14_FINAL_FINAL_v2_JohnFix_ACTUALLY_FINAL.xlsx

With nested IFs that no one understands:

=IF(AND(B2="Enterprise",C2>50000,D2="New"),
    IF(E2>1,G2*0.12*1.15,G2*0.12),
    IF(AND(B2="Mid-Market",C2>25000),
        IF(F2="SPIF",G2*0.10*1.25,G2*0.10),
        G2*0.08))

When something breaks—and it will—good luck debugging that.

The Trust Problem​

57% of sales reps have received an incorrect commission statement (Xactly). When reps don't trust their comp, they:

• Spend time manually verifying every deal
• Lose motivation during payout disputes
• Leave for companies with "cleaner" comp plans

Trust in compensation is trust in leadership.

The Claude Code Solution​

Claude Code's strengths align perfectly with commission calculation:

1. Natural language rules - Describe your comp plan in English, not formulas
2. 200K context - Hold the entire comp plan + all deals in one session
3. Explainable logic - Ask "why did this deal pay $X?" and get a real answer
4. Adaptable - Change the plan mid-quarter without rebuilding

Step 1: Document Your Comp Plan​

Instead of nested formulas, describe your plan clearly:

# Sales Commission Plan - Q1 2026

## Base Rates

### Account Executives
- New Business: 10% of first-year ACV
- Expansion: 8% of expansion ACV
- Renewal: 3% of renewal ACV

### SDRs
- Qualified Meeting: $100 per SAL
- Opportunity Created: $250 per SQL that converts to opportunity
- Deal Credit: 2% of won ACV (capped at $2,000 per deal)

### Sales Engineers
- Technical Win: $500 per closed-won where SE was primary
- Deal Credit: 3% of won ACV for complex deals (>$50K)

## Tier Accelerators

| Quota Attainment | Multiplier |
|------------------|------------|
| 0-80%            | 1.0x       |
| 80-100%          | 1.15x      |
| 100-120%         | 1.30x      |
| 120%+            | 1.50x      |

## SPIFs (Q1)
- New product (DataSync): Additional 2% on any deal including DataSync
- Multi-year: Additional 5% for 2+ year commitments
- Competitive displacement: Additional $1,000 for wins against Competitor X

## Splits
- SDR + AE on same deal: SDR gets meeting bonus + 2% deal credit; AE gets standard rate
- AE + SE on complex deal: SE gets technical win bonus; AE gets standard rate
- Two AEs on deal: Split based on documented territory/role agreement

## Clawbacks
- Customer churns within 6 months: 100% clawback
- Customer churns 6-12 months: 50% clawback
- Downgrade within 12 months: Clawback on difference

## Caps and Floors
- No cap on accelerated earnings
- Minimum $500 payout per closed-won deal (protects small deal motivation)
- Manager override: 5% of team deals, capped at $50K/quarter

Step 2: Build the Calculator​

Feed your comp plan to Claude Code:

You are a commission calculator for a B2B SaaS sales team. 

COMMISSION PLAN:
[Paste your entire comp plan document]

CALCULATION RULES:
1. Apply base rates first
2. Apply tier multipliers based on current quota attainment
3. Apply applicable SPIFs
4. Calculate splits according to deal roles
5. Check for clawbacks on previously paid commissions
6. Apply caps/floors
7. Show your work at each step

For each deal, output:
- Gross commission before modifiers
- Applicable tier multiplier
- SPIFs applied
- Split breakdown (if multiple parties)
- Final commission per person
- Reasoning for each decision

If anything is ambiguous, flag it for human review rather than guessing.

Step 3: Process Deals​

async function calculateCommission(deal, repProfile) {
  const prompt = `
    Calculate commission for this deal:
    
    DEAL:
    - Company: ${deal.company}
    - ACV: $${deal.acv}
    - Type: ${deal.type} (New/Expansion/Renewal)
    - Products: ${deal.products.join(', ')}
    - Contract term: ${deal.termMonths} months
    - Close date: ${deal.closeDate}
    - Displaced competitor: ${deal.displacedCompetitor || 'None'}
    
    REP:
    - Name: ${repProfile.name}
    - Role: ${repProfile.role}
    - Quota: $${repProfile.quota}
    - YTD Closed: $${repProfile.ytdClosed}
    - Current attainment: ${repProfile.attainment}%
    
    OTHER PARTIES ON DEAL:
    ${deal.splits.map(s => `- ${s.name} (${s.role}): ${s.contribution}`).join('\n')}
    
    Show all calculations step by step.
  `;
  
  return await claude.calculate(prompt);
}

Step 4: Handle Edge Cases​

Claude Code shines on the weird stuff:

EDGE CASE HANDLING:

Deal: Multi-year with mid-contract expansion
- Customer signed 3-year deal in January ($100K ACV)
- Expanded in March (+$25K ACV, same rep)

Question: How do we calculate the expansion commission?

REASONING:
1. Original deal: 3-year, so multi-year SPIF applies (10% + 5% = 15%)
2. Expansion: Same contract term, inherits multi-year status
3. Expansion rate: 8% base + 5% multi-year = 13%
4. Rep attainment: Now at 125% with original deal
5. Tier multiplier: 1.50x applies to expansion

CALCULATION:
$25,000 × 13% × 1.50x = $4,875

FLAG: Verify if expansion should inherit multi-year SPIF 
      (policy may differ by team).

Practical Workflows​

Monthly Commission Run​

async function runMonthlyCommissions(month, year) {
  // Get all closed deals
  const deals = await crm.getClosedDeals({ month, year });
  
  // Get all rep profiles
  const reps = await getRepProfiles();
  
  // Calculate each deal
  const commissions = [];
  for (const deal of deals) {
    const calc = await calculateCommission(deal, reps[deal.ownerId]);
    commissions.push({
      deal: deal,
      calculation: calc,
      breakdown: parseBreakdown(calc)
    });
  }
  
  // Check for clawbacks
  const clawbacks = await checkClawbacks(month, year);
  
  // Generate report
  return {
    totalPayout: sum(commissions.map(c => c.breakdown.finalAmount)),
    byRep: groupByRep(commissions),
    clawbacks: clawbacks,
    flaggedForReview: commissions.filter(c => c.breakdown.hasFlags)
  };
}

Rep Self-Service​

Let reps verify their own commissions:

async function repCommissionQuery(repId, question) {
  const repProfile = await getRepProfile(repId);
  const recentDeals = await getRecentDeals(repId);
  const commissionHistory = await getCommissionHistory(repId);
  
  const prompt = `
    A sales rep is asking about their commission.
    
    REP PROFILE:
    ${JSON.stringify(repProfile)}
    
    RECENT DEALS:
    ${JSON.stringify(recentDeals)}
    
    COMMISSION HISTORY (Last 3 months):
    ${JSON.stringify(commissionHistory)}
    
    QUESTION:
    ${question}
    
    Answer clearly, show relevant calculations, reference 
    specific deals and comp plan provisions.
  `;
  
  return await claude.answer(prompt);
}

Example queries:

• "Why did the Acme deal only pay $2,400?"
• "What's my commission if I close the pending BigCorp deal?"
• "Am I on track for the 120% accelerator this quarter?"

Plan Modeling​

Model comp plan changes before implementing:

async function modelPlanChange(proposedChange, historicalDeals) {
  const prompt = `
    We're considering this comp plan change:
    "${proposedChange}"
    
    Analyze the impact using last quarter's deals:
    ${JSON.stringify(historicalDeals)}
    
    Show:
    1. Total payout difference (old plan vs new)
    2. Impact per rep
    3. Which deal types are affected most
    4. Potential unintended consequences
    5. Recommendation
  `;
  
  return await claude.analyze(prompt);
}

Example: "What if we increase the new business rate from 10% to 12% but cap it at 110% attainment?"

Advanced Patterns​

Multi-Currency Handling​

CURRENCY RULES:
- All commissions paid in USD
- Deals closed in other currencies: use exchange rate at close date
- Exchange rate source: Company treasury rates (monthly)

EXAMPLE:
Deal closed in EUR: €50,000
Close date: February 15, 2026
Treasury rate (Feb 2026): 1.08 EUR/USD
USD equivalent: $54,000

Commission calculated on $54,000 USD value.

Territory Changes Mid-Quarter​

TERRITORY CHANGE HANDLING:

Rep A had Territory X from Jan 1 - Feb 15
Rep B took over Territory X on Feb 16

Deal in Territory X closed March 10

RULE: 
- If deal was in pipeline before transfer: 
  Original rep (A) gets full commission
- If deal entered pipeline after transfer:
  New rep (B) gets full commission
- If deal was in active stage during transfer:
  Split 50/50 or per documented agreement

This deal entered pipeline Jan 25, so Rep A gets full commission.

Clawback Automation​

async function processClawbacks() {
  // Find churned customers
  const churns = await crm.getChurns({ lookbackMonths: 12 });
  
  for (const churn of churns) {
    // Find original commission
    const originalCommission = await findCommission(churn.dealId);
    
    // Calculate clawback
    const monthsSinceDeal = monthsBetween(
      originalCommission.closeDate, 
      churn.churnDate
    );
    
    let clawbackRate;
    if (monthsSinceDeal <= 6) clawbackRate = 1.0;
    else if (monthsSinceDeal <= 12) clawbackRate = 0.5;
    else clawbackRate = 0;
    
    if (clawbackRate > 0) {
      await createClawback({
        repId: originalCommission.repId,
        dealId: churn.dealId,
        amount: originalCommission.amount * clawbackRate,
        reason: `Customer churned at ${monthsSinceDeal} months`
      });
    }
  }
}

Results to Expect​

Teams using AI-powered commission calculation typically see:

The biggest win: reps stop wasting mental energy worrying about comp. That energy goes back into selling.

Getting Started​

1. Document your current plan - Write it in plain English, not spreadsheet formulas

2. Identify edge cases - What causes disputes today? Document the rules

3. Start with one team - Run parallel calculations for one month

4. Build rep self-service - Let them query their own commissions

5. Add clawback automation - Remove manual tracking of churns

Ready to automate your commission complexity? Book a demo to see how MarketBetter helps RevOps teams operate at scale.

Related reading:

• RevOps Dashboard with Claude Code
• AI Sales Forecasting Accuracy with Codex
• SDR Performance Benchmarking

The average SDR spends 6 hours per week researching prospects. That's 6 hours of:

• Googling company names
• Scanning LinkedIn profiles
• Reading news articles
• Looking for pain points to reference

What if you could do all that in 30 seconds?

Claude Code—Anthropic's AI with tool use and code execution—can turn a prospect name into a complete research brief automatically. Here's exactly how to set it up.

What Good Lead Research Actually Looks Like​

Before we automate, let's define what we're building. A great prospect brief includes:

1. Company Overview: What they do, company size, industry
2. Recent News: Funding, product launches, leadership changes
3. Tech Stack: What tools they already use (if visible)
4. Pain Point Signals: Job postings, complaints, market trends
5. Personalization Hooks: Specific details for your outreach

This used to take 10-15 minutes per prospect. Now it takes seconds.

The Claude Code Approach​

Claude Code can:

• Execute searches and aggregate results
• Read web pages and extract key information
• Structure unstructured data into useful formats
• Reason about what matters for your use case

Here's a prompt template that generates complete prospect briefs:

Research this company for a B2B sales outreach:

**Company:** {\{company_name\}}
**Our Product:** AI-powered SDR platform that turns intent signals into pipeline

**Create a prospect brief with:**

1. **Company Overview**
   - What they do (one sentence)
   - Employee count and headquarters
   - Industry and target market

2. **Recent Activity (Last 6 Months)**
   - Funding or acquisitions
   - Product launches
   - Leadership changes
   - Press coverage

3. **Sales-Relevant Signals**
   - Are they hiring for SDRs, sales ops, or demand gen?
   - Any complaints about lead quality or outbound efficiency?
   - What CRM/sales stack do they use? (check job postings)

4. **Personalization Hooks**
   - 3 specific details I can reference in an email
   - Potential pain points based on their situation
   - Suggested angle for outreach

5. **Recommended Next Step**
   - Best channel to reach them (email, LinkedIn, phone)
   - Suggested first message angle

Be specific. Use actual data, not generic statements.

Setting Up Automated Research​

Option 1: OpenClaw + Claude (Always-On)​

If you want research to run automatically when new leads come in:

# OpenClaw config
cron:
  jobs:
    - name: "New Lead Research"
      schedule:
        kind: every
        everyMs: 900000  # Every 15 minutes
      payload:
        kind: agentTurn
        message: |
          Check HubSpot for contacts added in the last 15 minutes.
          For each new contact, create a prospect brief and add it
          to the contact notes field.

This runs in the background, enriching leads as they arrive.

Option 2: Claude Code CLI (On-Demand)​

For manual research when you need it:

# Install Claude Code
npm install -g @anthropic-ai/claude-code

# Run research
claude-code research "Acme Corp"

Option 3: VS Code Extension​

If you work in VS Code, Claude Code integrates directly:

1. Highlight a company name
2. Cmd+Shift+P → "Claude: Research Prospect"
3. Get a brief in your sidebar

Real Research Output Example​

Here's what Claude Code actually produces for a real company:

Company: Hologram (hologram.io)

Overview: IoT connectivity platform providing global cellular for devices. ~150 employees, HQ in Chicago. Series B ($65M from Battery Ventures).

Recent Activity:

• Feb 2026: Launched Hyper network for low-latency IoT
• Jan 2026: Partnership with AWS IoT Core announced
• Hiring: 3 open SDR roles, 2 demand gen positions

Sales Signals:

• Job posting mentions "scaling outbound motion" and "improving lead quality"
• Uses HubSpot (seen in job req), Outreach for sequences
• Active on G2 responding to reviews (cares about buyer perception)

Personalization Hooks:

1. Reference the Hyper launch: "Saw the Hyper network announcement—congrats"
2. Note the hiring push: "Looks like you're scaling the SDR team"
3. Connect to IoT/connectivity angle: "We work with several IoT companies..."

Recommended Approach: LinkedIn → Email sequence. Their team is active on LinkedIn. Reference specific content they've posted.

This took 15 seconds to generate. A human would need 10-15 minutes minimum.

Enrichment Sources Claude Code Can Access​

When you give Claude Code research tasks, it can pull from:

The key is structuring your prompt to tell Claude what matters for your specific outreach.

Advanced: Building a Research Pipeline​

For high-volume prospecting, build a full pipeline:

[New Lead] 
    ↓
[Basic Enrichment] 
    - Company size, industry
    - Contact title, seniority
    ↓
[ICP Scoring]
    - Match against ideal customer profile
    - Score 1-100
    ↓
[Deep Research] (if score > 70)
    - Full prospect brief
    - Personalization hooks
    ↓
[Routing]
    - Hot leads → Slack alert + call queue
    - Warm leads → Automated sequence
    - Cold leads → Nurture list

Each step can be automated with Claude Code + OpenClaw.

Common Mistakes to Avoid​

1. Researching Every Lead Equally

Not every lead deserves 10 minutes of research. Use basic enrichment to score first, then deep-dive on high-potential prospects only.

2. Ignoring Negative Signals

Good research includes disqualifying information. If a company just laid off their sales team, that's important context.

3. Stale Data

Information decays. Set up refresh cycles for long-nurture prospects.

4. Over-Personalizing

Mentioning 5 specific details in an email feels creepy. Pick the ONE most relevant hook.

Measuring Research Quality​

Track these metrics:

• Time per lead: Should drop from 10-15 min to under 1 min
• Reply rates: Better research → better personalization → higher replies
• Qualification accuracy: Are AI-scored leads actually converting?
• Rep adoption: Is your team actually using the briefs?

The MarketBetter Advantage​

MarketBetter does this automatically for every website visitor:

1. Identify: Know which companies visit your site
2. Enrich: Pull firmographic and technographic data
3. Research: AI generates prospect briefs
4. Prioritize: Score and route to the right rep
5. Act: Get a daily playbook of exactly who to contact

No manual research required. No copy-pasting between tools.

Ready to automate your lead research? See how MarketBetter turns visitor identification into actionable prospect intelligence. Book a demo.

Related Posts​

• How to Build an AI SDR with OpenClaw
• Claude vs ChatGPT for Sales Teams
• 10 AI Prompts That 10x SDR Productivity

"Who should I call next?"
"What's the context on this deal?"
"Draft me a follow-up email."

What if you could ask these questions and get instant, accurate answers—based on YOUR CRM, YOUR email history, YOUR calendar?

That's what a sales copilot does. And with OpenClaw, you can build one for free.

What is a Sales Copilot?​

A sales copilot is an AI assistant that knows your business context:

• Your deals: Pipeline stages, deal values, next steps
• Your contacts: Communication history, preferences, pain points
• Your calendar: Upcoming meetings, prep needed
• Your emails: Recent exchanges, follow-ups due

Unlike generic ChatGPT, a copilot doesn't need you to paste context every time. It already knows.

Why Build Your Own (vs. Buying)?​

Off-the-shelf AI SDR tools cost $35,000-50,000/year. They come with:

• Features you don't need
• Limitations on customization
• Data that lives on someone else's servers

OpenClaw is free and open source. You:

• Build exactly what you need
• Own your data completely
• Customize endlessly

Architecture Overview​

Here's what we're building:

[You via WhatsApp/Slack/Telegram]
           ↓
      [OpenClaw]
           ↓
   [Claude/GPT-4 API]
           ↓
┌─────────────────────┐
│   Your Data Sources │
│  • HubSpot CRM      │
│  • Gmail/Outlook    │
│  • Google Calendar  │
│  • Company Docs     │
└─────────────────────┘
           ↓
[Context-Aware Response]

OpenClaw acts as the bridge, connecting the AI to your tools.

Step 1: Install OpenClaw​

npx openclaw@latest init

This creates your workspace with:

• Configuration files
• Memory system
• Agent definitions

Step 2: Connect Your Data Sources​

HubSpot CRM​

Create a Private App in HubSpot and add to your config:

# .openclaw/config.yaml
plugins:
  hubspot:
    enabled: true
    token: ${HUBSPOT_TOKEN}

Email (Microsoft 365)​

Set up Graph API access:

plugins:
  ms365:
    enabled: true
    clientId: ${MS365_CLIENT_ID}
    tenantId: ${MS365_TENANT_ID}
    clientSecret: ${MS365_CLIENT_SECRET}

Google Calendar​

plugins:
  gcal:
    enabled: true
    credentials: ${GCAL_CREDENTIALS_PATH}

Step 3: Define Your Copilot's Personality​

Create a SOUL.md file that defines how your copilot behaves:

# SOUL.md - Sales Copilot

## Who I Am
I'm your sales copilot. I know your pipeline, your contacts, 
and your calendar. I help you sell smarter.

## How I Communicate
- Direct and actionable
- I give specific recommendations, not generic advice
- I cite my sources (which deal, which email, etc.)
- I flag urgency when it matters

## What I Can Do
- Pull deal info from HubSpot
- Summarize email threads
- Check upcoming meetings
- Draft follow-up messages
- Alert you to stale deals

## What I Won't Do
- Send emails without your approval
- Make changes to CRM without confirmation
- Share your data anywhere

Step 4: Create Core Commands​

Define common queries your copilot can handle:

"Who should I call today?"​

# In your agent config
prompts:
  call_priority:
    message: |
      Check my HubSpot pipeline and identify:
      1. Deals that haven't had activity in 7+ days
      2. Deals with meetings scheduled this week
      3. High-value deals (>$10K) in negotiation stage
      
      Rank by urgency. For each, tell me:
      - Company name and deal value
      - Last contact date and method
      - Suggested talking point based on history

"Prep me for my next call"​

prompts:
  meeting_prep:
    message: |
      My next meeting is in {{time_until}} with {{contact_name}}.
      
      Pull together:
      1. Company overview (from HubSpot + web research)
      2. Deal history and current stage
      3. All email exchanges in last 30 days
      4. Key talking points based on their pain points
      5. Potential objections to prepare for
      
      Format as a quick-reference briefing I can scan in 2 minutes.

"Draft a follow-up email"​

prompts:
  follow_up:
    message: |
      I just finished a call with {{contact_name}} at {{company}}.
      
      Based on our email history and CRM notes, draft a follow-up email that:
      1. Thanks them for the call
      2. Summarizes key points we discussed
      3. Proposes clear next steps
      4. Maintains my usual tone (check recent sent emails)
      
      Keep it under 150 words.

Step 5: Set Up Proactive Alerts​

Your copilot shouldn't just respond—it should reach out when needed:

# Cron jobs for proactive alerts
cron:
  jobs:
    - name: "Morning Pipeline Brief"
      schedule:
        kind: cron
        expr: "0 8 * * 1-5"  # 8am weekdays
      payload:
        kind: agentTurn
        message: |
          Good morning! Here's your pipeline brief:
          
          1. Meetings today (with quick context)
          2. Deals needing attention (stale or slipping)
          3. Follow-ups due
          4. Any hot signals (new website visitors, email opens)
          
          Keep it to 5-7 bullet points max.

    - name: "Stale Deal Alert"
      schedule:
        kind: cron
        expr: "0 14 * * 1-5"  # 2pm weekdays
      payload:
        kind: agentTurn
        message: |
          Check for deals over $5K that haven't been touched in 10+ days.
          If you find any, alert me with:
          - Deal name and value
          - Last activity
          - Suggested re-engagement approach

Step 6: Connect Your Messaging Channel​

OpenClaw supports multiple channels:

WhatsApp (Personal)​

openclaw whatsapp link
# Scan QR code with your phone

Slack​

plugins:
  slack:
    enabled: true
    token: ${SLACK_BOT_TOKEN}
    channel: "#sales-copilot"

Telegram​

plugins:
  telegram:
    enabled: true
    token: ${TELEGRAM_BOT_TOKEN}

Real Conversation Examples​

Here's what interacting with your copilot looks like:

You: Who needs follow-up today?

Copilot: 3 follow-ups due:

1. Acme Corp ($24K) - Demo was 3 days ago, promised to send proposal. Send it now.

2. Initech ($12K) - They went quiet after pricing. Suggest: value-focused check-in email.

3. Hooli ($45K) - Contract review since Monday. Time for a nudge.

Want me to draft emails for any of these?

You: Yes, draft Acme proposal email

Copilot: Based on your call notes from Thursday:

Subject: Acme proposal as promised

Hi Sarah,

Great speaking Thursday about reducing your SDR ramp time. As promised, I've attached our proposal.

Key points covered:

• Visitor identification for 5K monthly visitors
• HubSpot integration (you mentioned this was critical)
• 90-day pilot option

Want to find 15 minutes next week to walk through it?

Best, [Your name]

Send, edit, or scrap?

Advanced: Adding Custom Tools​

OpenClaw supports custom tools. Example: Add a "competitor check" tool:

// tools/competitor-check.js
module.exports = {
  name: 'check_competitor',
  description: 'Check if a prospect uses a competitor product',
  parameters: {
    company: { type: 'string', required: true }
  },
  async execute({ company }) {
    // Check BuiltWith, job postings, etc.
    const techStack = await fetchTechStack(company);
    return techStack.filter(t => COMPETITORS.includes(t));
  }
};

Now your copilot can answer: "Does Acme use any competitor products?"

Common Pitfalls​

1. Too Much Context Don't dump your entire CRM into every prompt. Be selective about what context matters for each query.

2. No Memory Structure Use OpenClaw's memory files to store persistent context (ICP, competitors, etc.) so you don't repeat yourself.

3. Forgetting Permissions Your copilot has access to sensitive data. Keep it on a secure channel. Don't expose it to shared workspaces.

4. Over-Automation Start with assisted workflows (copilot drafts, you approve). Don't go full autonomous until you trust the outputs.

What's Next?​

Once your basic copilot works, extend it:

• Add competitive intelligence lookups
• Connect to Gong/Chorus for call analysis
• Build a deal coaching mode
• Create a forecasting assistant

The foundation is the same—you're just adding more context and capabilities.

Don't want to build from scratch? MarketBetter comes with AI-powered playbooks built in. Visitor identification, lead prioritization, and recommended actions—no coding required. Book a demo.

Related Posts​

• OpenClaw + HubSpot: The Ultimate CRM Automation
• How to Automate Lead Research with Claude Code
• The AI SDR Tech Stack We Actually Use

Your SDRs spend just 35% of their time actually selling. The rest? Research, data entry, writing emails, prepping for calls. Both Claude and ChatGPT promise to automate this busywork—but they take different approaches.

After running both AIs on real sales workflows at MarketBetter (and building an AI SDR with OpenClaw), here's what we learned about when to use each.

Three AI tools. All capable. But which one should your GTM team actually use?

With GPT-5.3-Codex dropping February 5, 2026, the landscape just shifted. Again. This guide breaks down OpenAI Codex, Claude Code, and ChatGPT for sales and marketing use cases—with specific recommendations for each workflow.

Quick Summary: Which AI for Which Task​

Now let's dig into the details.

OpenAI Codex (GPT-5.3-Codex)​

Released: February 5, 2026
What it is: OpenAI's most capable agentic coding model

Key Features​

• 25% faster than GPT-5.2-Codex
• Mid-turn steering: Direct the agent while it's working (killer feature)
• Runs in Codex app, CLI, IDE extension, or Codex Cloud
• Multi-file changes: Can edit entire codebases
• Built for autonomy: Designed to work on complex tasks without constant prompting

GTM Use Cases for Codex​

1. Building Sales Automation Scripts

   • Write HubSpot/Salesforce API integrations
   • Build custom lead scoring models
   • Create data sync workflows

2. Pipeline Monitoring Systems

   • Alert systems for stale deals
   • Automated reporting dashboards
   • Integration scripts between tools

3. Custom Sales Tools

   • Chrome extensions for LinkedIn
   • Email template generators
   • Proposal automation systems

Codex Pricing (2026)​

• Codex CLI: Free tier available, pay per API call
• Codex Cloud: ~$50/user/month (team features)
• Enterprise: Custom pricing

When NOT to Use Codex​

• Simple email writing (overkill)
• Non-technical tasks (use Claude or ChatGPT)
• Quick research (Claude's context window is better)

Claude Code (Anthropic)​

What it is: Claude 3.5/4 with tool use and code execution
Integrated into: VS Code, terminal, OpenClaw

Key Features​

• 200K context window: Can analyze entire documents, codebases, or conversation histories
• Precise instruction following: Better at nuanced tasks
• Constitutional AI: More reliable safety guardrails
• Tool use: Can browse web, execute code, interact with APIs

GTM Use Cases for Claude​

1. Prospect Research

   • Deep-dive company analysis
   • Competitive intelligence reports
   • Personalization hook identification

2. Email Writing

   • Personalized outreach at scale
   • Multi-touch sequence creation
   • Reply handling suggestions

3. Document Analysis

   • Analyzing sales call transcripts
   • Extracting insights from RFPs
   • Summarizing long email threads

4. Sales Coaching

   • Call analysis and feedback
   • Objection handling suggestions
   • Win/loss pattern identification

Claude Pricing (2026)​

• Claude.ai: $20/month Pro, $30/month Teams
• API: $3-15 per million tokens (varies by model)
• OpenClaw: Free (bring your own API key)

When NOT to Use Claude​

• Heavy code generation (Codex is faster)
• Real-time chat (ChatGPT has lower latency)
• Tasks requiring strict format adherence (can be verbose)

ChatGPT (GPT-4o/4-Turbo)​

What it is: OpenAI's general-purpose assistant
Best for: Quick tasks, brainstorming, general questions

Key Features​

• Lowest latency: Fastest responses
• Plugins and GPTs: Extensible for specific use cases
• Web browsing: Built-in search
• Voice mode: Conversational interface

GTM Use Cases for ChatGPT​

1. Quick Research

   • "What does [company] do?"
   • "Who are [competitor]'s biggest customers?"
   • "What's the average deal size in [industry]?"

2. Brainstorming

   • Subject line ideas
   • Objection responses
   • Campaign angles

3. Light Automation

   • Simple data formatting
   • Template generation
   • Quick calculations

ChatGPT Pricing (2026)​

• Free: Basic access
• Plus: $20/month
• Team: $25/user/month
• Enterprise: Custom

When NOT to Use ChatGPT​

• Complex, multi-step workflows (use Codex)
• Long document analysis (Claude's context is better)
• Tasks requiring precise formatting (can be inconsistent)

Head-to-Head: The Details​

Context Window​

Winner for GTM: Claude. When researching prospects or analyzing long conversations, context matters.

Instruction Following​

Claude excels at following precise instructions. If you say "write exactly 3 bullet points," you get 3 bullet points.

ChatGPT tends to add extra context or caveats.

Codex is excellent for technical instructions but can over-engineer simple requests.

Winner for GTM: Claude for content, Codex for technical tasks.

Agentic Capabilities​

Codex was built for autonomous work. The mid-turn steering feature lets you redirect it without starting over.

Claude can be agentic via OpenClaw but requires more setup.

ChatGPT's agentic features are limited.

Winner for GTM: Codex for automation, Claude via OpenClaw for custom agents.

Speed​

Winner for GTM: Depends on use case. ChatGPT for quick tasks, Codex for batch processing.

The Best Stack for GTM Teams​

Based on our analysis, here's the optimal setup:

For SDRs​

• Primary: Claude (via OpenClaw for automation)
• Secondary: ChatGPT (quick questions)
• When needed: Codex (building custom tools)

For Sales Ops​

• Primary: Codex (building automation)
• Secondary: Claude (analysis and research)
• When needed: ChatGPT (quick prototyping)

For Marketing​

• Primary: Claude (content and research)
• Secondary: ChatGPT (brainstorming)
• When needed: Codex (programmatic SEO, automation)

Integration Comparison​

OpenClaw Compatibility​

OpenClaw works best with Claude due to Anthropic's tool use design.

CRM Integration​

• Codex: Best for building custom integrations
• Claude: Best for enrichment and research tasks
• ChatGPT: Limited native integration

Real-World Performance: Email Personalization​

We tested all three on the same task: Write a personalized cold email for a VP of Sales at a 200-person SaaS company.

Claude Output​

Followed the template exactly. Referenced specific company details. Professional but warm tone. 94 words (as requested).

ChatGPT Output​

Added extra context we didn't ask for. Good personalization but verbose. 147 words (missed the target).

Codex Output​

Technical and formal. Suggested code-like structures. Not ideal for email writing.

Winner: Claude for email personalization.

The Bottom Line​

There's no single best tool. The right answer depends on your workflow:

• Building automation? → Codex
• Writing content? → Claude
• Quick questions? → ChatGPT
• Running AI agents 24/7? → OpenClaw + Claude

The smartest teams use multiple tools for different tasks rather than forcing one tool to do everything.

Want AI that's already integrated? MarketBetter combines visitor identification, AI-powered playbooks, and automated outreach in one platform. No prompt engineering required. Book a demo.

Related Posts​

• GPT-5.3-Codex: What It Means for GTM Teams
• How to Build an AI SDR with OpenClaw
• Claude vs ChatGPT for Sales Teams

When GPT-5.3-Codex dropped on February 5, 2026, everyone focused on the "25% faster" headline. But the real game-changer? Mid-turn steering.

This feature lets you redirect an AI agent while it's working—not after it finishes. For GTM teams running complex automation, this changes everything.

What is Mid-Turn Steering?​

Traditionally, when you ask an AI to do something, you wait until it's done to give feedback. If it goes off track, you:

1. Wait for completion
2. Read the output
3. Write a correction prompt
4. Start over

Mid-turn steering breaks this pattern. You can intervene during execution:

You: Build a lead scoring model based on our HubSpot data

Codex: [starts working]
       - Pulling contact fields...
       - Analyzing conversion patterns...
       - Building scoring criteria...

You: Actually, weight company size more heavily than title

Codex: [adjusts mid-task]
       - Updating weight for company_size field...
       - Recalculating score thresholds...
       [continues with adjustment]

No restart. No lost work. Just a course correction.

Why This Matters for GTM​

1. Complex Automation Doesn't Fail Silently​

When building sales automation, you often don't know exactly what you want until you see the first attempt. Mid-turn steering lets you:

• Watch the agent's approach in real-time
• Correct misunderstandings immediately
• Guide toward edge cases as they appear

Without this, a 20-minute automation task might need 3-4 full restarts to get right.

2. Better Collaboration with AI​

Mid-turn steering makes AI feel less like a black box and more like a collaborator. You're not just prompting and praying—you're actively directing.

For sales leaders building complex workflows, this means:

• Faster iteration cycles
• More precise outputs
• Higher confidence in automation

3. Reduced Token Waste​

Every restart burns tokens. Mid-turn steering reduces:

• Repeated context loading
• Duplicate work
• Prompt engineering overhead

For teams running Codex at scale, this adds up.

GTM Use Cases for Mid-Turn Steering​

Building Custom Lead Scoring​

Traditional approach:

1. Ask Codex to build a lead score
2. Wait 10 minutes
3. Realize it weighted "email opened" too heavily
4. Start over with clarification
5. Wait another 10 minutes

With mid-turn steering:

1. Ask Codex to build a lead score
2. Watch it start weighting criteria
3. "Wait—de-emphasize email opens, focus on website visits"
4. Codex adjusts in real-time
5. Get the right model in one pass

Generating Email Sequences​

Traditional approach:

1. "Write a 5-email nurture sequence"
2. Wait for all 5 emails
3. Email 3 is too salesy
4. Restart or write complex follow-up prompt

With mid-turn steering:

1. "Write a 5-email nurture sequence"
2. After email 2: "Make these more educational, less pitch-focused"
3. Codex adjusts emails 3-5 accordingly
4. Done

Building Pipeline Dashboards​

Traditional approach:

1. "Build a pipeline dashboard showing X, Y, Z"
2. Wait for completion
3. Visualizations aren't quite right
4. Describe changes in detail
5. Hope it understands

With mid-turn steering:

1. "Build a pipeline dashboard"
2. See the chart types being chosen
3. "Actually, use bar charts for that, not pie"
4. Watch it switch mid-build
5. "Add a filter for deal size"
6. Done with all adjustments in one session

How to Use Mid-Turn Steering​

In Codex CLI​

# Start a task
codex run "Build a HubSpot integration that syncs new contacts"

# While it's running, type to intervene
> Also add error handling for rate limits
> Skip the logging for now, we'll add that later

In Codex Cloud (Web UI)​

The Codex dashboard shows real-time execution. A sidebar lets you:

• See what the agent is currently doing
• Type interventions
• Pause/resume execution
• Save partial progress

Via API​

const session = await codex.createSession({
  task: "Build lead enrichment pipeline",
  onProgress: (state) => console.log(state),
  allowSteering: true
});

// Intervene mid-task
await session.steer("Use Apollo for enrichment instead of Clearbit");

Best Practices for Mid-Turn Steering​

1. Let It Start Before Steering​

Don't intervene in the first 10 seconds. Let Codex show its approach first—you might learn something.

2. Be Specific with Corrections​

❌ "That's not quite right"
✅ "Use percentage instead of raw numbers for the conversion column"

3. Steer Early, Not Late​

If you see it going the wrong direction, intervene immediately. Don't wait until it's 80% done.

4. Save Checkpoints​

For complex tasks, tell Codex to checkpoint progress: "After each major step, commit and show me the current state"

This lets you roll back if steering doesn't work.

5. Don't Over-Steer​

Every intervention has overhead. If you're steering every 30 seconds, your initial prompt probably wasn't clear enough.

Mid-Turn Steering vs. Other Approaches​

Mid-turn steering gives you the autonomy of agents with the control of manual prompting.

Real Example: Building a Competitor Alert System​

Here's a real session transcript (abbreviated):

Me: Build a system that alerts me when competitors publish new content

Codex: Starting. I'll:
       1. Set up RSS feeds for competitor blogs
       2. Create a daily digest
       3. Send via email
       
       Setting up RSS parser...

Me: Actually, send via Slack not email

Codex: Switching to Slack webhook...
       Setting up #competitor-intel channel post...

Me: Also check their Twitter, not just blogs

Codex: Adding Twitter API integration...
       Will monitor @Warmly_AI, @CommonRoom...

Me: Add @6sense too

Codex: Added. Continuing with alert formatting...

[5 minutes later]

Codex: Done. System checks hourly, posts to #competitor-intel
       when new content detected.

That would have been 3-4 restarts without mid-turn steering.

Limitations to Know​

1. Not All Tasks Support Steering​

Some operations (like API calls mid-flight) can't be interrupted. Codex will tell you when steering isn't possible.

2. Token Cost Still Applies​

Steering doesn't reduce total tokens—it just uses them more efficiently.

3. Requires Real-Time Attention​

If you're not watching, you can't steer. For hands-off automation, traditional approaches might be better.

The Bottom Line​

Mid-turn steering is Codex's competitive moat for complex GTM automation. It transforms AI from "prompt and pray" to "collaborative building."

For teams building:

• Custom integrations
• Complex workflows
• Multi-step automation

This feature alone justifies using Codex over alternatives.

Want AI that works out of the box? MarketBetter combines visitor identification, automated playbooks, and AI-driven outreach—no prompting required. Book a demo.

Related Posts​

• OpenAI Codex vs Claude Code vs ChatGPT: Complete GTM Comparison
• GPT-5.3-Codex: What It Means for GTM Teams
• How to Build a Sales Copilot with OpenClaw

OpenAI dropped GPT-5.3-Codex on February 5, 2026. Three days later, the GTM world is still figuring out what it means.

Here's the short version: This is the most capable AI coding agent ever released, and it's going to change how sales and marketing teams build automation.

If you're a VP of Sales, SDR Manager, or RevOps leader wondering whether this matters to you—it absolutely does. Not because you need to become a developer, but because the barrier to building custom sales tools just dropped to near-zero.

Let me explain.

What Is GPT-5.3-Codex?​

GPT-5.3-Codex is OpenAI's cloud-based AI agent designed specifically for software engineering tasks. Think of it as having a senior developer on call 24/7 who can:

• Write complete applications from scratch
• Refactor existing code
• Build integrations between your tools
• Create custom automations

But here's what makes 5.3 different from previous versions:

Mid-Turn Steering​

This is the killer feature. Previous AI coding tools worked like this: you give a prompt, wait for the output, then correct mistakes and try again.

With mid-turn steering, you can redirect the agent while it's working. See it going down the wrong path? Tell it to change direction. Want to add a requirement halfway through? Just say so.

For GTM teams, this means:

• You can describe what you want in plain English
• Watch as the agent builds it
• Course-correct in real-time
• Get exactly what you need, faster

25% Faster Than GPT-5.2-Codex​

Speed matters when you're iterating on sales tools. The new model generates code significantly faster, which means:

• Quicker prototypes of new automation ideas
• Faster debugging when something breaks
• More experiments per sprint

Multi-File Projects​

Codex can now handle complex, multi-file projects natively. This means it can build real applications—not just scripts—including:

• Full CRM integrations
• Multi-step email sequences
• Dashboard applications
• API connectors

Why This Matters for GTM Teams​

Here's the uncomfortable truth about sales technology in 2026: The best tools are the ones you build yourself.

Generic AI SDR platforms cost $35,000-50,000 per year. They're built for the average use case, which means they're perfect for nobody.

Meanwhile, the teams winning right now are:

1. Identifying their specific bottlenecks
2. Building custom automations to solve them
3. Iterating weekly based on results

GPT-5.3-Codex makes this accessible to teams without dedicated developers.

Real Example: Custom Lead Research Agent​

Let's say your SDRs spend 20 minutes researching each prospect before outreach. You could:

Option A: Pay for a generic "AI research" tool ($15-25K/year) Option B: Build exactly what you need with Codex

Here's what Option B looks like:

"Build me a lead research agent that:
1. Takes a company name and prospect name as input
2. Finds their recent LinkedIn posts (last 30 days)
3. Checks if they've raised funding recently
4. Identifies any job changes in their department
5. Outputs a 3-sentence research summary I can paste into my email"

With GPT-5.3-Codex, you can build this in an afternoon. Total cost: Your time + ~$20/month in API calls.

Real Example: Pipeline Alert System​

Your VP of Sales wants to know immediately when:

• A deal over $50K stalls for more than 7 days
• An enterprise prospect opens a proposal 3+ times
• A competitor is mentioned in meeting notes

Building this with traditional development: 2-4 weeks and $5-10K

Building this with Codex + OpenClaw: A weekend

"Create a HubSpot integration that monitors our pipeline and sends
Slack alerts when:
1. Any deal over $50K hasn't had activity in 7+ days
2. Proposal tracking shows 3+ opens
3. Meeting notes (from Gong or Fireflies) mention competitor names

Run this check every 4 hours."

The OpenClaw Advantage​

Here's where it gets interesting. Codex is powerful, but it's a tool—it doesn't run 24/7 on its own.

OpenClaw is an open-source gateway that lets you:

• Deploy AI agents that run continuously
• Connect to your messaging platforms (Slack, WhatsApp, Telegram)
• Schedule cron jobs for recurring tasks
• Give agents memory across sessions
• Access browser automation for web tasks

The combination of Codex + OpenClaw = DIY AI SDR infrastructure.

Build the automations with Codex. Deploy them on OpenClaw. Run them 24/7 for free (you're self-hosting).

Getting Started: A Practical Roadmap​

Week 1: Install and Experiment​

1. Install the Codex CLI:

npm install -g @openai/codex

2. Start with a simple project—maybe a script that enriches a CSV of leads with company data.

3. Practice mid-turn steering. Give vague instructions, then refine as you watch it work.

Week 2: Build Your First Sales Tool​

Pick your biggest time-waster. Common candidates:

• Manual CRM updates
• Lead research
• Follow-up scheduling
• Meeting prep

Build a tool that automates 50% of it. Don't aim for perfection—aim for "better than manual."

Week 3: Deploy with OpenClaw​

Set up OpenClaw on a $5/month VPS (DigitalOcean, Vultr, etc.). Deploy your automation. Connect it to Slack so you can interact with it.

Week 4: Iterate Based on Results​

Your first version will be wrong. That's fine. The advantage of building your own tools is that you can change them weekly.

What Codex Can and Can't Do​

Codex Excels At:​

• Building integrations between SaaS tools
• Creating data processing pipelines
• Writing API connectors
• Automating repetitive code tasks
• Generating boilerplate for common patterns

Codex Struggles With:​

• Tasks requiring deep domain expertise
• Anything that needs real-time human judgment
• Complex UI design (it can build functional UIs, not beautiful ones)
• Tasks that require browsing the live web (use OpenClaw's browser tools for this)

Combine With Claude for Best Results​

For GTM automation specifically, Claude Code tends to be better at:

• Writing persuasive copy
• Analyzing unstructured data (emails, call transcripts)
• Making judgment calls about prospect intent

The winning stack for most teams:

• Codex: Build the infrastructure
• Claude: Handle the nuanced tasks
• OpenClaw: Orchestrate everything

Cost Comparison: Build vs. Buy​

*Assuming $20-40/month in API costs + minimal hosting

The catch: DIY requires someone on your team who's comfortable with technical projects. But you don't need a developer—you need someone curious enough to experiment.

The Build vs. Buy Decision​

Build your own when:

• Your workflow is unique
• You need rapid iteration
• Budget is constrained
• You have someone technical-adjacent on the team

Buy off-the-shelf when:

• You need enterprise support/SLAs
• Nobody on the team wants to maintain tools
• Your use case is generic
• Speed-to-value is critical

For most SMB and mid-market GTM teams in 2026, the math now favors building.

What This Means for the AI SDR Market​

GPT-5.3-Codex is going to put pressure on every AI sales tool that isn't providing genuine differentiation.

If your value proposition is "we connect to your CRM and do basic automation"—teams can now build that themselves in a weekend.

The winners will be tools that provide:

• Proprietary data (intent signals, company graphs)
• Deep workflow expertise (not just tools, but playbooks)
• Outcomes, not features

At MarketBetter, we've always believed in the "build your own" approach for teams that can handle it. That's why we focus on providing the intelligence layer—visitor identification, buying signals, and playbooks—rather than trying to own your entire workflow.

Getting Started Today​

1. Try Codex: Even if you're not technical, spend an hour with it. Ask it to build something simple for your sales process.

2. Audit Your Workflow: Where do your SDRs lose time? Make a list of the 5 most repetitive tasks.

3. Pick One to Automate: Start small. One successful automation builds confidence for the next.

4. Consider OpenClaw: If you want your automations to run 24/7, OpenClaw is the easiest path.

The release of GPT-5.3-Codex isn't just a technical milestone. It's a shift in what's possible for GTM teams without dedicated engineering resources.

The question isn't whether AI will change how you sell. The question is whether you'll build your own advantage—or rent someone else's.

Ready to see how MarketBetter's intelligence layer works with your custom automations? Book a demo →

Your CRM is only as good as the data inside it. And let's be honest—most CRMs are graveyards of stale contacts, forgotten deals, and "I'll update it later" promises that never happen.

What if your CRM updated itself?

That's exactly what happens when you connect OpenClaw—the open-source AI agent gateway—to HubSpot. You get an always-on AI assistant that monitors your pipeline, enriches contacts automatically, and alerts you before deals go cold.

Why Manual CRM Updates Are Killing Your Pipeline​

The average SDR spends 28% of their week on administrative tasks. Most of that is CRM data entry:

• Logging call notes
• Updating deal stages
• Adding contact information
• Setting follow-up reminders

That's 11+ hours per week not selling.

Worse, when reps get busy (which is always), CRM hygiene drops. Deals sit in the wrong stages. Contact info goes stale. Follow-ups get missed.

The result? Pipeline visibility becomes a lie. Your forecast is based on outdated data, and winnable deals slip through the cracks.

What OpenClaw + HubSpot Actually Does​

OpenClaw acts as a bridge between AI models (Claude, GPT-4, etc.) and your business tools. When connected to HubSpot, it can:

1. Auto-Enrich New Contacts​

When a new contact hits HubSpot, OpenClaw can:

• Research the contact's company
• Find their LinkedIn profile
• Pull recent news about their company
• Add firmographic data (company size, industry, tech stack)