Your lead routing is broken.

A prospect fills out a demo form at 2 PM. They get assigned to a rep at 4 PM. The rep emails them the next morning. By then, they've already booked calls with two competitors.

The data is brutal:

• Leads contacted within 5 minutes are 21x more likely to qualify
• Average B2B response time: 42 hours
• 78% of buyers choose the vendor who responds first

In 2026, lead routing shouldn't take hours. It shouldn't even take minutes. With OpenAI's GPT-5.3 Codex, you can build intelligent routing that matches leads to reps in seconds—based on fit, capacity, expertise, and likelihood to close.

This guide walks you through building that system.

Why Traditional Lead Routing Fails​

Most companies use one of these routing methods:

Round Robin​

• How it works: Leads distributed equally to all reps
• The problem: Your best rep gets the same load as your newest hire. High-value leads go to reps without relevant experience.

Geographic/Territory​

• How it works: Leads assigned by region or named accounts
• The problem: Territories become outdated. Hot leads sit in cold territories. Territory conflicts create friction.

First Available​

• How it works: Whoever claims it first gets it
• The problem: Creates a feeding frenzy. Aggressive reps hoard leads. Less assertive reps (who might be better fits) never get chances.

Manual Assignment​

• How it works: Manager reviews and assigns each lead
• The problem: Creates bottleneck. Manager goes to lunch, leads wait. Scale breaks the model entirely.

What all these miss: Context. They don't understand the lead OR the rep. They're just moving names between buckets.

What AI-Powered Routing Looks Like​

Intelligent routing considers:

About the Lead:

• Company size, industry, and technographics
• Stated pain points and urgency signals
• Previous interactions with your brand
• Predicted deal size and likelihood to close

About Available Reps:

• Current capacity and workload
• Historical win rates for similar leads
• Industry/vertical expertise
• Time zone and availability
• Relationship to the account (existing contacts)

The Match:

• Which rep has the highest probability of closing THIS lead?
• Who can respond fastest right now?
• Who has relevant case studies and references?

This is exactly what GPT-5.3 Codex can evaluate—instantly.

Architecture: The AI Routing Engine​

Here's how to structure your Codex-powered routing system:

┌─────────────────────────────────────────────────────────────┐
│                      Lead Sources                            │
│  (Forms, Chat, Events, Intent Data, Inbound Calls)         │
└─────────────────┬───────────────────────────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────────────────────────┐
│                   Lead Enrichment Layer                      │
│  (Clearbit, Apollo, LinkedIn, Technographics)              │
└─────────────────┬───────────────────────────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────────────────────────┐
│              Codex Routing Decision Engine                   │
│                                                              │
│  1. Score lead (fit + intent + urgency)                     │
│  2. Pull rep availability + capacity                        │
│  3. Match based on expertise + history                      │
│  4. Select optimal rep                                       │
│  5. Handle edge cases (overflow, escalation)                │
└─────────────────┬───────────────────────────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────────────────────────┐
│                     CRM Assignment                           │
│  (HubSpot, Salesforce, Pipedrive)                          │
└─────────────────┬───────────────────────────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────────────────────────┐
│              Notification & Action Layer                     │
│  (Slack alert, Email, Calendar invite, Sequence start)      │
└─────────────────────────────────────────────────────────────┘

Building with GPT-5.3 Codex​

Codex's mid-turn steering makes it ideal for routing—you can adjust decisions in real-time as context changes.

Step 1: Set Up the Routing Agent​

# lead_router.py
import openai
import json
from datetime import datetime
from typing import Dict, List, Optional

class CodexLeadRouter:
    def __init__(self):
        self.client = openai.OpenAI()
        self.routing_rules = self.load_routing_rules()
        
    def load_routing_rules(self) -> Dict:
        """Load your company's routing configuration."""
        return {
            "high_value_threshold": 50000,  # ARR threshold for enterprise routing
            "response_sla_minutes": 5,
            "max_leads_per_rep_per_day": 15,
            "expertise_tags": [
                "healthcare", "fintech", "saas", "manufacturing", 
                "retail", "logistics", "cybersecurity"
            ],
            "escalation_triggers": [
                "competitor_mentioned",
                "budget_over_100k",
                "c_level_contact",
                "existing_customer"
            ]
        }
    
    def get_rep_roster(self) -> List[Dict]:
        """Pull current rep availability and stats from CRM."""
        # In production, this queries your CRM/database
        return [
            {
                "id": "rep_001",
                "name": "Sarah Chen",
                "status": "available",
                "current_leads_today": 8,
                "expertise": ["saas", "fintech"],
                "win_rate_ytd": 0.34,
                "avg_deal_size": 45000,
                "timezone": "America/New_York"
            },
            {
                "id": "rep_002", 
                "name": "Marcus Johnson",
                "status": "available",
                "current_leads_today": 12,
                "expertise": ["healthcare", "manufacturing"],
                "win_rate_ytd": 0.28,
                "avg_deal_size": 72000,
                "timezone": "America/Chicago"
            },
            {
                "id": "rep_003",
                "name": "Emily Rodriguez",
                "status": "in_meeting",
                "available_in_minutes": 25,
                "current_leads_today": 6,
                "expertise": ["saas", "cybersecurity", "fintech"],
                "win_rate_ytd": 0.41,
                "avg_deal_size": 38000,
                "timezone": "America/Los_Angeles"
            }
        ]
    
    def route_lead(self, lead: Dict) -> Dict:
        """Use Codex to determine optimal routing."""
        
        reps = self.get_rep_roster()
        
        routing_prompt = f"""
        You are an expert sales operations analyst. Route this lead to the optimal sales rep.
        
        ## Lead Information
        {json.dumps(lead, indent=2)}
        
        ## Available Reps
        {json.dumps(reps, indent=2)}
        
        ## Routing Rules
        {json.dumps(self.routing_rules, indent=2)}
        
        ## Your Task
        Analyze the lead and select the best rep based on:
        1. Industry/vertical expertise match
        2. Current capacity (leads today vs max)
        3. Historical win rate for similar deals
        4. Availability for fast response
        5. Deal size alignment
        
        If this is a high-value or escalation-trigger lead, note that in your reasoning.
        
        Return JSON:
        {{
            "selected_rep_id": "rep_xxx",
            "selected_rep_name": "Name",
            "confidence_score": 0.0-1.0,
            "reasoning": "Brief explanation",
            "is_escalation": boolean,
            "escalation_reason": "if applicable",
            "recommended_action": "immediate_call|email_sequence|schedule_call",
            "talking_points": ["point 1", "point 2", "point 3"]
        }}
        """
        
        response = self.client.chat.completions.create(
            model="gpt-5.3-codex",  # New Feb 2026 model
            messages=[
                {"role": "system", "content": "You are a sales routing optimization engine."},
                {"role": "user", "content": routing_prompt}
            ],
            response_format={"type": "json_object"}
        )
        
        routing_decision = json.loads(response.choices[0].message.content)
        return routing_decision
    
    def apply_routing(self, lead: Dict, decision: Dict):
        """Execute the routing decision in your CRM."""
        
        # Update lead owner in CRM
        self.update_crm_owner(lead['id'], decision['selected_rep_id'])
        
        # Send notification to rep
        self.notify_rep(
            rep_id=decision['selected_rep_id'],
            lead=lead,
            talking_points=decision['talking_points'],
            action=decision['recommended_action']
        )
        
        # If escalation, also notify manager
        if decision['is_escalation']:
            self.notify_manager(lead, decision)
        
        # Start appropriate sequence
        if decision['recommended_action'] == 'email_sequence':
            self.enroll_in_sequence(lead['id'], 'inbound_nurture')
        
        return {"status": "routed", "decision": decision}

