GTM Email Sequencer — personalized cold email + Instantly push
One ready-to-sequence lead at a time, picked from your workspace DB, dressed in the right variant for its context signals, written, stored, and pushed straight into Instantly. Runs every 5 minutes, never double-sends.
Build this with agnt_
Skip the copy-paste. We'll spin up a builder session prepopulated with this blueprint's spec — providers, schedule, database schema, and the questions the agent should ask you to personalize it for your product.
Sign up free · no credit card
The motion
Cold outbound goes cold the moment it gets templatey. This agent gives every ready-to-sequence lead its own contextually-chosen email — the variant is picked by signals on the lead row (role + company size, title + tenure, trigger type — whatever you've enriched), placeholders are filled from the row, and the result is written back plus pushed into your Instantly campaign for sending. The agent processes exactly one lead per run on a 5-minute cron, which keeps runs deterministic and trivial to monitor in the session log. An `in_progress` claim is taken before any work so two concurrent runs can never send the same lead twice. The blueprint is general — works for hiring outreach, sales outbound, partner outreach, fundraising, anywhere you have a verified-lead → personalized-email flow. Pair with the LinkedIn / X engager scraper + qualifier blueprints to fill the leads table upstream.
The agent picks the right variant by signals on the lead row (role + company size by default) and fills [Name], [company], and your context token from the row — not a generic title fallback.
Processes exactly one lead per 5-minute tick. Every run is monitorable end-to-end; failures are obvious from the JSON summary in the session log.
The agent flips a lead to `in_progress` before any work happens. Two concurrent runs can never both grab the same row.
Writes the finalized email back to the lead row and pushes the lead into your Instantly campaign with the subject, body, and follow-up as custom variables.
Outbound goes cold the moment it gets templatey. This agent gives every ready-to-sequence lead its own contextually-chosen email — the variant is picked by signals on the lead row (role + company size, trigger type, whatever you've enriched), and placeholders are filled from the row, not a generic fallback. Then it pushes straight to Instantly. One lead per run, every 5 minutes, never re-touches a row.
Build this with agnt_
Skip the copy-paste. We'll spin up a builder session prepopulated with this blueprint's spec — providers, schedule, database schema, and the questions the agent should ask you to personalize it for your product.
Sign up free · no credit card
Or copy a prompt into another platform
Prefer to build with OpenClaw, Hermes, or Claude Code? Drop this prompt into your agent of choice — it seeds the goal, the agntdata endpoints to use, and a step-by-step plan.
You are helping me build a GTM Email Sequencer agent that runs on a 5-minute cron. It picks up one verified lead at a time from my workspace database, writes a personalized cold email using one of several contextual variants (chosen by signals on the lead — e.g. their role and the size of their company), stores the draft alongside the lead, and pushes the lead into my Instantly campaign for sending.
This blueprint is general — it works for any outbound motion where you have a stream of verified leads and want a personalized email per lead. Hiring outreach, sales outbound, partner outreach, fundraising — same shape.
REFERENCE DOCS (read these before writing code)
- Full agntdata API documentation: https://agnt.mintlify.app/apis/overview
- agntdata Instantly integration: bulkAddLeads — the only outbound this agent does
- Workspace DB access via agnt.db — used for the lead claim, draft write, and status updates
ABOUT MY PRODUCT
- Product name: <YOUR PRODUCT>
- One-line description: <WHAT IT DOES>
- ICP: <WHO YOU SELL TO — role + company stage>
- Sender voice: <FOUNDER NAME, role, signing-off line for emails>
- Instantly campaign id (UUID): <CAMPAIGN_ID>
YOUR DATA MODEL
- Leads table name: <LEADS_TABLE> (default: `leads`)
- "Ready to sequence" filter: `<READY_STATUS_COLUMN> = '<READY_VALUE>'` (e.g. `enrichment_status='verified'`, `qualification_status='qualified'`, or just `status='ready'`)
- Sequencing state column: `<SEQUENCE_STATUS_COLUMN>` (typical default: `sequencing_status`, with values `pending → in_progress → sequenced | sequencing_failed`)
- Variant selection signals — the 1–3 columns the agent reads to pick a variant. Common combos:
- role + company size (default)
- role + industry
- title + tenure
- trigger event type (job change / funding / signup) + company size
- Personalization tokens used in your variants: at minimum `[Name]`, `[company]`, and `[context]` — where `[context]` is whatever lead-specific value your hooks reference (job title, recent trigger, etc.). Tell me which column `[context]` maps to on your lead rows.
EMAIL VARIANTS
Give me 3–5 contextual variants of your cold email. For each, specify:
- WHEN TO USE — the trigger (e.g. mid-market + sales role, early-stage startup + technical founder)
- SUBJECT LINE — with placeholder tokens
- BODY — 3–5 short paragraphs, ending with a soft question close
- FOLLOW-UP — one universal follow-up the agent sends as a reply to every email
WHAT TO BUILD
- A scheduled agent on agntdata that runs every 5 minutes (claude-sonnet-4-6 — the variant-selection logic benefits from the smarter model).
- Each run: claim ONE row from <LEADS_TABLE> where `<READY_STATUS_COLUMN>='<READY_VALUE>'` AND `<SEQUENCE_STATUS_COLUMN>='pending'`. Order by `created_at ASC`. Immediately mark it `in_progress` so concurrent runs don't double-process.
- Pick the right variant using your variant-selection signals. Substitute placeholders from the lead row. Generate clean output: no double line breaks, no stray punctuation.
- Write the finalized `email_subject`, `email_body`, and `email_variant` back onto the lead row.
- Call Instantly `bulkAddLeads` with the campaign id; pass the subject, body, and follow-up as `custom_variables` (`custom_subject`, `custom_body`, `custom_followup`).
- Mark `<SEQUENCE_STATUS_COLUMN>='sequenced'` and `sequenced_at=now()` on success. On failure, mark `sequencing_failed` and surface the error in the run summary.
DATABASE (must already exist — upstream agents write to it)
- Your leads table is owned by upstream scraper / enricher / qualifier agents. This sequencer adds five columns to it on first run: `<SEQUENCE_STATUS_COLUMN>`, `sequenced_at`, `email_variant`, `email_subject`, `email_body`. The rest of the schema is whatever your pipeline already produces.
- If you don't have a leads table yet, look at the `linkedin-gtm-engager-scraper` blueprint (creates one) and `linkedin-lead-qualifier-enricher` blueprint (enriches + verifies). This sequencer is the closing piece of that pipeline.
- (Optional) `agent_config` — single-row config table for environment-specific values like the Instantly campaign id, when you don't want them in the system prompt.
DELIVERY
- After each run, the agent prints a one-line JSON summary: lead id, name, company, variant used, subject, instantly_status. That's how you'll spot failures from the agent_sessions list at a glance.
GUARDRAILS
- Process exactly ONE lead per run — keeps runs deterministic and easy to monitor.
- Never re-process a lead where `<SEQUENCE_STATUS_COLUMN> != 'pending'`. The `in_progress` lock plus the status filter together prevent double-sends.
- Multiple contacts at the same company is correct — sequence every verified lead regardless of whether a colleague already got their email.
- Never send a raw template — every email must have all placeholders filled.
- The agent does NOT scrape, enrich, or verify emails — that's upstream agents' jobs. This agent assumes "ready" means trustworthy.
When you're ready, start by asking me the ABOUT MY PRODUCT, YOUR DATA MODEL, and EMAIL VARIANTS questions.Paste into OpenClaw to scaffold this agent. Tweak the inputs and goal at the top of the prompt.
How to build it
8 steps. Each one links to the underlying agntdata endpoints — open them in a new tab to inspect parameters and pricing as you build.
Sign up at app.agntdata.dev/dashboard. One key gets you the workspace DB, the meta-agent builder, scheduled agents, and the Instantly connector. Credit-based pricing, no monthly minimum.
On the agntdata dashboard, install the Instantly connector and authorize it against your account. Note your campaign id from the Instantly dashboard — you'll paste it into the system prompt during setup.
This agent doesn't create or own the leads table — it assumes upstream scraper + enricher agents are populating it with rows that carry a status column you can filter on. Tell the blueprint which table to read (default: `leads`), which column to filter on (e.g. `enrichment_status`, `qualification_status`, or just `status`), and which value means "ready" (e.g. 'verified', 'qualified', 'ready'). If you don't have an upstream feed yet, start with the `linkedin-gtm-engager-scraper` and `linkedin-lead-qualifier-enricher` blueprints — together they create + populate a `leads` table that drops right into this sequencer.
The agent reads 1–3 columns on each lead row to decide which email variant to use. Defaults are role + company size. Other valid combos: title + tenure, industry + ACV band, trigger type (job change / funding / signup) + role. Pick the combo that makes the variants meaningfully different.
Write 3–5 variants of your cold email, each tagged with WHEN TO USE (e.g. "mid-market 50+ employees, sales role", "early-stage startup, technical founder"). Each variant has a subject line and a body with personalization tokens like [Name], [company], and [context]. Add one universal follow-up that Instantly will send as a reply.
Click "Build with agnt_" to spin up a builder session prefilled with the workspace_db allowlist, the Instantly integration, and the 6-step workflow. The meta-agent asks you the personalization questions (product, ICP, voice, campaign id, data model, variants), bakes them into the system prompt, and stages the deploy.
Dry-run on a single ready lead. Verify the subject + body look right and that the Instantly push lands. Approve, set the schedule to */5 * * * * in your timezone, and you're live. The next 5-minute tick fires the first real run.
Read the JSON summary on each run. Pull 10 random sequenced rows and read the email_body column — does the variant feel right for that lead? Refine the WHEN TO USE rules in the system prompt until the agent's picks agree with your gut.
Ship this blueprint today
One click spins up a builder session prefilled with this blueprint's spec. We'll ask you a handful of personalization questions, then generate the agent.
Related blueprints
Browse all →Hand any X username to this agent and get back a qualified, ICP-scored lead with a verified email and a resolved LinkedIn profile.
Hand any LinkedIn profile URL to this agent and get back a qualified, ICP-scored lead with a verified email and a website summary attached.
Give it a name + a domain (or a LinkedIn URL, or any combo of identifiers) — it returns a verified professional email or a structured failure. Three-step waterfall: agntdata orchestrator → Exa deep search → verifier. Stateless primitive, called by other agents.