Same architecture. Two completely different problems.
The first: building a partnership and investor pipeline for Streamr Network — a decentralised data infrastructure protocol — targeting government contacts, VC investors, DePIN ecosystem partners, and advisor networks across Europe and the US.
The second: building a repeatable, client-ready version of that same system that any B2B company could deploy for their own BD and GTM pipeline.
Different data. Different outputs. But the same underlying stack — Claude as orchestrator, Hermes as always-on executor, Apollo and Clay for data, Orange Slice for GTM workflows, MCP as the connective tissue, and GitHub for auditability.
Here's how I built it — and what the architecture looks like when you want to make it genuinely client-ready.
The problem at Streamr
When I joined Streamr as CMO in 2022, there was no commercial infrastructure. No CRM. No contact database. No systematic process for identifying and approaching partners, investors, or advisors. Business development was happening through personal relationships and conference conversations — valuable but not scalable.
By the time I became CEO in 2025, I needed a system that could:
- Continuously discover new BD targets across the DePIN ecosystem, web3 infrastructure, and enterprise data sectors
- Enrich those contacts with verified emails, LinkedIn profiles, and company intelligence
- Maintain a live knowledge graph of relationships and interactions
- Draft personalised outreach in Streamr's voice
- Keep the team updated without requiring manual data entry
The answer was an agentic lead gen system. Here's how I built it.
The stack
- Claude (via Cowork) — the orchestrator. The brain that runs scheduled tasks, makes decisions, and coordinates everything. Interacted with through natural language. No code required.
- Hermes Agent — the always-on executor. Runs 24/7 on a VPS, handling continuous discovery and enrichment while the team sleeps.
- Apollo — people and company search. Free tier gives access to a massive database of contacts, job titles, and company data via MCP connector.
- Clay — waterfall data enrichment. Runs each contact through multiple data providers in sequence until it finds verified emails and LinkedIn profiles.
- Orange Slice — GTM workflow automation. Describes the ideal customer in plain English and gets back a qualified, enriched lead list. Each column is an AI agent that browses the web and pulls live data.
- Google Sheets — the data layer. All contacts, enrichment status, and pipeline data. Accessible to the whole team without requiring a new tool.
- Slack — notifications and team updates. The agent posts formatted cards when new targets are found or enrichment is complete.
- GitHub — version control and auditability. Every configuration file the system runs from lives in a private repo.
The architecture: inputs → core → outputs
The system follows a clear pattern that scales to any lead gen use case.
Inputs feed the system continuously: meeting transcripts from Firefly, with names, companies and action items from every call extracted automatically; Slack signals from the company workspace covering partnership discussions, product launches and team conversations; existing Google Sheets contact lists enriched over time; web research via Apollo, Clay and Orange Slice for automated discovery of new targets; and news and funding announcements providing hiring signals, investment rounds and ecosystem events.
The core is three components working together.
The Knowledge Graph holds every contact, company, relationship and interaction — who knows who, what was discussed, what stage each relationship is at. This is what makes outreach intelligent rather than spammy.
The Brand Foundation contains the company's positioning, messaging, ICP definitions, value propositions and tone of voice. Everything the agent writes passes through this filter, codified in markdown files so both humans and agents can read and update it.
Hermes Agent is the autonomous executor that reasons and acts. It uses the knowledge graph for context and the brand foundation for voice, running 24/7 to discover leads, enrich contacts and keep data accurate. The self-improvement loop means it writes skill documents after complex tasks and gets better over time.
Outputs are actions the system takes: updated Google Sheets with enriched contact data, personalised LinkedIn message drafts, email campaign sequences, Slack notifications to the team, and weekly BD pipeline reports.
Orange Slice — GTM workflows in plain English
Orange Slice is the tool in this stack that most people haven't encountered yet, and it deserves proper explanation because it changes how you think about lead generation.
The core idea: every column in a spreadsheet is an AI agent. You describe what you want in plain English — "find the CEO's email", "what CRM do they use", "look up their annual revenue" — and a fleet of agents enriches every row in parallel by browsing the web in real time.
I used Orange Slice to discover BD targets ("find 50 DePIN infrastructure companies in Europe that have raised Series A or later and are actively hiring BD roles"), enrich at scale ("for each company, find the CEO's LinkedIn, their head of partnerships email, and their most recent press mention"), and take action — when a target matches the ICP criteria, Orange Slice can automatically sync to Google Sheets, push to a CRM, or trigger an email sequence, asking for approval in Slack before sending anything.
The practical difference between Orange Slice and traditional enrichment tools: you describe what you need in conversational language rather than configuring filters and field mappings. It is closer to briefing a researcher than operating a database.
The enrichment pipeline
Apollo handles initial discovery — finding people by title, company, sector and seniority using the free mixed_people_api_search endpoint via MCP. The critical constraint: never use the enrichment endpoints, which consume credits. Discovery only.
Orange Slice adds the first enrichment layer — natural language queries against each contact to pull company intelligence, tech stack and recent signals.
Clay adds waterfall enrichment, running each contact through multiple data providers in sequence until it finds verified email addresses and LinkedIn profiles. If Provider A doesn't have the email, it tries Provider B, then C. This dramatically increases coverage compared to any single tool.
The pipeline writes back to Google Sheets with an enrichment status column so you can see exactly what data you have and what is still missing.
Claude as orchestrator, Hermes as executor
The key architectural decision: Claude stays as the orchestrator. It is the interface humans use — accessible, familiar, no technical knowledge required. You talk to it like a colleague.
Hermes is the always-on executor. It runs autonomously, handling the continuous work: discovering contacts overnight, enriching data, keeping sheets accurate. Think of it as a digital BD manager that never sleeps.
Claude decides what to do. Hermes does it while you sleep.
The self-improvement loop is what makes Hermes different from a standard automation. When Hermes completes a complex task successfully — identifying and enriching 30 ecosystem partners in one run, for instance — it writes a skill document capturing exactly how it did it. Next time a similar task arises, it loads that skill and executes faster and more accurately. Over weeks, the system gets better at your specific use case without you retraining anything. That is what genuine compounding looks like at the infrastructure level.
From Mac Mini to VPS — making it client-ready
The first version of this system ran on a Mac Mini in my home office in Lisbon.
It worked — but it had a fundamental problem. The Mac Mini kept going to sleep. Power cuts, settings resets, occasional reboots. An agent that stops running when the machine sleeps is not a system. It is a prototype.
When I started building the client-ready version, I migrated to a VPS — a Linux server in a data centre that runs 24/7 regardless of what happens in my home. Hetzner, €4.49/month for the base tier. Always on, always connected, accessible via SSH from anywhere in the world.
The migration was straightforward. Hermes installs on Linux identically to Mac. The operational difference is everything: the system now runs without me thinking about it.
The Mac Mini still exists and is useful for local development and testing. But production runs on the VPS. If you are building this for yourself, the Mac Mini is fine to start. If you are building it for a client or need guaranteed uptime, go straight to VPS.
GitHub as the audit trail
Every configuration file — the playbooks, brand foundation documents, ICP definitions, outreach templates, skill files — lives in a private GitHub repository. The Hermes agent has read access. Claude has read access via MCP.
This gives three things a professional client engagement requires.
Version control — every change to the system is tracked. If you update the outreach templates and response rates drop, you can see exactly what changed and roll it back. This matters enormously when you are running autonomous outreach at scale.
Auditability — clients can see exactly what instructions their agent is running from. No black box. The configuration is readable markdown in a repo they have access to. This is the difference between "trust me, the AI is doing the right thing" and "here is the exact file that defines what the AI does." For enterprise clients, this is often the difference between a signed contract and a polite no.
Deployment — when the agent writes a new skill document or updates a configuration file, it commits to GitHub. Any website or dashboard changes deploy automatically via Vercel. The entire pipeline from agent action to live update is one Git commit.
For a client engagement, I hand over a private GitHub repo containing every configuration file their system runs from. They own it. They can read it. They can modify it. The agent is theirs, not mine.
Markdown as configuration language
One of the most powerful patterns in this system: using markdown files as the configuration language for AI agents.
The lead gen playbook is a single markdown file defining target company types, sectors and funding stages; target personas and seniority levels; Apollo search configurations; deduplication and filtering rules; Slack notification format; Google Sheets field mappings; and what to do and what not to do.
It reads like documentation. But it is executable configuration. Claude reads it, understands it, and follows it. Hermes does the same.
This means anyone can modify the system's behaviour by editing a markdown file. No code changes, no deployments, no developer required. A non-technical marketing director can open the ICP definition, update the target company size, and the next discovery run reflects those changes.
The MCP layer — why it matters
MCP (Model Context Protocol) is the connective tissue that makes all of this work. It is the standard that lets Claude talk to external tools — Apollo, Google Sheets, Slack, Gmail, Google Drive, Chrome — through a unified interface.
Without MCP, building this system would mean writing custom API integrations for every tool. With MCP, each tool is a connector that Claude can call directly through natural language. "Search Apollo for VPs of Partnerships at DePIN infrastructure companies in Europe" becomes a function call, not a script.
| Tool | MCP Connector | What It Does | | --- | --- | --- | | Apollo | apollo MCP | People and company search | | Orange Slice | orange-slice MCP | GTM workflow automation | | Google Sheets | sheets MCP | Contact lists and pipeline data | | Slack | slack MCP | Notifications and team updates | | Gmail | gmail MCP | Email reading and draft creation | | Google Drive | drive MCP | Shared file access | | Chrome | chrome MCP | Web page reading and interaction | | Clay | clay MCP | Waterfall data enrichment |
Each connector is added to your Claude session and immediately available. No coding, no configuration files, no deployment. Connect and go.
The practical impact: the core of this system was built in an afternoon. Not because the builder is a developer. Because MCP abstracts away the API complexity. Describe what you want, Claude figures out which tools to call and in what order.
What the roadmap looks like
The system runs through three phases, and this is the same sequence I would recommend for any client deployment.
Phase 1 — Discovery and enrichment. The agent finds contacts, enriches them with verified emails and LinkedIn profiles, and writes them to Google Sheets. Humans review and approve. No autonomous outreach yet. This phase builds confidence in data quality before anything goes out.
Phase 2 — Assisted outreach. Pre-populated LinkedIn messages and email sequences, personalised using the knowledge graph and brand foundation. The agent drafts, the human approves. One click to send. This phase tests message quality and response rates before removing the human from the loop.
Phase 3 — Autonomous pipeline. Hermes tracks which outreach messages get responses, which channels produce the best leads, which ICPs convert. It writes skill documents capturing what works and uses them to improve. The system learns from its own performance. The human's job shifts from doing the work to reviewing the output and setting direction.
The tools exist. The architecture works. The question is not whether AI-powered lead gen is possible — it is how fast you can get your first version running.
Want this built for your business?
This is what I build as fractional CMO — not a slide deck about AI lead gen, but a working pipeline running on your data, in your voice, connected to your tools.
If you want a BD pipeline, investor outreach system, or full agentic GTM stack — book a discovery call and let's scope what makes sense for your business.
The first version takes a week to build. It runs for years.
That's what I mean by marketing systems that compound.
Want this built for your business?
This is the system I build as fractional CMO — not a slide deck, a working pipeline running on your data.
Book a discovery call