Step 2: Real-Time Webhook Handler​

# webhook_handler.py
from flask import Flask, request, jsonify
from lead_router import CodexLeadRouter

app = Flask(__name__)
router = CodexLeadRouter()

@app.route('/webhook/new-lead', methods=['POST'])
def handle_new_lead():
    """Process incoming leads from any source."""
    
    lead_data = request.json
    
    # Enrich lead data first
    enriched_lead = enrich_lead(lead_data)
    
    # Get AI routing decision
    decision = router.route_lead(enriched_lead)
    
    # Apply the routing
    result = router.apply_routing(enriched_lead, decision)
    
    # Log for analytics
    log_routing_decision(enriched_lead, decision)
    
    return jsonify({
        "status": "success",
        "assigned_to": decision['selected_rep_name'],
        "response_time_ms": result.get('processing_time_ms')
    })

def enrich_lead(lead: Dict) -> Dict:
    """Add enrichment data from multiple sources."""
    
    enriched = lead.copy()
    
    # Add company data (Clearbit, Apollo, etc.)
    company_data = get_company_enrichment(lead.get('company_domain'))
    enriched['company_size'] = company_data.get('employees')
    enriched['industry'] = company_data.get('industry')
    enriched['technologies'] = company_data.get('tech_stack', [])
    enriched['funding'] = company_data.get('funding_total')
    
    # Add contact data
    contact_data = get_contact_enrichment(lead.get('email'))
    enriched['title'] = contact_data.get('title')
    enriched['seniority'] = contact_data.get('seniority')
    enriched['linkedin_url'] = contact_data.get('linkedin')
    
    # Add intent signals if available
    intent_data = get_intent_signals(lead.get('company_domain'))
    enriched['intent_score'] = intent_data.get('score', 0)
    enriched['intent_topics'] = intent_data.get('topics', [])
    
    return enriched

Step 3: Mid-Turn Steering for Edge Cases​

One of Codex's killer features is mid-turn steering—adjusting the AI's approach while it's working. This is critical for routing edge cases:

def route_with_steering(lead: Dict) -> Dict:
    """Use Codex mid-turn steering for complex routing scenarios."""
    
    client = openai.OpenAI()
    
    # Start the routing conversation
    conversation = client.chat.completions.create(
        model="gpt-5.3-codex",
        messages=[
            {"role": "system", "content": "You are routing a new lead."},
            {"role": "user", "content": f"Route this lead: {json.dumps(lead)}"}
        ]
    )
    
    initial_decision = conversation.choices[0].message.content
    
    # Check if we need to steer
    if "existing_customer" in lead.get('tags', []):
        # Steer toward customer success team
        conversation = client.chat.completions.create(
            model="gpt-5.3-codex",
            messages=[
                {"role": "system", "content": "You are routing a new lead."},
                {"role": "user", "content": f"Route this lead: {json.dumps(lead)}"},
                {"role": "assistant", "content": initial_decision},
                {"role": "user", "content": "Wait—this is an existing customer. Route to their current CSM or account manager instead of new business reps."}
            ]
        )
    
    elif lead.get('estimated_value', 0) > 100000:
        # Steer toward enterprise team
        conversation = client.chat.completions.create(
            model="gpt-5.3-codex",
            messages=[
                {"role": "system", "content": "You are routing a new lead."},
                {"role": "user", "content": f"Route this lead: {json.dumps(lead)}"},
                {"role": "assistant", "content": initial_decision},
                {"role": "user", "content": "This deal is over $100K. Apply enterprise routing rules—senior AE only, immediate manager notification, white-glove treatment."}
            ]
        )
    
    return json.loads(conversation.choices[0].message.content)

Production Considerations​

Speed Optimization​

For sub-second routing:

1. Pre-compute rep availability: Cache rep status, update every 60 seconds
2. Async enrichment: Start enrichment calls in parallel
3. Model selection: Use Codex for complex decisions, rules engine for simple ones
4. Queue management: Handle spikes with a fast queue (Redis/SQS)

