Multi-Agent Outbound System: The 3-Agent Stack We Use to Book 40+ Demos/Month

Here’s a number that should make you uncomfortable: the average SDR costs $75,000/year fully loaded, sends 50 emails per day, and books maybe 8-12 meetings per month.

That’s roughly $500+ per booked meeting, not counting management overhead, tools, and the 3-month ramp time before they’re productive.

We decided there had to be a better way.

Over the past 18 months, we’ve built and refined a multi-agent outbound system that books 40+ qualified demos per month. Not through spam. Not through “spray and pray.” Through intelligent, personalized outreach that actually sounds human.

This is the exact system we use, broken down into components you can replicate.

Why Multi-Agent? The Limits of Single-Agent Automation

Before we dive in, let’s address the obvious question: why multiple agents instead of one AI doing everything?

Single-agent systems have a fundamental problem: they try to be generalists. One AI researches the prospect, writes the email, decides when to follow up, and handles responses. The result is mediocre at everything.

Multi-agent systems work like a specialized team:

• Each agent does one thing exceptionally well
• Agents pass context to each other (like humans briefing teammates)
• The system is modular (upgrade one agent without breaking others)
• Failure is isolated (if research fails, personalization still works with cached data)

Think of it like a sales team:

• SDR Manager doesn’t write emails - they coordinate
• Research Analyst doesn’t send emails - they gather intel
• Copywriter doesn’t research - they craft messages
• SDR doesn’t research or write - they execute and respond

Our multi-agent system mirrors this structure, but runs 24/7 at a fraction of the cost.

The 3-Agent Stack: Architecture Overview

Our outbound system consists of three specialized agents:

┌─────────────────────────────────────────────────────────────┐
│                    ORCHESTRATOR (N8N)                       │
│         Coordinates agents, manages queue, handles errors   │
└─────────────────────────────────────────────────────────────┘
                              │
          ┌───────────────────┼───────────────────┐
          ▼                   ▼                   ▼
┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐
│  RESEARCH       │  │  PERSONALIZATION│  │  FOLLOW-UP      │
│  AGENT          │  │  AGENT          │  │  AGENT          │
│                 │  │                 │  │                 │
│ • Company data  │  │ • Email copy    │  │ • Sequence      │
│ • Contact info  │  │ • Subject lines │  │   management    │
│ • Intent signals│  │ • Value props   │  │ • Response      │
│ • Tech stack    │  │ • Pain points   │  │   detection     │
│ • Recent news   │  │ • CTAs          │  │ • Re-engagement │
└─────────────────┘  └─────────────────┘  └─────────────────┘
          │                   │                   │
          └───────────────────┼───────────────────┘
                              ▼
                    ┌─────────────────┐
                    │   PROSPECT DB   │
                    │   (Airtable/    │
                    │    Supabase)    │
                    └─────────────────┘

Let’s break down each agent.

Agent 1: The Research Agent

Purpose: Gather everything knowable about a prospect before any outreach.

The Problem It Solves: SDRs spend 30-40% of their time on research. Most skip it to hit activity metrics, sending generic emails that get ignored. The Research Agent eliminates this tradeoff.

What It Collects

Company Intelligence:

• Company description and value proposition
• Industry and sub-vertical
• Company size (employees, revenue estimates)
• Funding stage and recent raises
• Tech stack (from job postings, BuiltWith, Wappalyzer)
• Recent news and press releases
• Job openings (signals growth areas and pain points)

Contact Intelligence:

• Role and seniority
• Time in role
• LinkedIn activity and posts
• Shared connections
• Previous companies
• Content they’ve published

Intent Signals:

• Recent website visits (if you have visitor identification)
• Content downloads
• Job postings related to your solution
• Competitor mentions
• Tech stack changes

How It Works

# Simplified Research Agent Flow

def research_prospect(prospect_id):
    # 1. Get basic info from prospect database
    prospect = db.get_prospect(prospect_id)
    
    # 2. Enrich company data
    company_data = enrichment_api.get_company(prospect.domain)
    
    # 3. Get LinkedIn profile data
    linkedin_data = linkedin_api.get_profile(prospect.linkedin_url)
    
    # 4. Check for recent news
    news = news_api.search(prospect.company_name, days=30)
    
    # 5. Analyze tech stack
    tech_stack = builtwith_api.get_stack(prospect.domain)
    
    # 6. Check job postings for pain signals
    jobs = job_api.search(prospect.company_name)
    pain_signals = analyze_job_postings(jobs)
    
    # 7. Compile research brief
    research_brief = compile_brief(
        company=company_data,
        contact=linkedin_data,
        news=news,
        tech=tech_stack,
        signals=pain_signals
    )
    
    # 8. Save to database and pass to Personalization Agent
    db.save_research(prospect_id, research_brief)
    trigger_personalization_agent(prospect_id)

