We Run Our Own Outbound on an AI Agent Swarm. Here's What It Actually Did.

Most companies selling you AI can't show you their own AI working.

We can. Every weekday morning, before anyone on our team opens a laptop, a swarm of autonomous agents goes to work finding companies that look like our best customers, figuring out who to talk to, writing the emails, sending them, and handling the replies. It's the same architecture we build for clients as the AI Growth Engine — except we ran it on ourselves first, and we kept running it long enough to learn what actually moves the numbers.

We've written before about why we built our own swarm before selling one. This is the other half of that story: not why we built it, but what it actually produced. Real numbers — what the swarm did, where it broke, and the ones that didn't match our assumptions.

What the Swarm Actually Is

It's not one big model answering prompts. It's a chain of small, specialized agents, each doing one job and handing off to the next:

• Scout finds companies that match our ideal-customer profile and pulls them into the pipeline.
• Analyst scores and tiers every company — HOT, WARM, or COOL — so effort goes where it's most likely to pay off.
• Enricher does the hard part: finding the right decision-maker and, critically, a verified email address. No verified email, no send.
• Messenger writes the actual outreach in our voice and sends it, but only after a chain of pre-flight safety checks passes.
• Response watches for replies and routes the real conversations to a human.

Coordinating all of it is an Operator that handles errors and recovery, and a learning agent we call the Dreamer that reviews each run and writes down what it learned so the next run is smarter. The agents don't talk to each other directly — they pass signals through a shared database, which means any one of them can fail and restart without taking the whole pipeline down.

To date, the Scout has evaluated just over 12,000 companies. The Analyst has sorted them into roughly 540 HOT, 4,600 WARM, and 6,800 COOL. The Enricher has produced more than 2,200 contacts with verified email addresses — the only contacts the swarm is ever allowed to email. That's the engine. Here's what we learned running it.

Lesson One: Warmth Beats Volume, and the Numbers Aren't Close

The most expensive instinct in outbound is "send more." We had it too. The swarm talked us out of it.

Our standard cold sequence performs about how you'd expect for good cold outreach: across roughly 7,500 sends, it earns a 45% open rate and a 21% click rate. Respectable. Not magic.

Then we pointed the swarm at a different cohort — people who had clicked one of our emails at some point in the past 90 days but never replied. Already-warm, already-curious, just not yet in a conversation. We built a dedicated re-engagement path for them.

The first batch of 288 of those prior-clickers came back at 91% open and 28% click. We didn't believe it, so we kept running it monthly. Across 540 sends now, that re-engagement path holds a 70.7% open rate and a 41.5% click rate — roughly 1.6 times the opens and 2 times the clicks of our standard cold sequence, sustained over months, with zero spam complaints on the original batch.

The lesson isn't "warm leads are better" — everyone knows that. The lesson is that an agent swarm can systematically find and re-engage the warm signal hiding in your own data, at a cadence no human SDR would keep up. The swarm now treats re-engagement as a first-class job, not an afterthought.

Lesson Two: The Economics Have to Be Defensible, So We Made Them Visible

Finding a verified email costs money. Some of the data providers we use charge per lookup. An agent that burns budget without producing verified contacts isn't autonomous — it's just expensive.

So the Enricher is gated. It tries the cheapest, free paths first — searching public sources, scraping a company's own contact page — and only pays for a verified lookup when the cheaper paths come up empty, with a hard per-company cap. Every paid lookup is logged and reconciled against what it produced.

That discipline got tested. On one cohort of small businesses, the scheduled enrichment path returned zero verified emails — the data provider simply had no coverage. Instead of burning the budget retrying, the swarm had a fallback: use a research model to name the actual decision-makers, then verify just those specific names. In one recovery run, that path turned a 0% cohort into roughly 31% verified yield. The budget went toward contacts we could actually reach, not guesses.

This is the part most "autonomous AI" demos skip. Autonomy isn't impressive when it's free to be wrong. It's impressive when it stays inside an economic budget and you can audit every dollar.

Lesson Three: The Swarm Catches Its Own Failures

The scariest failures are the silent ones. Here's one that happened to us.