# Fast routing with pre-computed context
class FastRouter:
    def __init__(self):
        self.rep_cache = {}
        self.cache_ttl = 60  # seconds
        
    async def route_lead(self, lead: Dict) -> Dict:
        # Get cached rep data (< 1ms)
        reps = self.get_cached_reps()
        
        # Quick rules check first (< 5ms)
        quick_match = self.apply_quick_rules(lead, reps)
        if quick_match:
            return quick_match
        
        # Fall back to Codex for complex decisions (200-500ms)
        return await self.codex_route(lead, reps)
    
    def apply_quick_rules(self, lead: Dict, reps: List) -> Optional[Dict]:
        """Handle obvious cases without AI."""
        
        # Existing customer → their CSM
        if lead.get('is_customer'):
            csm = self.get_assigned_csm(lead['company_id'])
            if csm:
                return {"selected_rep_id": csm['id'], "reasoning": "existing_customer"}
        
        # Named account → account owner
        account_owner = self.get_account_owner(lead.get('company_domain'))
        if account_owner:
            return {"selected_rep_id": account_owner['id'], "reasoning": "named_account"}
        
        # Hot lead + one obvious best rep
        if lead.get('intent_score', 0) > 80:
            best_available = self.get_best_available_rep(reps, lead['industry'])
            if best_available and best_available['current_leads_today'] < 5:
                return {"selected_rep_id": best_available['id'], "reasoning": "hot_lead_best_fit"}
        
        return None  # Needs AI routing

Handling Failures​

def route_with_fallback(lead: Dict) -> Dict:
    """Ensure every lead gets routed, even if AI fails."""
    
    try:
        # Try AI routing
        decision = router.route_lead(lead)
        return decision
        
    except openai.RateLimitError:
        # Fall back to round robin
        return fallback_round_robin(lead)
        
    except openai.APIError:
        # Fall back to rules-based
        return fallback_rules_engine(lead)
        
    except Exception as e:
        # Last resort: assign to manager for manual routing
        log_error(f"Routing failed for lead {lead['id']}: {e}")
        return {
            "selected_rep_id": "manager_001",
            "reasoning": "routing_failure_escalation",
            "is_escalation": True
        }

Measuring Routing Quality​

Track these metrics to optimize your routing:

# routing_analytics.py
def calculate_routing_metrics(period_days: int = 30) -> Dict:
    """Measure routing effectiveness."""
    
    return {
        # Speed metrics
        "avg_time_to_route_ms": 340,
        "avg_time_to_first_contact_min": 4.2,
        "sla_compliance_rate": 0.94,  # % routed within 5 min
        
        # Quality metrics
        "routing_accuracy": 0.87,  # % of leads that stayed with initial assignment
        "rep_satisfaction_score": 4.2,  # Out of 5
        "lead_satisfaction_score": 4.5,  # From post-call surveys
        
        # Outcome metrics
        "conversion_rate_ai_routed": 0.24,
        "conversion_rate_manual_routed": 0.18,
        "avg_deal_size_ai_routed": 48000,
        "avg_cycle_time_ai_routed_days": 32,
        
        # Efficiency metrics
        "leads_per_rep_variance": 2.1,  # Lower = more balanced
        "expertise_match_rate": 0.78,  # % where rep had relevant expertise
    }

Integration with MarketBetter​

If you're using MarketBetter, our Daily SDR Playbook already includes intelligent routing:

• Visitor identification → automatic enrichment → AI routing → rep notification in under 60 seconds
• Intent signals factor into routing priority
• Smart Dialer pre-loads the highest-priority leads for each rep
• No manual assignment needed—the playbook tells each rep exactly who to contact

This is the "WHO + WHAT TO DO" approach that turns signals into action.

Ready to route leads to revenue faster? See how MarketBetter automates the entire SDR workflow →

Your competitor just dropped their prices by 20%. Your sales team finds out... when a prospect tells them on a demo call. By then, three deals have already been lost.

Pricing intelligence shouldn't be reactive. Here's how to build an AI system that monitors competitor pricing changes and alerts your team before you lose deals.

Why Pricing Intelligence Matters for Sales​

Pricing is the most commonly used competitive weapon in B2B:

• 62% of deals involve pricing objections
• 38% of lost deals cite pricing as a factor
• Average competitor changes pricing 2-4 times per year
• Time to detect manual monitoring: 2-8 weeks

The gap between price change and detection is where deals die. Your reps are pitching against outdated competitive intel.

The Pricing Intelligence Architecture​

Here's a system that monitors competitor pricing and alerts your team in real-time:

Component 1: Price Monitoring Agent​

The foundation is automated price scraping with AI interpretation:

Data Sources:

• Public pricing pages
• G2, Capterra, TrustRadius pricing sections
• Web archive history (Wayback Machine)
• Sales intel platforms (ZoomInfo, Clearbit)
• Job postings (sometimes reveal pricing in comp plans)
• Competitor blog posts and press releases

Monitoring Frequency:

• Pricing pages: Daily
• Review sites: Weekly
• Press/blog: Real-time via RSS
• Job postings: Weekly

Component 2: Price Change Detection​

Raw price data is messy. AI helps interpret it:

TASK: Analyze competitor pricing data

PREVIOUS DATA:
[Last known pricing structure]

