TL;DR
Two open-source projects — Paperclip (governance + coordination) and OpenClaw (browser automation + execution) — can replace a $300/month SaaS prospecting tool when combined correctly. This article shows you how to build a three-agent lead generation squad from scratch: a Researcher that defines targets, an Executor that scrapes and enriches via OpenClaw, and a Validator that enforces quality. Total infrastructure cost: under $90/month. Time to first leads: one working day. Three realistic paths to monetize within 30 days included.
Here is the decision you are actually facing.
A DevOps lead at a Series A developer tools company just signed up for your uptime monitoring micro-SaaS. You know there are hundreds more like him. The problem is finding them systematically.
You have three options. Spend three to four hours per day manually prospecting on LinkedIn — unsustainable. Subscribe to a SaaS prospecting tool at $250 to $400 per month — that is a $3,000+ annual commitment before you have proven the market. Or build the infrastructure that does the work while you sleep, for a fraction of the cost, and that you own entirely.
The third option stopped being theoretical about six months ago. Two open-source projects changed the math: Paperclip — which crossed 42,000 GitHub stars in under a month — gives you governance, budget caps, and coordination for AI agent squads. OpenClaw — with over 339,000 stars — executes real-world tasks: web scraping, browser automation, API integrations, data enrichment.
Together, they form something closer to a small operation than a script. The key word is “governed.” Not just automated — governed. Every action is logged. Every agent has a hard budget ceiling. Every decision is auditable. That distinction matters whether you are running this for yourself or selling it as a service.
This article is about the infrastructure decision, the build sequence, and the monetization path. Installation details are included, but they are not the point.
The case for building instead of buying
Before touching a single line of configuration, understand what you are actually choosing.
A prospecting SaaS tool like Apollo.io or ZoomInfo charges you for access to a database you do not control, a workflow you cannot modify, and an algorithm you cannot inspect. When the data quality drops, you file a support ticket. When the pricing changes, you either pay or migrate. When you want to add a custom enrichment step — say, checking BuiltWith to filter for companies using Kubernetes — you wait for a feature request.
The Paperclip + OpenClaw stack inverts every one of those constraints. You define the data sources. You define the enrichment logic. You define the quality criteria. When something breaks, you read the audit log and fix it. When you want to add a scoring step, you add another agent.
The trade-off is real: you spend one day building it instead of signing up in five minutes. That trade-off makes sense when:
- You are generating leads for yourself and want compound improvement over time
- You are selling a done-for-you prospecting service to clients
- You are building a data product that needs a proprietary collection pipeline
- You need a pipeline your clients can audit (a differentiator in enterprise sales)
If you need leads today and have no intention of ever reselling or customizing the workflow, pay for the SaaS tool. But if any of the above apply, the infrastructure investment pays back within the first client.
What the three-agent architecture looks like
The squad operates as three specialized agents coordinated by a single Paperclip instance running on your server.
┌─────────────────────────────────────────────┐
│ PAPERCLIP (Governance) │
│ │
│ ┌──────────────┐ │
│ │ Agent 1 │ ← Defines ICP, breaks │
│ │ Researcher │ work into tasks │
│ └──────┬───────┘ │
│ │ POST /issues │
│ ▼ │
│ ┌──────────────┐ │
│ │ Agent 2 │ ← Scrapes, enriches │
│ │ Executor │ via OpenClaw browser │
│ │ (OpenClaw) │ automation │
│ └──────┬───────┘ │
│ │ PATCH /issues │
│ ▼ │
│ ┌──────────────┐ │
│ │ Agent 3 │ ← Validates, dedupes, │
│ │ Validator │ formats output │
│ └──────────────┘ │
│ │
│ Budget cap: $50/month per agent │
│ Heartbeat: every 15 minutes │
│ Audit log: every action recorded │
└─────────────────────────────────────────────┘
The output is a CSV or JSON file with enriched leads — name, company, title, email, LinkedIn URL, tech stack — generated automatically from an ICP you defined once.
Specific scenario this article builds toward:
You sell an uptime monitoring micro-SaaS. Your ICP is DevOps leads and CTOs at developer tools companies with 10 to 200 employees, primarily Series A and B, primarily US and UK. The squad researches companies in that space, extracts decision-maker contact data, enriches with tech stack information, and delivers a validated list ready for outreach.
Minimum stack required
| Component | What it does | Where to get it |
|---|---|---|
| Node.js 20+ | Paperclip runtime | nodejs.org |
| pnpm 9.15+ | Package manager | npm install -g pnpm |
| Paperclip | Agent governance + coordination | npx paperclipai onboard --yes |
| OpenClaw | Browser automation executor | github.com/openclaw/openclaw |
| LLM API key | Claude, GPT-4o, or equivalent | Your provider of choice |
| Linux VPS (optional) | 24/7 operation | Any $5/month VPS |
Total monthly cost estimate: $60 to $90 in LLM API tokens plus $5 for a VPS. Compare that to $250 to $400 for a prospecting SaaS with less flexibility.
Run in one day: the concrete path
This section comes before the detailed architecture deliberately. Most builders stall because they try to build the complete system first. Start with the minimum viable pipeline instead.
Morning block (two hours):
Install Paperclip with the one-command setup:
npx paperclipai onboard --yes
This opens a dashboard at http://localhost:3100 with a setup wizard. PostgreSQL is created automatically — no external database configuration needed.
In the dashboard, create your company:
Name: LeadGen Squad
Mission: Identify and extract contact data for decision-makers
at B2B SaaS companies with 10-200 employees,
delivering validated lists for outreach.
Create the main goal:
Goal: Weekly lead generation
Description: Generate 200 qualified leads per week.
Each lead must include: name, title, company,
email, LinkedIn URL, tech stack.
Focus on DevOps leads and CTOs at developer
tools companies, 10-200 employees, US/UK.
KPI: valid_leads / week >= 200
Then hire just two agents — the Researcher (CEO role by default) and the Executor. Set their monthly budgets to $50 each and heartbeat intervals to 30 minutes and 15 minutes respectively.
Afternoon block (two hours):
Install OpenClaw on the same server:
git clone https://github.com/openclaw/openclaw.git
cd openclaw
npm install
cp .env.example .env
Configure the .env:
OPENCLAW_LLM_PROVIDER=anthropic
OPENCLAW_MODEL=claude-sonnet-4-20250514
OPENCLAW_API_KEY=your-api-key
OPENCLAW_TOOLS=browser,shell,http,file
OPENCLAW_BROWSER_HEADLESS=true
Connect OpenClaw to Paperclip using the token generated when you created the Executor agent:
openclaw connect --paperclip-url http://localhost:3100 \
--token YOUR_CONNECTION_TOKEN \
--agent-id executor-agent-id
Once connected, OpenClaw sits in standby and responds to Paperclip’s heartbeats.
Create three test tasks manually in the Paperclip dashboard — simple targets like “extract leads from Grafana Labs team page,” “extract leads from Honeycomb.io about page,” “extract leads from incident.io.” Assign them to the Executor.
Evening block (one hour):
Watch the first heartbeat cycles run. The Executor will pick up tasks, open the browser, attempt scraping, and report results back as comments on each task. Some will succeed. Some will hit anti-bot protection. That is expected.
Review the output. Validate the first five to ten leads manually against your ICP. Adjust the Executor’s instructions if the output misses your criteria.
Day two:
Add the Validator agent, set its heartbeat to 20 minutes, and configure it to pick up tasks in in_review status. It handles deduplication, email format validation, and decision-maker title verification automatically from that point forward.
You will have 20 to 40 validated leads by end of day two, with the system running autonomously. That is the signal that the infrastructure works — not perfection, but proof of the loop.
Agent roles and governance configuration
Researcher: the strategist
The Researcher is the CEO of your Paperclip company. It reads the goal, breaks it into executable tasks, monitors quality from the Validator, and adjusts targeting criteria based on results.
Configure its instructions (the SOUL.md field in Paperclip):
You are a lead research strategist.
Your function:
1. Analyze the company goal and break it into executable tasks
2. Create specific tasks for the Executor with clear targeting criteria
3. Monitor lead quality reported by the Validator
4. Adjust search criteria when quality drops below threshold
Rules:
- Never execute scraping yourself — delegate to the Executor
- Each task must have specific, measurable criteria
- If a lead source yields less than 30% valid leads after two cycles, replace it
- Preferred sources: company team pages, LinkedIn, Crunchbase, GitHub org pages
Budget: $50/month. Runtime: Claude or any adapter that handles complex reasoning.
Executor: the muscle (OpenClaw)
The Executor handles all actual data extraction. It uses OpenClaw’s browser automation to navigate real websites, extract team members, check for decision-maker titles, and enrich with email lookups and tech stack data.
Configure it with:
You are a data extraction executor.
Your tools: browser, HTTP requests, APIs.
When you receive a prospecting task:
1. Navigate to the target source indicated in the task
2. Extract people matching the criteria (decision-maker titles only)
3. Enrich with email via Hunter.io when available
4. Check tech stack via BuiltWith or Wappalyzer
5. Comment raw data on the task in JSON format
6. Set status to in_review
Output format per lead:
{
"name": "Alex Morgan",
"title": "VP Engineering",
"company": "Incident.io",
"email": "alex@incident.io",
"linkedin": "https://linkedin.com/in/alexmorgan",
"tech_stack": ["AWS", "Kubernetes", "PagerDuty", "Datadog"]
}
Decision-maker titles to target:
CTO, VP Engineering, Director of Engineering, Head of Infrastructure,
DevOps Lead, SRE Lead, Platform Lead, Engineering Manager
Budget: $50/month. Runtime: OpenClaw gateway adapter.
Validator: the quality gate
The Validator ensures nothing gets to your outreach pipeline without passing quality checks. It runs after the Executor and is the difference between a 30% bounce rate and a 5% bounce rate on your cold emails.
You are a lead quality validator.
When a task arrives with status in_review:
1. Check all required fields are populated
2. Validate email format (must contain @ and a valid domain)
3. Run deduplication check against workspace leads (same email OR same LinkedIn)
4. Verify title matches the decision-maker criteria
5. If more than 20% of leads in a batch are invalid, return to Executor with notes
6. If approved, format as CSV and save to workspace/validated/
7. Set task status to done
Rejection criteria:
- Generic email (info@, contact@, hello@, support@)
- Non-decision-maker title (intern, assistant, coordinator, junior)
- Company under 10 employees
- Missing two or more required fields
- Duplicate entry already in workspace
Budget: $30/month. Runtime: Claude (light mode — lower cost per token).
Budget governance: why this is the critical layer
Most tutorials treat budget configuration as a footnote. It is not. It is the difference between a system that earns and a system that runs up a surprise API bill.
Configure your budget controls in Paperclip under Settings → Budget:
Company budget: $130/month
Per agent:
- Researcher: $50/month (soft warning at 80% = $40)
- Executor: $50/month (soft warning at 80% = $40)
- Validator: $30/month (soft warning at 80% = $24)
Hard stop: 100% — agent pauses automatically
Circuit breaker: pause if 3 consecutive failures
The hard stop is non-negotiable. Every agent, every time. A heartbeat loop running without a hard stop can generate hundreds of dollars in tokens within hours if something goes wrong — a bad instruction, a runaway retry loop, a misconfigured task assignment. The budget ceiling is what separates a governed pipeline from an expensive mistake.
When the Executor hits its 80% soft warning, you get a dashboard notification. When it hits 100%, it pauses until the next billing cycle or until you manually reset it. The company never exceeds $130/month regardless of what any individual agent does.
This governance layer is also what makes the system sellable. When a client asks “how do I know your agents won’t run up unbounded costs?” — you show them the audit log and the hard stop configuration. That answer closes deals.
How the heartbeat loop works
Every 15 minutes, the Executor wakes up and follows this sequence:
Step 1 — Identity confirmation
GET /api/agents/me
Authorization: Bearer {token}
The agent confirms who it is, what its remaining budget looks like, and who it reports to.
Step 2 — Task discovery
GET /api/companies/{id}/issues?assigneeAgentId={id}&status=todo,in_progress
If no tasks are available, the agent returns to standby. This is where idle token costs come from — configure longer heartbeat intervals (60+ minutes) for agents that do not need constant attention.
Step 3 — Atomic task checkout
POST /api/issues/{issueId}/checkout
X-Paperclip-Run-Id: run-abc123
This locks the task. If the response is 409 Conflict, another agent already claimed it. The Executor moves on — no retry, no duplicate work.
Step 4 — Execution
OpenClaw opens a headless browser, navigates to the target, extracts data according to the Executor’s instructions. For a company team page, this looks like:
async function extractLeads(issue) {
const targets = parseTargets(issue.description);
const leads = [];
for (const target of targets) {
await browser.navigate(target.url);
const team = await browser.scrape({
selector: '.team-member, [class*="person"], [class*="team"]',
extract: ['name', 'title', 'linkedin_url']
});
for (const person of team) {
if (isDecisionMaker(person.title)) {
person.email = await hunterAPI.findEmail(
person.name, target.domain
);
person.tech_stack = await builtWithAPI.lookup(target.domain);
leads.push(person);
}
}
}
return leads;
}
Step 5 — Status update
PATCH /api/issues/{issueId}
{
"status": "in_review",
"comment": "Extracted 14 leads from 4 company pages. 2 sites blocked (Cloudflare). Leads in workspace/leads_batch_017.json."
}
Step 6 — Subtask creation for blockers
When a site blocks scraping, the Executor creates a subtask rather than failing silently:
POST /api/companies/{id}/issues
{
"title": "Retry blocked sources via alternative method",
"description": "Use Google cache or public API fallback for: [sites list]",
"parentId": "issue-017",
"assigneeAgentId": "executor-agent-id",
"status": "todo"
}
The full loop visualized:
[Heartbeat: 15min]
│
▼
GET /agents/me ← Budget check
│
▼
GET /issues?status=todo ← Task discovery
│
├── None ──→ Standby until next heartbeat
│
▼ (Tasks available)
POST /issues/{id}/checkout ← Atomic lock
│
├── 409 ──→ Skip, another agent has it
│
▼ (Checkout confirmed)
OpenClaw executes ← Real browser work
│
▼
PATCH /issues/{id} ← Report results
│
▼
Standby until next heartbeat
A real execution cycle
Scenario: The Researcher has targeted Series A developer tools companies. It created six tasks, each covering four companies.
Executor wakes (minute 0):
→ GET /agents/me
Agent: Executor | Budget remaining: $44.80 / $50.00
→ GET /issues?status=todo
6 tasks available
→ POST /issues/task-001/checkout
200 OK — task acquired
→ Executing against incident.io/about...
- Navigated to team page
- Found 8 people, 3 match decision-maker criteria
- CTO: Chris Evans — email found via Hunter.io
- VP Eng: Sarah Patel — email found via Hunter.io
- Dir of Infra: Marcus Webb — email not found (manual lookup needed)
- Tech stack via BuiltWith: AWS, Kubernetes, PagerDuty, Prometheus
→ PATCH /issues/task-001
Status: in_review
Comment: 3 leads extracted from incident.io. Data in workspace/leads_001.json.
Validator wakes (minute 0, same cycle):
→ GET /agents/me
Agent: Validator | Budget remaining: $27.20 / $30.00
→ GET /issues?status=in_review
1 task found (task-001)
→ Validating 3 leads...
- Chris Evans: email format valid, MX check OK, title OK (CTO)
- Sarah Patel: email format valid, MX check OK, title OK (VP Engineering)
- Marcus Webb: email missing — rejection criteria met (missing required field)
→ Flagged for manual enrichment, not added to validated output
→ PATCH /issues/task-001
Status: done
Comment: 2/3 leads approved. 1 flagged (missing email). CSV saved.
→ Output:
name,title,company,email,linkedin,tech_stack
"Chris Evans","CTO","Incident.io","chris@incident.io","linkedin.com/in/chrisevans","AWS,Kubernetes,PagerDuty,Prometheus"
"Sarah Patel","VP Engineering","Incident.io","sarah@incident.io","linkedin.com/in/sarahpatel","AWS,Kubernetes,PagerDuty,Prometheus"
End of day: 35 to 55 validated leads across six cycles, depending on scraping success rate and how often anti-bot protection triggers.
Three ways to monetize within 30 days
Path 1: Done-for-you lead lists (fastest to revenue)
Configure the squad to generate leads in a specific niche — DevOps tooling, fintech infrastructure, edtech platforms — and sell the validated CSV as a digital product. A list of 500 verified DevOps leads with email, LinkedIn, and tech stack sells for $150 to $350 on Gumroad. Your cost to produce it: approximately $15 in API tokens.
Create three to five niche lists in your first two weeks. Stack them on a simple Gumroad page with clear ICP descriptions. This is table-stakes validation: if buyers pay for the lists, the niche has demand worth serving.
Path 2: Prospecting-as-a-service (highest margin)
A small agency or freelance consultant running outbound needs 50 to 100 fresh leads per week, consistently. You charge $400 to $800/month for a weekly delivery of validated leads in their ICP. Your infrastructure cost: $90/month. Margin: $310 to $710/month per client.
The governance layer is your differentiator here. Most freelancers scraping leads manually cannot show a client an audit log of every data point’s origin and validation timestamp. You can. That answer matters in enterprise sales conversations where data provenance is a compliance question, not just a nice-to-have.
Path 3: Vertical data product (highest ceiling)
Pick a vertical with strong B2B demand — developer tools, infrastructure, cybersecurity — and build a data product around the tech stack angle specifically. “Companies using Kubernetes with under 200 engineers” is a buying signal for vendors in the platform engineering space. “Series A fintech companies running Datadog” is a buying signal for Datadog competitors.
Build the collection pipeline, set up a simple API or Notion database as the delivery layer, and sell monthly access at $99 to $299. The Paperclip + OpenClaw stack refreshes the data on a cadence you control. This takes four to six weeks to build properly but creates recurring revenue that compounds.
Monitoring and audit trail
The Paperclip dashboard gives you two views that matter operationally:
Audit log (Company → Audit Log):
Every agent action is recorded with timestamp, tokens consumed, decision rationale, and outcome. When the Validator rejects a batch, you see exactly which leads failed and why. When the Executor creates a subtask for a blocked site, you see the reasoning. This log is the debugging surface for everything — and it is also what you show a client when they ask how the pipeline works.
Budget view:
Company Budget: $130/month
├── Researcher: $11.20 / $50.00 (22.4%) ✅
├── Executor: $28.50 / $50.00 (57.0%) ⚠️ approaching soft warning
└── Validator: $4.90 / $30.00 (16.3%) ✅
Total spent: $44.60 / $130.00
Monthly projection: $89.20 (based on last 7 days)
The projection line is what tells you whether you are on track for the month or need to reduce heartbeat frequency.
Alert thresholds:
- 80% of agent budget: Dashboard notification (soft warning)
- 100% of agent budget: Agent pauses automatically (hard stop)
- 3 consecutive task failures: Circuit breaker activates
- 5 heartbeats with no task progress: Stalled agent alert
Known limitations and real workarounds
Anti-bot protection. Sites running Cloudflare, reCAPTCHA, or heavy JavaScript fingerprinting will block the Executor. OpenClaw handles standard dynamic JavaScript rendering but not advanced bot protection. Workarounds: use Hunter.io’s company search API directly, fall back to Google cached pages, or source company lists from Crunchbase’s API instead of scraping company websites.
Idle token cost. Every heartbeat consumes tokens even when no tasks are available. Three agents running every 15 minutes generates meaningful “idle” cost at scale. Fix: extend heartbeat intervals for the Researcher and Validator (30 to 60 minutes), since they react to work the Executor creates rather than initiating it.
No persistent memory by default. If the Executor learns that a particular site blocks scraping, that knowledge disappears on the next heartbeat. Fix: use Paperclip’s SKILL.md and MEMORY.md workspace files to persist discovered blockers and successful patterns across sessions.
OpenClaw gateway connection drops. The SSE connection between Paperclip and OpenClaw does not have robust automatic reconnection yet. Fix: add a simple health check cron that pings the connection every 10 minutes and restarts it if needed.
Paperclip is v0.3.x. The project is young. There are over 400 open issues and the API has changed between minor versions. Do not deploy this on production infrastructure for a client without building a version-pin and testing protocol first.
The infrastructure decision in full
When you weigh paying $300/month for a SaaS prospecting tool against building this pipeline, the comparison is not tool vs. tool. It is renting vs. owning.
Renting gets you started in five minutes and hands the maintenance overhead to someone else. Owning gives you a pipeline you can improve continuously, audit completely, and sell as a service.
The Paperclip + OpenClaw combination is at the right inflection point: mature enough to run in production with reasonable stability, young enough that most of your competitors have not built it yet. That window does not stay open indefinitely.
The path forward from a working V1 is straightforward: add enrichment sources (Clearbit, Apollo.io API, GitHub org search), add a scoring agent that ranks leads by signal strength, connect the validated output to an outreach sequencer (Instantly, Smartlead), and move from generating leads to closing them automatically.
That is not a SaaS subscription. That is a business operation you control.
Build the infrastructure. Own the pipeline. Collect the results.
Related reading:
