AI SDR: Infrastructure vs UI Wrappers

Every AI SDR demo on LinkedIn is a UI wrapper with Chrome extensions scraping LinkedIn profiles. Real agent-native outbound requires API infrastructure: programmatic search for prospect research, structured data for enrichment, and MCP for agent tool access. The difference between a demo and production AI outbound is the data layer underneath.

The UI wrapper pattern

The typical AI SDR product works like this: a Chrome extension scrapes LinkedIn profiles, pipes the data to an LLM to generate a personalized email, and sends it through a connected email account. The demo looks impressive because the email references specific details from the prospect profile.

The problems surface at scale:

• Chrome extensions break when LinkedIn changes their DOM, which happens regularly
• LinkedIn detects automated scraping and restricts accounts. Users report profile restrictions after 200-500 automated profile views
• The personalization is shallow: it references job title and company name but has no awareness of the prospect company recent news, competitive landscape, or pain points
• No enrichment beyond what LinkedIn profiles show. Missing: company size growth, funding rounds, technology stack, hiring patterns

What agent-native outbound actually requires

A Reddit post in r/coldemail referenced Nexuscale thesis on AI outbound infrastructure. The core argument: AI SDRs that work in production need three infrastructure layers that UI wrappers skip.

• Programmatic search for prospect research: search APIs that pull company data, news, job postings, and competitive intelligence without scraping individual websites
• Structured data enrichment: turning raw search results into structured prospect profiles with verified data points
• Agent tool access via MCP or function calling: allowing the AI agent to autonomously decide what data it needs and fetch it in real time during the personalization step

Building the research layer

import requests, os, json

def research_prospect(company_name, contact_role):
    """Deep prospect research using search data."""
    api_key = os.environ["SCAVIO_API_KEY"]
    headers = {"x-api-key": api_key}

    # Layer 1: Company intelligence
    company_data = requests.post(
        "https://api.scavio.dev/api/v1/search",
        headers=headers,
        json={"query": f"{company_name} company news 2026", "num_results": 5}
    ).json()

    # Layer 2: Pain point detection
    pain_points = requests.post(
        "https://api.scavio.dev/api/v1/search",
        headers=headers,
        json={
            "query": f"{company_name} challenges problems",
            "platform": "reddit",
            "num_results": 5
        }
    ).json()

    # Layer 3: Competitive landscape
    competitors = requests.post(
        "https://api.scavio.dev/api/v1/search",
        headers=headers,
        json={
            "query": f"{company_name} vs competitors alternatives",
            "num_results": 5
        }
    ).json()

    return {
        "company": company_name,
        "recent_news": [
            r.get("snippet", "") for r in
            company_data.get("organic_results", [])
        ],
        "pain_signals": [
            r.get("snippet", "") for r in
            pain_points.get("organic_results", [])
        ],
        "competitive_context": [
            r.get("snippet", "") for r in
            competitors.get("organic_results", [])
        ]
    }

# Research a prospect
prospect = research_prospect("Acme Corp", "VP Engineering")
print(json.dumps(prospect, indent=2))

The enrichment pipeline

Raw search data needs to be structured before an LLM can use it for personalization. The enrichment step extracts specific data points from search results and organizes them into a prospect profile the LLM can reference.

def enrich_for_outbound(prospect_data):
    """Structure search data for LLM personalization."""
    profile = {
        "company_signals": [],
        "personalization_hooks": [],
        "pain_points": [],
        "timing_signals": []
    }

    for news in prospect_data.get("recent_news", []):
        news_lower = news.lower()
        if any(kw in news_lower for kw in ["funding", "raised", "series"]):
            profile["timing_signals"].append(f"Recent funding: {news}")
        elif any(kw in news_lower for kw in ["hiring", "open role", "job"]):
            profile["timing_signals"].append(f"Hiring signal: {news}")
        elif any(kw in news_lower for kw in ["launch", "release", "announce"]):
            profile["company_signals"].append(f"Product launch: {news}")

    for pain in prospect_data.get("pain_signals", []):
        if len(pain) > 20:
            profile["pain_points"].append(pain)

    return profile

MCP for autonomous agent research

The most advanced pattern gives the AI agent direct access to search tools via MCP. Instead of pre-defining what data to fetch for each prospect, the agent decides what it needs based on the outreach context.

{
  "mcpServers": {
    "search": {
      "command": "npx",
      "args": ["-y", "scavio-search-mcp"],
      "env": {
        "SCAVIO_API_KEY": "your-key-here"
      }
    }
  }
}

With MCP, the agent can search for company news, check Reddit for user complaints about the prospect company product, look up competitor pricing, and find relevant case studies. All without pre-programming the research workflow. The agent adapts its research based on what it finds.

Cost comparison: wrapper vs infrastructure

A typical AI SDR wrapper charges $200-500/month for 1,000 prospects. Building on infrastructure costs roughly: $30/month for 7,000 search credits (7 searches per prospect for 1,000 prospects), plus your LLM costs for personalization ($10-30/month at current pricing). Total: $40-60/month for the same volume with deeper personalization.

The tradeoff is build versus buy. Wrappers are faster to start. Infrastructure gives you control, customization, and significantly lower per-prospect costs. For teams doing outbound at scale (5,000+ prospects/month), the infrastructure approach pays for itself within the first month.

What separates demos from production

A production AI SDR needs: reliable data sources that do not break when a website changes its layout, enrichment that goes beyond LinkedIn profile fields, research depth that produces genuinely personalized outreach, and costs that scale linearly. Every component except the LLM itself depends on the data infrastructure. That is why the infrastructure layer matters more than the AI wrapper on top.