CURRENT DATA:
[Today's scraped pricing]

DETECT:
1. Direct price changes (increases or decreases)
2. Tier restructuring (new tiers, removed tiers)
3. Feature repackaging (moved between tiers)
4. New add-ons or modules
5. Changed billing models (monthly vs annual)
6. New discount structures
7. Free tier changes

OUTPUT: Structured diff with significance rating (1-10)

Not every change matters equally. A 5% price increase is less urgent than a new free tier that undercuts your entry point.

Component 3: Alert System​

Different changes need different responses:

Tier 1 (Immediate - Slack + Email):

• Price decrease >10%
• New free tier launched
• Aggressive promotion announced
• Major feature moved to lower tier

Tier 2 (Same-day - Email digest):

• Price increase >10%
• Tier restructuring
• New enterprise tier
• Billing model changes

Tier 3 (Weekly digest):

• Minor price adjustments (<10%)
• Add-on pricing changes
• Regional pricing variations
• Minor feature repackaging

Component 4: Sales Enablement Response​

Detection without action is useless. The system should automatically:

Update Battle Cards: When a competitor changes pricing, their battle card should update within 24 hours:

• New pricing information
• Suggested talk tracks for the change
• Counter-positioning recommendations

Alert Active Deals: If a competitor in an active deal changes pricing:

• Alert the deal owner immediately
• Provide talking points for the next conversation
• Suggest proactive outreach if deal is at risk

Adjust Discount Authority: If competitors drop prices significantly:

• Temporarily expand rep discount authority
• Pre-approve promotional offers
• Create time-limited competitive response

Implementation: Three Approaches​

Approach 1: Manual + AI Analysis (Quick Start)​

If you're not ready for full automation:

1. Set Google Alerts for competitor pricing news
2. Assign someone to check pricing pages weekly
3. Use Claude/Codex to analyze and structure findings
4. Manually update battle cards and alert reps

Time investment: 2-4 hours/week Coverage: Moderate

Approach 2: OpenClaw Automation (DIY)​

Build a fully automated system with OpenClaw:

# pricing-intel-agent.yaml
agents:
  pricing-monitor:
    model: claude-sonnet-4-20250514
    schedule:
      - cron: "0 6 * * *"  # Daily at 6 AM
    
    tools:
      - web_fetch
      - browser  # For JavaScript-rendered pages
      - web_search
    
    context:
      - path: /context/competitors.md
      - path: /context/pricing-history.md
      - path: /context/alert-rules.md
    
    integrations:
      - slack:
          channels:
            - "#competitive-intel"
            - "#sales-alerts"
      
      - hubspot:
          update_companies: true
          update_deals: true
      
      - google_docs:
          battlecards_folder: "Competitive Intel"

    memory:
      - pricing-history/[competitor].md
      - change-log.md

The agent:

1. Scrapes all competitor pricing pages daily
2. Compares to historical data
3. Detects and categorizes changes
4. Sends appropriate alerts
5. Updates battle cards in Google Docs
6. Logs all changes for trend analysis

Time investment: 8-12 hours setup, 1-2 hours/week maintenance Coverage: High

Approach 3: Dedicated Tool (Turnkey)​

Several tools offer pricing intelligence as a service:

• Klue (competitive intelligence platform)
• Crayon (competitive tracking)
• Kompyte (competitive analysis)

These cost $20K-50K/year but require minimal setup.

What to Track Beyond List Price​

Pricing is more than the number on the page:

Contract Terms:

• Minimum commitment length
• Annual vs monthly pricing gap
• Cancellation policies
• Auto-renewal terms

Discounting Patterns:

• End-of-quarter aggressiveness
• Multi-year discount structures
• Bundle discounts
• Volume pricing breaks

Hidden Costs:

• Implementation fees
• Integration fees
• Support tier pricing
• Overage charges

Total Cost of Ownership:

• Required add-ons for core functionality
• Professional services requirements
• Training costs

Your AI should track all of these, not just the headline price.

Turning Intelligence into Action​

Data without action is just noise. Here's how to operationalize pricing intel:

For Sales Reps​

In CRM: Each competitor record should show:

• Current pricing (last updated date)
• Recent changes (last 90 days)
• Price positioning vs. us
• Common objection + response

In Deal Context: When a competitor is tagged:

• Automatic pricing comparison
• Suggested discount authority
• Win/loss history by price gap

For Product/Pricing Team​

Monthly Report:

• Competitor pricing trends
• Market positioning shifts
• Opportunities for repositioning
• Risk areas

Quarterly Review:

• Full competitive pricing analysis
• Recommendations for pricing changes
• Packaging optimization suggestions

For Marketing​

Battle Card Updates:

• Auto-flag outdated pricing references
• Suggest new positioning based on changes
• Create comparison content for SEO

Real Example: Detecting a Stealth Price Drop​

One of our customers caught a competitor's stealth price drop through this system:

What happened:

• Competitor removed their pricing page
• Started showing "Contact Sales" instead
• Actually dropped prices 30% for deals over $50K

How we detected it:

1. Pricing page change detected immediately
2. G2 reviews mentioned lower prices within 2 weeks
3. LinkedIn posts from their reps hinted at new flexibility
4. Job posting mentioned "competitive pricing" in the comp plan

The response:

• Alerted sales team within 48 hours of detection
• Adjusted discount authority for enterprise deals
• Updated all battle cards
• Created targeted content for enterprise buyers

Result: Retained 3 deals that would have been lost, worth $180K ARR.

Getting Started Today​

You don't need a complex system to start:

Day 1: List your top 5 competitors and their pricing page URLs

Day 2: Set up Google Alerts for "[Competitor] pricing" for each

Week 1: Manually check all pricing pages and document current state

Week 2: Compare to last week, note any changes, alert sales team

Month 1: Evaluate whether to automate with OpenClaw or purchase a tool

The manual process shows you the value. The automation makes it sustainable.

MarketBetter's Approach​

Competitive intelligence is built into our AI SDR platform. When a competitor is tagged on a deal, your reps see current pricing, positioning, and suggested responses—automatically updated as things change.

No separate tool. No manual updates. Just intelligence where reps need it.

Want to see competitive intel that actually helps close deals? Book a demo and we'll show you how it works.

Related reading:

• Competitive Win/Loss Repository with AI
• AI Objection Handling Battle Script Generator
• Automating Competitor Intel with OpenClaw

Your marketing team claims the webinar drove $500K in pipeline. Sales says it was their cold calls. The CEO wants to know where to invest next quarter's budget.

Sound familiar?

Revenue attribution is broken at most B2B companies. You're either flying blind or drowning in conflicting reports from tools that each claim credit for the same deals.

Here's the truth: Traditional attribution models (first-touch, last-touch, even "multi-touch") are built for a world that doesn't exist anymore. B2B buyers touch 20+ channels before talking to sales. They read your blog, see your LinkedIn ads, attend your webinar, get cold emailed, AND get a referral—all for the same deal.

The good news? AI coding agents like OpenAI Codex can build custom attribution systems that actually reflect your business. Not generic SaaS attribution—your attribution model.

Why Traditional Attribution Fails GTM Teams​

Let's be honest about what's wrong with current approaches:

First-Touch Attribution​

Credits the first interaction. Problem: That blog post from 18 months ago gets credit for a deal that actually closed because of a killer demo.

Last-Touch Attribution​

Credits the final interaction before conversion. Problem: Your SDR's call gets all the credit while the content marketing that warmed up the lead gets nothing.

Linear Multi-Touch​

Splits credit equally across all touchpoints. Problem: A random email open counts the same as a 45-minute product demo? That's not how influence works.

Time-Decay Models​

More recent touches get more credit. Problem: What about the case study that sat in their inbox for 3 months before they finally read it and decided to buy?

The real issue: These models were designed for e-commerce, not B2B. When someone buys shoes online, you can track a clean path from ad → click → purchase. When an enterprise company buys your software, there are 5 stakeholders, 6 months of evaluation, and touchpoints across every channel you have.

The AI-First Approach to Revenue Attribution​

Here's what changes when you use Codex to build custom attribution:

1. Pull data from everywhere — CRM, marketing automation, ad platforms, website analytics, call tracking, all unified
2. Build custom models — Weight touchpoints based on YOUR sales cycle, not generic assumptions
3. Automate the analysis — Daily/weekly attribution reports without manual data wrangling
4. Iterate fast — Test different models, see which one best predicts future revenue

Building Revenue Attribution with OpenAI Codex​

Let me walk you through a practical implementation. We'll build a system that:

• Pulls deal data from HubSpot
• Collects touchpoint data from multiple sources
• Applies custom attribution logic
• Outputs actionable reports

Step 1: Set Up Your Environment​

First, install the Codex CLI:

npm install -g @openai/codex

Create a project directory:

mkdir revenue-attribution && cd revenue-attribution
codex init

Step 2: Define Your Data Sources​

Create a configuration file that maps all your touchpoint sources:

// config/sources.js
module.exports = {
  crm: {
    type: 'hubspot',
    apiKey: process.env.HUBSPOT_API_KEY,
    objects: ['deals', 'contacts', 'companies']
  },
  marketing: {
    type: 'hubspot_marketing',
    events: ['email_open', 'email_click', 'form_submission', 'page_view']
  },
  ads: {
    type: 'google_ads',
    conversionActions: ['demo_request', 'trial_signup']
  },
  calls: {
    type: 'gong', // or your call tracking tool
    outcomes: ['meeting_scheduled', 'demo_completed']
  },
  website: {
    type: 'google_analytics',
    events: ['page_view', 'scroll_depth', 'time_on_page']
  }
};

Step 3: Build the Attribution Model​

Here's where Codex shines. You can describe your attribution logic in plain English and have it generate the code:

Prompt to Codex:

Build a revenue attribution model with these rules:
1. Demo attendance = 30% weight (high-intent signal)
2. Content downloads = 15% weight (research phase)
3. Email engagement = 10% weight (nurture)
4. Website visits = 5% weight (awareness)
5. Direct sales touch = 25% weight (relationship)
6. Referral source = 15% weight (trust signal)

Apply time decay: touchpoints in last 30 days get 2x weight.
Handle multi-stakeholder deals by attributing to the primary contact's journey.
Output should show attribution by channel and by campaign.

Codex generates something like:

// models/customAttribution.js
const WEIGHTS = {
  demo_completed: 0.30,
  content_download: 0.15,
  email_engagement: 0.10,
  website_visit: 0.05,
  sales_call: 0.25,
  referral: 0.15
};

const TIME_DECAY_WINDOW = 30; // days
const TIME_DECAY_MULTIPLIER = 2;

function calculateAttribution(deal, touchpoints) {
  const closeDate = new Date(deal.closeDate);
  let totalWeight = 0;
  const attribution = {};

  touchpoints.forEach(touch => {
    const touchDate = new Date(touch.timestamp);
    const daysBeforeClose = (closeDate - touchDate) / (1000 * 60 * 60 * 24);
    
    let weight = WEIGHTS[touch.type] || 0.05;
    
    // Apply time decay bonus
    if (daysBeforeClose <= TIME_DECAY_WINDOW) {
      weight *= TIME_DECAY_MULTIPLIER;
    }
    
    totalWeight += weight;
    
    const channel = touch.channel || 'direct';
    const campaign = touch.campaign || 'none';
    
    if (!attribution[channel]) {
      attribution[channel] = { weight: 0, campaigns: {} };
    }
    attribution[channel].weight += weight;
    
    if (!attribution[channel].campaigns[campaign]) {
      attribution[channel].campaigns[campaign] = 0;
    }
    attribution[channel].campaigns[campaign] += weight;
  });

  // Normalize to percentages
  Object.keys(attribution).forEach(channel => {
    attribution[channel].percentage = 
      (attribution[channel].weight / totalWeight * 100).toFixed(1);
  });

  return {
    dealId: deal.id,
    dealValue: deal.amount,
    attribution
  };
}

module.exports = { calculateAttribution };

Step 4: Automate Data Collection​

Use Codex to write the data pipeline:

// pipelines/collectTouchpoints.js
const HubSpot = require('@hubspot/api-client');

async function collectTouchpointsForDeal(dealId) {
  const hubspot = new HubSpot.Client({ accessToken: process.env.HUBSPOT_TOKEN });
  
  // Get deal and associated contacts
  const deal = await hubspot.crm.deals.basicApi.getById(dealId, [
    'amount', 'closedate', 'dealstage'
  ]);
  
  const associations = await hubspot.crm.deals.associationsApi.getAll(
    dealId, 'contacts'
  );
  
  const touchpoints = [];
  
  for (const assoc of associations.results) {
    // Get contact's marketing timeline
    const timeline = await hubspot.crm.timeline.eventsApi.getEventsByContactId(
      assoc.id
    );
    
    timeline.results.forEach(event => {
      touchpoints.push({
        type: mapEventType(event.eventType),
        timestamp: event.timestamp,
        channel: extractChannel(event),
        campaign: event.properties?.campaign || null,
        contactId: assoc.id
      });
    });
    
    // Get email engagement
    const emails = await getEmailEngagement(assoc.id);
    touchpoints.push(...emails);
    
    // Get call/meeting history
    const calls = await getCallHistory(assoc.id);
    touchpoints.push(...calls);
  }
  
  return touchpoints;
}

Step 5: Generate Attribution Reports​

// reports/weeklyAttribution.js
async function generateWeeklyReport() {
  const closedDeals = await getClosedDealsThisWeek();
  const results = [];
  
  for (const deal of closedDeals) {
    const touchpoints = await collectTouchpointsForDeal(deal.id);
    const attribution = calculateAttribution(deal, touchpoints);
    results.push(attribution);
  }
  
  // Aggregate by channel
  const channelSummary = aggregateByChannel(results);
  
  // Aggregate by campaign
  const campaignSummary = aggregateByCampaign(results);
  
  return {
    period: 'weekly',
    totalRevenue: results.reduce((sum, r) => sum + r.dealValue, 0),
    dealCount: results.length,
    byChannel: channelSummary,
    byCampaign: campaignSummary
  };
}

Real Example: What This Looks Like in Practice​

Here's a sample output from a real attribution run:

Weekly Revenue Attribution Report
=================================
Period: Feb 3-10, 2026
Closed Deals: 8
Total Revenue: $247,000

Attribution by Channel:
-----------------------
Sales Calls/Meetings    34.2%   $84,474
Demo Attendance         28.7%   $70,889
Content Marketing       18.3%   $45,201
Email Nurture           11.4%   $28,158
Paid Ads                 7.4%   $18,278

Top Performing Campaigns:
-------------------------
1. "AI SDR Playbook" ebook     $62,400 influenced
2. January Webinar Series      $48,200 influenced
3. LinkedIn Retargeting        $31,100 influenced
4. Cold Email Sequence A       $28,900 influenced

Now you can answer the CEO's question: "Where should we invest next quarter?"

Advanced: Mid-Turn Steering with GPT-5.3 Codex​

One of the killer features in the new GPT-5.3 Codex release (Feb 5, 2026) is mid-turn steering. This lets you adjust your attribution model while Codex is running the analysis.

Example scenario:

1. You kick off a large attribution run across 6 months of data
2. Halfway through, you realize you forgot to include LinkedIn engagement
3. With mid-turn steering, you can add that data source without restarting

# Start the attribution run
codex run attribution --period="2025-08-01 to 2026-02-01"

# Mid-run, add LinkedIn data
codex steer "Also include LinkedIn company page engagement as a touchpoint with 8% weight"

This is massive for iterating on attribution models. You don't have to guess the perfect model upfront—you can adjust based on what you're seeing.

Why Build vs. Buy?​

You might be thinking: "Why not just use a tool like Bizible, Attribution, or CaliberMind?"

Here's why building makes sense for many GTM teams:

The trade-off is maintenance. But with Codex, you can also automate the maintenance—have it monitor for data quality issues, alert on anomalies, and even suggest model improvements.

Getting Started This Week​

Here's a practical starting point:

Day 1: Export your closed-won deals from the last 90 days with associated contacts Day 2: Use Codex to map all touchpoints for those contacts (email, calls, web visits) Day 3: Define your initial weight model based on what you think matters Day 4: Run attribution and compare to gut feel—adjust weights Day 5: Automate weekly reports to Slack

Within a week, you'll have better attribution than most companies get from $50K/year tools.

The Bigger Picture​

Revenue attribution isn't just about knowing what worked. It's about building a feedback loop that makes your entire GTM motion smarter.

When you know that demo attendance drives 3x the revenue of webinar attendance, you stop running generic webinars and start running webinars designed to book demos.

When you know that a specific cold email sequence influenced 40% of Q1 revenue, you double down on that messaging.

When you know that LinkedIn ads drive awareness but never close deals, you reallocate budget to channels that do.

AI coding agents like Codex make this level of insight accessible to teams that couldn't afford enterprise BI tools or couldn't hire data engineers.

Ready to See What's Actually Driving Your Pipeline?​

MarketBetter helps B2B teams track the signals that matter and turn them into action. Our AI-powered playbook shows your SDRs exactly what to do next—based on the touchpoints that actually correlate with closed deals.

Book a demo →

Related reading:

• Build a 24/7 Pipeline Monitor with OpenClaw
• GPT-5.3 Codex: What Changes for GTM Teams
• RevOps Dashboard with Claude Code

Your competitors' customers are telling you exactly how to beat them. They're leaving 1-star reviews on G2, complaining on Twitter, and posting detailed critiques on Capterra.

But who has time to read 500 reviews?

That's where AI comes in. In this guide, I'll show you how to build an automated review analysis system with Claude that extracts competitive intelligence, tracks sentiment trends, and surfaces sales opportunities—all while you sleep.

Why Reviews Are Competitive Gold​

Reviews contain unfiltered intelligence that you can't get anywhere else:

• Real pain points — What customers actually hate (not what marketing says)
• Feature gaps — What competitors are missing that you could exploit
• Switching triggers — What makes customers leave for alternatives
• Pricing complaints — How customers really feel about value
• Support quality — Where competitors are dropping the ball

A single detailed review can give you a battlecard-worthy insight. Hundreds of reviews? That's a strategic playbook.

The Review Intelligence Stack​

Here's what we're building:

1. Collector — Scrape reviews from G2, Capterra, TrustRadius
2. Analyzer — Claude extracts structured insights
3. Aggregator — Trends and patterns across time
4. Alerter — Notify sales when opportunities surface

Let's build each piece.

Step 1: Collecting Reviews​

First, gather the raw data. G2 and Capterra have APIs, but you can also scrape public review pages:

// review-collector.js
const cheerio = require('cheerio');
const axios = require('axios');

async function collectG2Reviews(productSlug, pages = 5) {
  const reviews = [];
  
  for (let page = 1; page <= pages; page++) {
    const url = `https://www.g2.com/products/${productSlug}/reviews?page=${page}`;
    const { data } = await axios.get(url, {
      headers: { 'User-Agent': 'Mozilla/5.0...' }
    });
    
    const $ = cheerio.load(data);
    
    $('.review-item').each((i, el) => {
      reviews.push({
        rating: $(el).find('.star-rating').attr('data-rating'),
        title: $(el).find('.review-title').text().trim(),
        pros: $(el).find('.pros-content').text().trim(),
        cons: $(el).find('.cons-content').text().trim(),
        date: $(el).find('.review-date').text().trim(),
        industry: $(el).find('.reviewer-industry').text().trim(),
        companySize: $(el).find('.reviewer-company-size').text().trim(),
        role: $(el).find('.reviewer-role').text().trim()
      });
    });
    
    await sleep(2000); // Be respectful
  }
  
  return reviews;
}

Competitors to Track​

For a GTM/sales intelligence company, you'd track:

• Direct competitors: Warmly, Common Room, 6sense, ZoomInfo
• Adjacent tools: Apollo, Outreach, Salesloft
• Emerging players: Unify GTM, Clay, Clearbit

Step 2: Analyzing with Claude​

Here's where it gets interesting. Claude processes each review and extracts structured intelligence:

// review-analyzer.js
const Anthropic = require('@anthropic-ai/sdk');

const claude = new Anthropic();

async function analyzeReview(review, competitor) {
  const response = await claude.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 2048,
    messages: [{
      role: 'user',
      content: `Analyze this ${competitor} review for competitive intelligence:

**Rating:** ${review.rating}/5
**Title:** ${review.title}
**Pros:** ${review.pros}
**Cons:** ${review.cons}
**Reviewer:** ${review.role} at ${review.companySize} company in ${review.industry}

Extract and return as JSON:
{
  "sentiment": "positive|negative|mixed",
  "pain_points": ["specific issues mentioned"],
  "praised_features": ["what they like"],
  "missing_features": ["what they wish existed"],
  "pricing_feedback": "any pricing comments",
  "support_feedback": "any support comments",
  "switching_signals": ["any hints they might switch"],
  "competitor_mentions": ["other products mentioned"],
  "use_case": "how they use the product",
  "sales_opportunity": {
    "is_opportunity": true/false,
    "reason": "why this could be a sales opportunity",
    "battlecard_insight": "insight for sales team"
  }
}`
    }]
  });
  
  return JSON.parse(response.content[0].text);
}

Batch Processing​

Process reviews efficiently with batching:

async function analyzeAllReviews(reviews, competitor) {
  const results = [];
  
  // Process in batches of 10
  for (let i = 0; i < reviews.length; i += 10) {
    const batch = reviews.slice(i, i + 10);
    
    const batchResults = await Promise.all(
      batch.map(review => analyzeReview(review, competitor))
    );
    
    results.push(...batchResults);
    
    console.log(`Processed ${Math.min(i + 10, reviews.length)}/${reviews.length}`);
    await sleep(1000); // Rate limiting
  }
  
  return results;
}

Step 3: Aggregating Insights​

Individual reviews are useful. Patterns across hundreds are powerful:

async function generateCompetitiveReport(analyzedReviews, competitor) {
  const response = await claude.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 4096,
    system: `You are a competitive intelligence analyst. 
Generate actionable insights for a sales team.
Be specific and quote reviews when relevant.`,
    
    messages: [{
      role: 'user',
      content: `Analyze these ${analyzedReviews.length} ${competitor} reviews and generate a competitive intelligence report:

${JSON.stringify(analyzedReviews, null, 2)}

Generate:

## Executive Summary
Key findings in 3 bullets

## Top Pain Points (ranked by frequency)
What customers complain about most

## Feature Gaps
What's missing that we could highlight

## Pricing Perception
How customers feel about value/price

## Support Quality
Strengths and weaknesses of their support

## Switching Triggers
What makes customers leave

## Sales Battlecard Updates
Specific talking points for our sales team

## Recommended Actions
What we should do with this intelligence`
    }]
  });
  
  return response.content[0].text;
}