A certificate on the link-tracking domain quietly stopped matching its hostname. Email kept "sending," but 144 outbound messages went out with broken tracking links before anyone noticed. In a manual process, that's the kind of thing you find out about a week later, by accident.

So we did what you do with a swarm: we taught it to check. Now, before every single send batch, the Messenger runs a pre-flight chain — it confirms the sending infrastructure is reachable, verifies the tracking certificate actually covers its hostname, and checks the recent bounce rate against a ceiling. If any check fails, the batch aborts before a single email goes out. The swarm catches its own infrastructure failures before they cost us anything.

That same instinct runs all the way down. There's a documented recovery routine for the worst case — a morning where the swarm sends nothing. Instead of a human reverse-engineering why, the system walks a diagnostic order, finds the bottleneck, and recovers the day. Code changes to the swarm itself can't ship to the live system until an automated test gate passes. The whole thing is built to fail safely and tell you about it.

Why We Tell Clients This Story

We don't lead sales conversations with a slide that says "AI is transformative." We lead with this: we run our own growth function on an agent swarm, here are the real numbers, and here's where it broke and how it recovered.

That's the difference between an AI vendor and an AI operator. One sells you the promise. The other has already lived inside the failure modes — the budget that runs away, the cert that silently breaks, the cold list that converts at 2% — and built the guardrails before you have to.

If your sales team is drowning in manual prospecting, or you're paying for a tool that "does AI outreach" but can't show you its own pipeline, that's exactly the conversation worth having. The swarm we run on ourselves is the same one we'd build for you.

Related Reading

• We Built a Swarm Before We Sold One — The origin story behind this post: why we built our own agent swarm before offering to build anyone else's.
• From AI Interest to AI Advantage: Why Proof Beats Promise — Why the companies winning with AI lead with proof and execution, not the loudest demo.
• From Macros to Agents: AI Any Ops Team Can Ship in 30 Days — How real teams move from brittle automation to agents that handle judgment, fast.

Related Solutions

• AI Growth Engine — Grow revenue without growing your sales org: an autonomous agent swarm that scouts, scores, enriches, and sends — the same system we run on ourselves.

Frequently Asked Questions

What is an AI agent swarm for sales outreach?

An AI agent swarm is a set of small, specialized AI agents that each handle one step of the outbound process and hand off to the next — one finds target companies, one scores them, one finds and verifies contacts, one writes and sends the outreach, and one handles replies. Unlike a single chatbot, the agents work in a chain through a shared database, so each step can fail and recover independently without taking down the whole pipeline. It replaces the manual work of a prospecting and outbound sales team.

Does an AI agent swarm actually outperform manual cold outreach?

In our own pipeline, yes — but the biggest gains came from re-engagement, not raw volume. Our standard cold sequence runs about 45% open and 21% click. When the swarm systematically re-engaged contacts who had previously clicked but never replied, that cohort sustained a 70.7% open and 41.5% click rate across 540 sends — roughly 1.6x the opens and 2x the clicks. The advantage isn't sending more; it's finding the warm signal already hiding in your data.

How do you keep an autonomous AI swarm from wasting money?

By gating the expensive steps. Our swarm tries free contact-discovery paths first — public sources and a company's own contact page — and only pays for a verified data lookup when the free paths fail, with a hard per-company cap. Every paid lookup is logged and reconciled against what it produced, so the economics are auditable. Autonomy only matters if it stays inside a budget you can defend.

What happens when the AI swarm breaks?

It's built to fail safely and tell you. Before every send batch, the swarm runs pre-flight checks on its infrastructure — sending reachability, tracking-certificate validity, and bounce rate — and aborts the batch if any check fails. There's a documented recovery routine for a zero-send morning, and code changes can't reach the live system until an automated test gate passes. The goal is a system that catches its own failures before they cost you anything.

Can you build an agent swarm like this for our company?

Yes. The AI Growth Engine is the productized version of the system described here — the same scout-score-enrich-send architecture, adapted to your ideal customer, your voice, and your sales process. We run it on our own growth function first, which means the guardrails for the common failure modes are already built. Start with a discovery conversation and we'll map where a swarm plugs into your pipeline.