Multi-Agent Sales Lead Generation System with A2A Support

AI-powered sales lead generation using Google ADK agents with standardized Agent-to-Agent communication protocol

Comment

🌟 Inspiration

As a founder who's spent countless hours manually searching for potential customers on LinkedIn and company websites, I knew there had to be a better way. The breaking point came when I spent an entire week researching prospects, only to realize I was targeting the wrong customer profile.

That's when I discovered Google's Agent Development Kit (ADK) and realized I could build intelligent agents that not only automate this process but actually learn and improve from each interaction. The vision was clear: create a system where AI agents work together like a skilled sales team—one creates the ideal customer profile, another researches the market, and a third finds and qualifies prospects.

💡 What I Learned

1. The Power of Multi-Agent Orchestration

Working with Google ADK taught me that complex problems are best solved by specialized agents working together. Instead of one monolithic AI trying to do everything, I learned to break down the sales process into discrete, manageable tasks that different agents could master.

2. Memory Makes Agents Smarter

Integrating Vertex AI's memory system was a game-changer. My agents don't just process requests—they remember past interactions, learn from previous ICPs, and get better at finding prospects over time. It's like having a sales team that never forgets a lesson learned.

3. Standardization Enables Innovation

Implementing the A2A (Agent-to-Agent) protocol taught me the importance of standardized communication. By making my agents speak a common language, I opened up possibilities I hadn't imagined—other developers can now build on top of my agents or integrate them into their own systems.

4. Real Data Beats Assumptions

Integrating with HorizonDataWave, Exa AI, and Firecrawl showed me that the best AI decisions are grounded in real, comprehensive data. My agents don't guess who your customers might be—they analyze actual company data, LinkedIn profiles, and web content to find real matches.

🔨 How I Built It

Phase 1: Foundation (Days 1-2)

I started by setting up the Google ADK framework and creating my base agent architecture. The key insight was to inherit from ADK's Agent class while adding my own external tool integrations. This gave me the best of both worlds—Google's powerful agent capabilities plus access to specialized data sources.

class ADKAgent(ABC):
    def __init__(self):
        # Google ADK provides the brain
        self.adk_agent = Agent(model=gemini_model)
        # I add the specialized tools
        self.tools = [hdw_client, exa_client, firecrawl_client]

Phase 2: Agent Specialization (Days 3-4)

I built three specialized agents:

  • ICP Agent: Uses Gemini to analyze business descriptions and create detailed customer profiles
  • Research Agent: Combines web scraping with company databases to gather market intelligence
  • Prospect Agent: Searches multiple sources and uses AI to score matches against the ICP

The breakthrough was realizing each agent needed its own prompt engineering and tool selection. The ICP agent needed more creative reasoning, while the Prospect agent needed precise data matching.

Phase 3: Orchestration Layer (Days 5-6)

Building the orchestrator was like conducting an orchestra. I used an intent-detection system powered by Gemini to understand user requests and route them to the right agent at the right time. The workflow state-machine ensures users move smoothly from describing their business to receiving qualified prospects.

Phase 4: A2A Protocol Integration (Day 7)

The final piece was making my agents interoperable. I implemented the A2A protocol, creating:

  • A FastAPI server exposing all agent capabilities
  • An agent registry with health monitoring
  • Standardized message formats for agent communication
  • WebSocket support for real-time updates

🚧 Challenges I Faced

1. The Infinite Loop Problem

My biggest challenge came when implementing ICP creation. The agent would call itself recursively, creating an infinite loop. I solved this by implementing a “JSON generation mode” that temporarily disables tool access when agents need to generate structured output.

async with self.json_generation_mode():
    icp_json = await self.process_message(prompt)

2. Streaming-Response Complexity

Getting real-time streaming to work properly on Cloud Run was tricky. Gradio's async handling didn't play nicely with my multi-agent setup at first. I had to carefully manage the event loop and implement proper async generators to stream responses while updating the UI.

3. API Rate Limits and Costs

With multiple external APIs, I quickly hit rate limits and racked up costs during testing. I implemented:

  • Intelligent caching with request fingerprinting
  • Batch processing for API calls
  • Fallback strategies when APIs fail

4. Memory Persistence Across Sessions

Making agents remember past interactions required integrating Vertex AI's database, handling async operations, and managing memory contexts. The challenge was balancing memory relevance with storage costs.

5. Prospect-Scoring Accuracy

Initially, my AI would score everyone as either 9/10 or 2/10—not very helpful! I refined my prompting strategy, implemented comparative scoring, and added detailed reasoning requirements. Now the scores are nuanced and actually useful.

🎯 The Result

What started as a personal frustration with manual prospecting became a sophisticated AI platform that:

  • Reduces prospect-research time from days to minutes
  • Learns and improves from every interaction
  • Integrates with any A2A-compliant system
  • Provides transparent, explainable AI decisions

The most rewarding moment was when I used my own system to find customers for the platform itself—and it worked! The ICP agent understood I was building a B2B sales tool, and the Prospect agent found AI-forward sales teams who became my first users.

🚀 Looking Forward

This hackathon project is just the beginning. I've proven that specialized AI agents can revolutionize B2B sales. Next, I want to:

  • Add more data sources and communication channels
  • Build agents for outreach and engagement
  • Create a marketplace where agents can discover and hire each other
  • Open-source the core framework to help others build specialized agents

Building with Google ADK taught me that the future isn't about one super-intelligent AI—it's about many specialized agents working together, each excellent at their specific task. Just like the best human teams.

Built With

  • docker
  • exa-ai
  • fastapi
  • firecrawl
  • gemini
  • gemini-flash-lite
  • google-a2a
  • google-adk
  • google-agent-development-kit
  • google-cloud
  • google-cloud-run
  • gradio
  • hdw
  • vertex-ai
Share this project:

Updates