Step 4: Alerting on Opportunities​

Set up real-time alerts when high-value signals appear:

async function checkForOpportunities(newReviews) {
  const opportunities = newReviews.filter(r => 
    r.analysis.sales_opportunity.is_opportunity
  );
  
  for (const opp of opportunities) {
    // Check if reviewer's company is in our target market
    const company = await enrichCompany(opp.review.companyName);
    
    if (matchesICP(company)) {
      await slack.postMessage({
        channel: '#sales-opportunities',
        text: `🎯 *Potential Opportunity Detected*`,
        blocks: [
          {
            type: 'section',
            text: {
              type: 'mrkdwn',
              text: `*${company.name}* left a ${opp.review.rating}-star review of *${opp.competitor}*

*Signal:* ${opp.analysis.sales_opportunity.reason}

*Key Pain Points:*
${opp.analysis.pain_points.map(p => `• ${p}`).join('\n')}

*Battlecard Insight:*
> ${opp.analysis.sales_opportunity.battlecard_insight}`
            }
          },
          {
            type: 'actions',
            elements: [
              { type: 'button', text: { type: 'plain_text', text: 'Add to Outreach' }, action_id: 'add_prospect' },
              { type: 'button', text: { type: 'plain_text', text: 'View Full Review' }, url: opp.review.url }
            ]
          }
        ]
      });
    }
  }
}

