How to Deploy AI Agents for Lead Generation: An Operator's Playbook

The Core Stack: What You Actually Need

Forget the all-in-one platforms that promise push-button lead generation. They’re black boxes that produce generic, low-quality outreach. If you want results, you have to build the machine yourself. The good news is that the components are cheaper and more accessible than ever. You don’t need to be a developer, but you do need to be an operator who understands how to connect the pieces.

Here’s the minimal, no-fluff stack I use:

• A Data Source: This is your starting point. You need a way to find potential leads. I use tools like Apify or Bright Data to scrape public directories, industry news sites, or job boards. For example, you could set up a scraper to pull a daily list of companies that just raised a Series A from TechCrunch. The quality of your entire system depends on the quality of this initial data.
• An Orchestration Tool: This is the brain of your operation. It triggers workflows and passes data between services. I use the Make platform for this. It’s a visual builder that’s more flexible and cost-effective for multi-step processes than Zapier. If you’ve tried to build a complex, branching workflow in Zapier, you know the pain of their task-based pricing. Make.com’s operation-based model is much more forgiving for agentic workflows.
• The LLM API: This is the agent itself. You’ll make API calls to a large language model to perform research, analysis, and writing. Your main choices are OpenAI (GPT-4o, GPT-4 Turbo) or Anthropic (Claude 3 family). For most lead-gen tasks like summarizing a website or categorizing a company, Claude 3 Sonnet is my pick. It’s fast, reliable, and significantly cheaper than GPT-4 Turbo. At around $3 per million input tokens, it’s a steal for structured data extraction.
• A State Store (aka ‘Memory’): You need a simple database to track your work. Where have your agents looked? Who have they qualified? What was the output? Don’t overcomplicate this. An Airtable base or even a Google Sheet is perfectly fine to start. It acts as the agent’s memory and your central dashboard.

What Most Guides Get Wrong About AI Lead Gen

Most of the content you’ll find on this topic is theoretical nonsense written by marketers, not builders. They promote a fundamentally flawed approach that dooms you to failure before you even start.

The biggest mistake is the ‘one-shot prompt’. People try to cram everything into a single, massive prompt given to one AI agent. They’ll ask it to “find me 10 tech companies in Austin, research their key decision-maker, find their email, and write a personalized cold email.” This will never work reliably. The context window gets confused, the model hallucinates information, and the output is an unusable mess. It’s a brittle and lazy approach.

It will fail.

The only way to build a system that works is to break the problem down into a series of smaller, specialized agents. Think of it like an assembly line. One agent does one job, does it well, and then passes the result to the next agent in the chain. A ‘Researcher’ agent just finds and structures data. A ‘Qualifier’ agent just checks if the lead meets your criteria. A ‘Writer.com‘ agent just drafts the outreach. Each step is simple, testable, and debuggable.

Another common failure is ignoring the data source. People scrape a list of 10,000 domains from a cheap, outdated list provider and wonder why their outreach gets zero replies. Your agent is only as good as the information you feed it. Start with a small, high-quality, and recent data source. It’s better to have 50 highly relevant leads than 5,000 random ones.

Building the ‘Researcher’ Agent: A Step-by-Step Example

Let’s make this concrete. Say your goal is to find B2B SaaS companies that have recently launched a new major feature, because that’s a great trigger for your service. Here’s how you’d build the first agent in the chain using Make.com and an LLM.

1. The Trigger: The workflow starts when a new company URL is added to a specific view in your Airtable base. You could populate this list manually or by using an Apify scraper that monitors specific software review sites.
2. The Scraper: The first Make.com module is an HTTP request that uses a simple scraping API (like ScraperAPI or the built-in Apify integration) to fetch the raw HTML content of the company’s homepage or blog.
3. The Agent Call: The next module is an API call to Anthropic or OpenAI. You’ll feed the scraped HTML content into a carefully structured prompt. This is the core of your agent.

Here is the exact type of prompt I use for this research task. Notice how it asks for a specific output format (JSON) to make the data easy to use in the next steps.

You are an expert business analyst AI. Your task is to analyze the provided HTML content from a company's website and extract specific, factual information. Your output must be a valid JSON object. Do not add any commentary or conversational text. Based ONLY on the provided text, extract the following:1. `company_name`: The official name of the company.2. `one_liner`: A single, concise sentence describing what the company does.3. `target_customer`: A brief description of their ideal customer (e.g., "enterprise sales teams," "freelance graphic designers").4. `recent_announcement`: The title of the most recent blog post, feature launch, or press release mentioned. If nothing is found, return null.Website Content:---{{scraped_html_content}}---Output only the JSON object.