Tools We Use

Purpose	Tool	Why
Company enrichment	Clay, Clearbit	Comprehensive data
LinkedIn data	Phantombuster, Proxycurl	Profile scraping
Tech stack	BuiltWith, Wappalyzer	Technology signals
News monitoring	Google Alerts API, NewsAPI	Recent triggers
Job postings	LinkedIn Jobs API	Pain point signals

Output: The Research Brief

The Research Agent produces a structured brief that feeds the Personalization Agent:

{
  "prospect_id": "abc123",
  "company": {
    "name": "Acme Corp",
    "description": "B2B SaaS for inventory management",
    "industry": "Supply Chain Tech",
    "size": "50-100 employees",
    "funding": "Series A ($12M)",
    "tech_stack": ["Salesforce", "HubSpot", "AWS"]
  },
  "contact": {
    "name": "Sarah Chen",
    "title": "VP of Sales",
    "time_in_role": "8 months",
    "linkedin_posts": ["Recently posted about scaling SDR team"],
    "previous_company": "Gong"
  },
  "signals": {
    "hiring": ["3 SDR roles open", "Sales Manager role"],
    "news": ["Announced new enterprise tier last month"],
    "pain_indicators": ["scaling sales team", "outbound efficiency"]
  },
  "personalization_hooks": [
    "New VP Sales likely reviewing sales stack",
    "Hiring SDRs = outbound is priority",
    "Gong background = values data-driven sales"
  ]
}

Agent 2: The Personalization Agent

Purpose: Transform research into compelling, personalized email copy.

The Problem It Solves: Generic templates get 1-2% reply rates. Truly personalized emails get 15-25%. But manual personalization doesn’t scale. The Personalization Agent writes emails that feel hand-crafted, at machine scale.

The Personalization Framework

We don’t just “use AI to write emails.” We’ve developed a framework that consistently produces high-converting copy:

The P.A.I.N. Framework:

• Personalization hook (specific to them)
• Acknowledge their situation (show understanding)
• Introduce relevance (why you, why now)
• Next step (clear, low-friction CTA)

How It Works

# Simplified Personalization Agent Flow

def generate_email(prospect_id):
    # 1. Get research brief from Research Agent
    research = db.get_research(prospect_id)
    
    # 2. Select best personalization angle
    angle = select_personalization_angle(research)
    # Options: recent_news, job_change, hiring_signal, 
    #          content_they_posted, mutual_connection
    
    # 3. Select email template based on angle
    template = get_template(angle, research.contact.seniority)
    
    # 4. Generate personalized copy using LLM
    email = llm.generate(
        system_prompt=PERSONALIZATION_SYSTEM_PROMPT,
        user_prompt=f"""
        Research Brief: {research}
        Personalization Angle: {angle}
        Template Structure: {template}
        
        Write a personalized cold email following the P.A.I.N. framework.
        Keep it under 100 words. No fluff. Sound human, not salesy.
        """
    )
    
    # 5. Generate subject line variants
    subjects = llm.generate_subjects(research, email, count=3)
    
    # 6. Quality check
    if not passes_quality_check(email):
        return generate_email(prospect_id)  # Retry
    
    # 7. Save and queue for sending
    db.save_email_draft(prospect_id, email, subjects)
    queue_for_sending(prospect_id)

The System Prompt (Our Secret Sauce)

The quality of AI-generated emails depends heavily on the system prompt. Here’s a simplified version of ours:

You are an expert B2B sales copywriter. You write cold emails that:

1. NEVER start with "I hope this email finds you well" or any variation
2. NEVER use phrases like "I noticed" or "I came across" 
3. NEVER ask "Is this a priority for you?"
4. ALWAYS lead with something specific about THEM
5. ALWAYS keep emails under 100 words
6. ALWAYS have ONE clear call-to-action
7. Sound like a helpful peer, not a salesperson

Your emails follow the P.A.I.N. framework:
- Personalization: Reference something specific (recent post, news, job change)
- Acknowledge: Show you understand their likely situation
- Introduce: Briefly explain relevance without pitching features
- Next step: One clear, low-friction ask

Write in short paragraphs. Use line breaks. Be direct.

Output Examples

Input Research Brief:

Contact: Sarah Chen, VP Sales at Acme Corp
Signal: Just posted about "scaling outbound without burning out the team"
Company: Series A, hiring 3 SDRs

Generated Email:

Subject: re: scaling outbound

Sarah,

Your post about scaling outbound without burnout hit home. 
It's the exact problem we see with Series A teams trying to 
10x pipeline with the same headcount.

We've helped 3 companies at your stage build systems that 
book 40+ demos/month without adding SDRs. Happy to share 
what worked if useful.

Worth a 15-min call?

[Name]

Why It Works:

• References her actual LinkedIn post
• Acknowledges the specific challenge
• Social proof (3 companies at your stage)
• Clear, low-friction CTA

Agent 3: The Follow-Up Agent

Purpose: Manage multi-touch sequences, detect responses, and know when to stop.

The Problem It Solves: 80% of deals require 5+ touchpoints, but most SDRs give up after 2. The Follow-Up Agent maintains persistence without being annoying, and intelligently adapts based on engagement signals.

The Follow-Up Logic

Day 0:  Initial email
Day 3:  Follow-up #1 (if no open) - different subject line
Day 3:  Follow-up #1 (if opened, no reply) - "bump" email
Day 7:  Follow-up #2 - new angle/value prop
Day 14: Follow-up #3 - social proof or case study
Day 21: Break-up email - last touch

If replied (positive): Route to human for conversation
If replied (not interested): Mark as closed, add to nurture
If bounced: Remove and flag for data cleaning
If opened 3+ times: Priority flag for human review

How It Works

# Simplified Follow-Up Agent Flow

def manage_followups():
    # Run every hour
    prospects = db.get_prospects_needing_followup()
    
    for prospect in prospects:
        # 1. Check for responses
        response = check_for_response(prospect)
        if response:
            handle_response(prospect, response)
            continue
        
        # 2. Check engagement signals
        engagement = get_engagement(prospect)
        # Opens, clicks, LinkedIn profile views
        
        # 3. Determine next action
        sequence_stage = prospect.sequence_stage
        days_since_last = get_days_since_last_touch(prospect)
        
        if should_send_followup(sequence_stage, days_since_last, engagement):
            # 4. Generate appropriate follow-up
            followup = generate_followup(
                prospect=prospect,
                stage=sequence_stage,
                engagement=engagement
            )
            
            # 5. Queue for sending
            queue_email(prospect, followup)
            
        elif should_end_sequence(sequence_stage, engagement):
            # 6. Send break-up email
            send_breakup(prospect)
            mark_sequence_complete(prospect)

Follow-Up Templates by Stage

Follow-Up #1 (Day 3) - The Bump:

Subject: re: {original_subject}

Sarah, floating this up in case it got buried.

[Original email]

Follow-Up #2 (Day 7) - New Angle:

Subject: quick thought on {pain_point}

Sarah,

One thing I forgot to mention - we just helped {similar_company} 
cut their CAC by 40% using a similar approach.

Might be relevant given your SDR hiring push. Happy to share details.

15 mins this week?

Follow-Up #3 (Day 14) - Case Study:

Subject: how {similar_company} did it

Sarah,

Thought you'd find this interesting - {similar_company} went from 
10 to 45 demos/month in 60 days using the system I mentioned.

Here's the quick breakdown: [link to case study]

Worth discussing if you're still solving for outbound scale.

Break-Up (Day 21):

Subject: closing the loop

Sarah,

Haven't heard back, so I'll assume the timing isn't right.

No worries at all - I'll close this thread. If outbound efficiency 
becomes a priority later, happy to reconnect.

Thanks for your time.

Response Detection & Routing

The Follow-Up Agent doesn’t just send emails - it intelligently handles responses:

Positive Response Detection:

• “Yes, let’s chat”
• “Send me more info”
• “How does Tuesday look?” → Action: Pause sequence, alert human, route to calendar booking

Negative Response Detection:

• “Not interested”
• “Remove me from your list”
• “We already have a solution” → Action: End sequence, add to “not interested” list, never contact again

Objection Detection:

• “What’s the pricing?”
• “How is this different from X?”
• “We’re not ready yet” → Action: Generate appropriate response, flag for human review

The Orchestrator: Bringing It Together

The three agents don’t work in isolation - they’re coordinated by an orchestrator (we use N8N, but you could use Make, Zapier, or custom code).

The Daily Workflow

6:00 AM - Research Agent
├── Pull new prospects from TAM list
├── Run enrichment on each
├── Generate research briefs
└── Queue for Personalization