What Intelligence Looks Like​

Here's a real example of what Claude extracts from a 2-star Warmly review:

Input Review:

"We tried Warmly for visitor identification but the data quality wasn't there. Out of 100 identified companies, maybe 20 were accurate. Also, $35K/year for what amounts to a widget is insane. Looking at alternatives now."

Claude's Analysis:

{
  "sentiment": "negative",
  "pain_points": [
    "Data quality issues - only 20% accuracy on company identification",
    "High price point ($35K/year) not justified by value"
  ],
  "switching_signals": [
    "Actively looking at alternatives",
    "Price-to-value mismatch frustration"
  ],
  "sales_opportunity": {
    "is_opportunity": true,
    "reason": "Actively evaluating alternatives, frustrated with price and accuracy",
    "battlecard_insight": "Lead with data quality comparisons and ROI calculator showing value at our price point"
  }
}

That's a warm lead and a battlecard insight in one.

Tracking Trends Over Time​

Monthly trend analysis reveals strategic shifts:

async function monthlyTrendAnalysis(competitor) {
  const lastMonth = await getReviewsByPeriod(competitor, 'last-30-days');
  const previousMonth = await getReviewsByPeriod(competitor, '30-60-days-ago');
  
  const analysis = await claude.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 2048,
    messages: [{
      role: 'user',
      content: `Compare ${competitor}'s reviews from the last 30 days vs the previous 30 days:

LAST 30 DAYS (${lastMonth.length} reviews):
Average rating: ${calculateAverage(lastMonth, 'rating')}
Top complaints: ${aggregateComplaints(lastMonth)}

PREVIOUS 30 DAYS (${previousMonth.length} reviews):
Average rating: ${calculateAverage(previousMonth, 'rating')}
Top complaints: ${aggregateComplaints(previousMonth)}

Identify:
1. Sentiment trend (improving/declining/stable)
2. New complaints emerging
3. Resolved issues (complaints disappearing)
4. Any correlation with product releases or news`
    }]
  });
  
  return analysis.content[0].text;
}