4. The Update: The final step is to parse the JSON response from the LLM and update the company’s record in Airtable with the structured data your agent just created. Now you have clean, useful information ready for the next agent in the chain.

Is the Free Tier Actually Usable for This?

This is a common question, and the answer is: for testing, yes. For production, absolutely not. The economics of the free tiers are designed to get you hooked, not to run a business process.

Let’s break it down:

• Make.com: Their free plan gives you 1,000 operations per month. The workflow described above uses at least 4 operations per lead (Trigger, Scrape, LLM Call, Airtable Update). You can process maybe 250 leads before the lights go out. Honestly, the free plan is a joke for production. You’ll burn through your operations in a single decent-sized run. The Core plan at $9/month is the real starting point and is incredibly fair for what you get.
• Airtable: The free plan is fantastic. It offers 1,000 records per base, which is more than enough to manage your lead pipeline when you’re starting out. This is one part of the stack where the free offering is genuinely sufficient for a while.
• LLM APIs: There are no free tiers for serious use. You pay per token from day one. This is your main variable cost. A run of 1,000 leads with the researcher agent might cost anywhere from $2 to $10 in API fees depending on the model and the size of the websites you’re scraping. It’s not free, but it’s incredibly cheap for the value it provides.
• Apify: I love that Apify gives you $5 in free platform credits every month. It’s enough to actually build and test your scrapers and run small, targeted jobs to validate an idea without putting a credit card down.

The ‘Qualifier’ and ‘Writer’ Agents: Chaining the Workflow

Once your Researcher agent has populated your Airtable base with clean data, the next steps are qualification and drafting. This is where you create the next links in your assembly line.

The Qualifier Agent is a simple gatekeeper. Its only job is to look at the data from the first agent and decide if the lead is a good fit. You can trigger this in Make.com whenever a record in Airtable is updated by the Researcher. The prompt is a straightforward rule check: “Based on this data: `{{research_data_json}}`, does this company meet all the following criteria: 1) Is a B2B company, 2) Is not in the gambling industry, 3) Has a target customer of ‘enterprise sales teams’. Respond with only the word ‘YES’ or ‘NO’.” If the answer is ‘YES’, the record gets moved to a ‘Qualified’ view in Airtable. If ‘NO’, it’s moved to a ‘Discarded’ view.

Next, the Writer Agent picks up the qualified leads. This agent’s prompt is more creative. It takes the `company_name`, `one_liner`, and `recent_announcement` fields and uses them to draft a personalized opening line or a complete cold email. The key is that this draft is *not* sent automatically. It’s saved to a new field in Airtable called ‘Draft_Email’. This creates a queue for human review.

How to Debug When This Breaks

This system will break. Automation is not a one-time setup; it’s a process of continuous monitoring and improvement. Expecting it to run perfectly forever is a recipe for frustration. Here are the most common failure points and how to fix them.

First, the LLM will return malformed JSON. My biggest gripe with building these systems is silent failures. GPT-3.5, in particular, loves to get creative with its JSON output, sometimes adding conversational text or a trailing comma that will cause your JSON parser module in Make.com to throw an error. You absolutely must build an error-handling route in your scenario. If the JSON parsing fails, the error handler should catch it, log the raw text output from the LLM to a separate Google Sheet, and send you a notification. This way, you can see exactly what the model returned and adjust your prompt to be more specific.

Second, your scraper will get blocked. Websites don’t like being scraped. If you’re hitting the same site too frequently or without the right headers, you’ll get hit with a CAPTCHA or an IP ban. The solution is to use a proper scraping service like Bright Data that manages residential proxies and browser fingerprints for you. Don’t try to build this yourself with a cheap data center proxy; you’ll just waste your time.

Finally, your prompts will ‘drift’. A prompt that worked perfectly last week might start producing worse results this week as the underlying model is updated. The fix is simple: version control your prompts. When you have a prompt that delivers consistent, high-quality results, save its exact text in a document. Don’t just edit it live in Make.com. When performance degrades, you can revert to the last known good version and analyze what changed.

For more on this exact angle, deeper coverage of AI agent platforms.

Building this system takes time, especially dialing in the prompts and error handling. If you’d rather skip the build and deploy a working version in an afternoon, we’ve packaged this entire operator playbook as a blueprint at deepusecase.com/vault/ai-agent-builder-kit.