8:00 AM - Personalization Agent
├── Pull prospects with completed research
├── Generate personalized emails
├── Generate subject line variants
└── Queue for sending

9:00 AM - 5:00 PM - Email Sending
├── Send emails in batches (avoid spam filters)
├── Randomize send times
└── Track opens and clicks

Every Hour - Follow-Up Agent
├── Check for responses
├── Process engagement signals
├── Send scheduled follow-ups
└── Route positive responses to humans

6:00 PM - Reporting
├── Daily metrics compilation
├── A/B test analysis
└── Slack notification with results

Error Handling

Multi-agent systems need robust error handling:

If Research Agent fails:
→ Use cached/basic data
→ Still personalize on available info
→ Flag for manual enrichment later

If Personalization Agent fails:
→ Fall back to high-performing template
→ Add basic personalization (name, company)
→ Log for review

If Follow-Up Agent fails:
→ Pause sequence for that prospect
→ Alert team
→ Resume when fixed

Results: The Numbers

After 18 months of iteration, here’s what our multi-agent system delivers:

Metric	Before (Manual SDR)	After (Multi-Agent)
Emails sent/day	50	200
Reply rate	2-3%	12-15%
Positive reply rate	0.5%	4-5%
Demos booked/month	8-12	40-50
Cost per demo	$400-500	$50-80
Time to first touch	2-3 days	Same day

ROI Calculation:

• Previous: 1 SDR ($75K) booking 10 demos/month = $625/demo
• Current: Multi-agent system (~$2K/month in tools) booking 45 demos/month = $44/demo
• 14x cost reduction

Building Your Own: Getting Started

You don’t need to build everything at once. Here’s the phased approach:

Phase 1: Research Agent (Week 1-2)

Start simple:

1. Set up Clay or similar for enrichment
2. Create a prospect database (Airtable or Notion)
3. Build basic N8N workflow: New prospect → Enrich → Save

MVP Output: Automated company + contact enrichment

Phase 2: Personalization Agent (Week 3-4)

Build on Phase 1:

1. Create email templates for 3-4 scenarios
2. Add OpenAI/Claude API for copy generation
3. Build quality checking (word count, spam words)

MVP Output: Auto-generated first emails

Phase 3: Follow-Up Agent (Week 5-6)

Complete the loop:

1. Build sequence logic (Day 3, 7, 14, 21)
2. Add response detection
3. Create follow-up templates
4. Add break-up logic

MVP Output: Automated multi-touch sequences

Phase 4: Optimization (Ongoing)

Continuous improvement:

1. A/B test subject lines
2. Refine personalization prompts
3. Adjust timing based on data
4. Add new data sources

Common Mistakes to Avoid

Mistake #1: Over-automating responses Let AI handle follow-ups, but route positive responses to humans. Nothing kills a deal faster than an AI fumbling a buying signal.

Mistake #2: Ignoring deliverability Multi-agent systems can send at scale, but that’s useless if emails hit spam. Warm up domains, use multiple sending accounts, and monitor deliverability.

Mistake #3: No quality control AI will occasionally produce garbage. Build quality checks: word count limits, spam word detection, human review for first 100 emails.

Mistake #4: Same message to everyone The whole point is personalization. If your Research Agent isn’t finding differentiated hooks, your Personalization Agent is just generating templates.

Mistake #5: Giving up too early Multi-agent systems take 2-3 months to optimize. The first version will underperform manual SDRs. Keep iterating.

The Future: Where This Goes

Multi-agent outbound is just the beginning. We’re already seeing:

• Voice agents that make cold calls and qualify leads
• LinkedIn agents that engage with prospect content
• Meeting prep agents that brief reps before calls
• Proposal agents that generate custom decks

The companies building these systems now will have insurmountable advantages in 2-3 years.

Key Takeaways

1. Multi-agent beats single-agent. Specialized agents working together outperform generalist AI.

2. Research is the foundation. Bad research = generic emails = low replies. Invest in the Research Agent first.

3. Personalization at scale is possible. The P.A.I.N. framework + good research = emails that feel hand-written.

4. Follow-up is where deals happen. Most give up too early. Automate persistence without being annoying.

5. Start simple, iterate fast. Don’t build the perfect system. Build an MVP and improve weekly.

6. Humans in the loop. Automate the repetitive work, but keep humans for conversations and decisions.

The future of outbound isn’t more SDRs sending more emails. It’s smarter systems sending better emails to the right people at the right time.

Your move: Which agent will you build first?

---

Want help building a multi-agent outbound system for your team? Book a free strategy call with our team to discuss your sales automation needs.