Integration with Sales Workflows​

HubSpot: Auto-Update Battlecards​

// When new insights found, update company records
async function updateBattlecards(insights) {
  for (const insight of insights.battlecard_updates) {
    await hubspot.crm.objects.notes.create({
      associations: [{
        to: { id: insight.competitorCompanyId },
        types: [{ associationCategory: 'HUBSPOT_DEFINED', associationTypeId: 202 }]
      }],
      properties: {
        hs_note_body: `📊 **Competitive Intel Update**\n\n${insight.update}\n\n_Source: G2 Review Analysis_`,
        hs_timestamp: Date.now()
      }
    });
  }
}

OpenClaw: Automated Monitoring​

Set up 24/7 monitoring with OpenClaw:

# In your OpenClaw agent config
agents:
  competitive-intel:
    schedule: "0 6 * * *"  # Daily at 6am
    task: |
      Check for new competitor reviews on G2 and Capterra.
      Analyze any with rating <= 3 stars.
      Alert #sales-intel channel with opportunities.
      Update battlecard docs in Notion.

Privacy and Ethics​

Important considerations:

1. Public reviews only — Only analyze publicly posted reviews
2. Don't scrape aggressively — Respect rate limits and robots.txt
3. No reviewer doxxing — Don't try to identify individual reviewers for outreach
4. Aggregate, don't stalk — Use for strategic insights, not individual targeting

ROI of Review Intelligence​

That's 52 hours/month saved on competitive intelligence alone.

Getting Started​

1. Pick 3-5 competitors to monitor
2. Set up collection for G2 (easiest API access)
3. Run initial analysis on last 6 months of reviews
4. Generate baseline report to share with sales
5. Automate weekly updates going forward

Related Resources​

• Automating Competitor Intelligence with AI Agents
• Competitive Battlecards with Claude
• Claude 200K Context for Sales Workflows

Turn Competitor Weaknesses Into Your Wins​

MarketBetter helps GTM teams work smarter with AI-powered competitive intelligence. Know what to say, when to say it, and who to target—all automatically.

Book a Demo →

See how teams are using AI to outsmart the competition.

RFPs are the bane of every sales team's existence. You get a 50-page document, 200 questions, and a deadline that's always "last week." Your best reps spend days copy-pasting from old proposals while new deals pile up.

What if you could cut RFP response time from 40 hours to 4?

That's exactly what AI coding agents like OpenAI Codex make possible. In this guide, I'll show you how to build an automated RFP response system that drafts 80% of your answers automatically—letting your team focus on customization rather than repetitive typing.

The Problem: RFPs Are a Time Black Hole​

Here's the ugly truth about RFPs:

• Average time to complete: 20-40 hours per response
• Win rate: 5-25% (meaning 75%+ of that effort is wasted)
• Repetition: 60-70% of questions are repeated across RFPs
• Cost: $3,000-$10,000 in labor per response

Your best salespeople—the ones who should be closing deals—are stuck copying answers from old Word docs. It's insane.

How AI Changes the Game​

OpenAI's Codex (powered by GPT-5.3, released February 5, 2026) is the most capable agentic coding model ever built. Combined with its mid-turn steering capability, you can build RFP automation that:

1. Parses RFP documents automatically (PDFs, Word docs, spreadsheets)
2. Matches questions to your answer library using semantic search
3. Drafts responses that match your company's voice and style
4. Flags gaps where human input is needed
5. Formats output to match required submission formats

The key insight: You don't need 100% automation. You need to eliminate the 70% that's copy-paste.

Building Your AI RFP System​

Step 1: Create Your Answer Library​

Your answer library is the foundation. This is where Codex pulls responses from.

Structure it like this:

rfp-library/
├── security/
│   ├── soc2-compliance.md
│   ├── data-encryption.md
│   └── access-controls.md
├── technical/
│   ├── api-capabilities.md
│   ├── integrations.md
│   └── uptime-sla.md
├── company/
│   ├── about-us.md
│   ├── customer-references.md
│   └── team-bios.md
└── pricing/
    ├── pricing-models.md
    └── enterprise-terms.md

Each file contains pre-approved answers with metadata:

# SOC 2 Compliance

**Category:** Security
**Last Updated:** 2026-01-15
**Approved By:** Legal Team

## Standard Response

MarketBetter maintains SOC 2 Type II certification, audited annually by [Auditor Name]. Our most recent audit was completed in December 2025 with zero findings.

## Short Response (for checkboxes)

Yes - SOC 2 Type II certified, audited annually.

## Long Response (for detailed sections)

[Extended response with specifics...]

Step 2: Set Up Codex for RFP Processing​

Install the Codex CLI:

npm install -g @openai/codex

Create a Codex agent specifically for RFP work:

// rfp-agent.js
const { Codex } = require('@openai/codex');

const rfpAgent = new Codex({
  model: 'gpt-5.3-codex',
  tools: ['file_read', 'file_write', 'search'],
  context: `You are an expert RFP response writer. Your job is to:
  1. Parse RFP questions accurately
  2. Find matching answers in the library
  3. Draft responses that are professional and specific
  4. Flag questions that need human review
  
  Always maintain the company's professional tone.
  Never make up technical claims—flag for review if unsure.`
});

Step 3: Parse and Match Questions​

The magic happens in semantic matching. Codex doesn't just keyword-match—it understands intent:

async function processRFP(rfpDocument) {
  // Extract questions from RFP
  const questions = await rfpAgent.run(`
    Parse this RFP document and extract all questions.
    Return as JSON array with:
    - question_id
    - question_text
    - category (security/technical/company/pricing/other)
    - complexity (simple/moderate/complex)
    
    Document: ${rfpDocument}
  `);
  
  // Match each question to library
  for (const q of questions) {
    const match = await rfpAgent.run(`
      Find the best matching answer in our library for:
      "${q.question_text}"
      
      Return:
      - matched_file
      - confidence (0-100)
      - suggested_response
      - needs_review (boolean)
    `);
    
    q.match = match;
  }
  
  return questions;
}