# Building an Autonomous MCP Lead Generation System with Hermes Agent

> Source: <https://dev.to/nujovich/building-an-autonomous-mcp-lead-generation-system-with-hermes-agent-gf4>
> Published: 2026-05-25 21:43:58+00:00

How I built a daily research pipeline with Hermes Agent that finds SMEs with legacy APIs, scores them on MCP readiness, and pre-audits their public API surface — all running autonomously on my own infrastructure.

MCP (Model Context Protocol) is the emerging standard for connecting legacy APIs, databases, and manual workflows to AI agents. But finding companies that actually *need* MCP integration — and that have the budget and readiness to act — is a manual, time-consuming sales process.

I'm constantly thinking about where to focus my help and services. My problem was simple: **I needed a way to find prospects daily without spending hours on LinkedIn and Reddit. My problem was simple: **I needed a way to find prospects daily without spending hours on LinkedIn and Reddit.**

Enter Hermes Agent.

A fully autonomous **MCP Lead Generation & Pre-Audit System** that runs daily on my own infrastructure:

The result is a daily pipeline of warm, pre-vetted leads — each one with a concrete MCP action plan ready to go.

I designed a 13-question scoring system based on four dimensions:

**8+ points = High priority. 5-7 = Warm. 0-4 = Skip.**

The system is a **Hermes Agent cron job** — a self-contained prompt that the agent executes on schedule. Here's how it works:

Hermes Agent launches parallel research tasks across multiple sources:

```
delegate_task(tasks=[
  {"goal": "Search LinkedIn for operations managers
            at SMEs mentioning 'tool sprawl'..."},
  {"goal": "Scan Reddit r/SaaS, r/smallbusiness
            for integration pain points..."},
  {"goal": "Check ProductHunt and tech blogs
            for companies with obvious API needs..."},
])
```

Each prospect is evaluated against the 13-point checklist. The agent reads company websites, checks their API docs, looks for GitHub repos, and builds a complete profile.

For companies with **public API documentation or GitHub repos**, the agent performs a deeper analysis:

This transforms a cold lead into a warm prospect with a *concrete MCP proposal* ready to present.

On its first run, the system found and pre-audited two LATAM tech companies:

**Signal:** API-first payments platform with fragmented client systems.

The agent found their API documentation, analyzed ~50 REST endpoints across 18 categories (accounts, payments, FX, checkouts), and identified 5 specific MCP tools that could be built:

`cobre_crear_contraparte`

— Register beneficiaries by country/rail`cobre_ejecutar_pago_local`

— Execute SPEI/ACH/Bre-B payments`cobre_crear_cotizacion_fx`

— Get FX quotes for cross-border`cobre_ejecutar_pago_internacional`

— Execute international payments`cobre_consultar_estado_pago`

— Track payment status**Key finding:** Cobre already has an MCP server via Apidog — but a custom MCP server would be more powerful and fill their SDK gap (no Python/Node.js SDKs exist).

**Signal:** API-first identity verification with ~120 endpoints across 5 API families.

The agent mapped their entire API surface: Checks API (background checks), Digital Identity (document/facial verification), WhatsApp Engagement (chatbots), Business Rules Engine, and Validator Suite. Suggested 5 MCP tools:

`truora_check_background`

— Create background checks per country`truora_get_check_result`

— Get verification results with scores`truora_create_identity_process`

— Start digital identity validation`truora_send_whatsapp_message`

— Send WhatsApp via templates`truora_list_checks`

— Query verification history**Key finding:** Truora only has iOS SDKs — no Python, Node.js, or Go tooling. An MCP server would fill a critical gap in their developer ecosystem.

The heart of the system is a self-contained Hermes Agent cron job prompt. Here's the structure:

```
# Create the cron job
hermes cron create \
  --schedule "0 10 * * *" \
  --prompt "research prospects..."
```

The prompt instructs Hermes Agent to:

`himalaya template send`

```
cat << 'MAILDELIM' | himalaya template send
From: me@email.com
To: me@email.com
Subject: 🔌 MCP Prospects — [DATE]

═══════════════════════════════════════
1. AUDIT NOW — Company Name
   🔧 PRE-AUDIT: READY TO AUDIT
   API Docs: https://docs.example.com/
   ...
   🛠️ Suggested MCP tools:
   • tool_name — what it does
═══════════════════════════════════════
MAILDELIM
```

I chose Hermes Agent for three reasons:

**Autonomous research** — The agent can browse, read, analyze, and make decisions without me in the loop. It's not a script — it *reasons* about what it finds.

**Tool ecosystem** — Hermes Agent's built-in browser, web search, and terminal tools let it navigate real websites, parse API docs, and interact with GitHub — just like a human researcher would.

**Self-hosted** — This runs on my own infrastructure. No API costs, no data leaks to third parties. The prospect data stays mine.

**Cron jobs** — The built-in scheduler means the system runs itself. I wake up to a fresh lead report every morning.

This system is already running daily. My roadmap includes:

If you're running Hermes Agent, you can build something similar in a few hours:

The hardest part isn't the technology — it's knowing what signals to look for. That's where your domain expertise comes in.

*Built with Hermes Agent — the open-source agentic system that runs on your own infrastructure.*

*🔗 **Full code and prompts:** [github.com/nujovich/hermes-mcp-lead-gen](https://github.com/nujovich/hermes-mcp-lead-gen)*

*Follow me on LinkedIn*