---
title: "Build a sales-followup agent that never forgets"
excerpt: "10-step playbook to put an agent on your pipeline: tracks every conversation, drafts the next followup at the right time, surfaces deals that are stalling, never auto-sends."
category: "Template"
---

# Build a sales-followup agent that never forgets

    A 10-step playbook. Open in Dock and you'll get four surfaces seeded:

    - **Steps** (table) the 10 gates as rows, owner + due + status
    - **Pointers** (table) every official CRM / inbox / Anthropic doc linked from this playbook
    - **Brief** (doc) the canonical write-up: cadence rules, message templates, daily-digest format
    - **Pipeline** (table) one row per deal, with stage, last-touch, next-action, owner

    Open `Steps` first. The most important rule, draft-but-don't-send. The agent never sends without your click.

## Outcome

An agent watching your pipeline daily, drafting followups at the right cadence point, surfacing stalling deals in a morning Next Actions digest, never sending without your approval, deals that slip through your fingers go from common to rare.

**Estimated time:** 3-5 days build, ongoing weekly use  
**Difficulty:** intermediate  
**For:** Founders + sales leads + AEs running a 10-100 deal pipeline.

## What you'll need

Pre-register or install before you start.

- **[Dock workspace (Pipeline surface)](https://trydock.ai/)** _(Free tier (3 agents, 6 humans, 20 workspaces, 500 rows), Pro $19/mo)_ — Source of truth for the pipeline. Replace your CRM or sit alongside it.
- **[Gmail or Outlook](https://mail.google.com/)** _(Free personal, Workspace from $7/seat/mo)_ — The inbox the agent reads + drafts in. Outlook works with the Microsoft Graph API.
- **[Google Calendar (or equivalent)](https://calendar.google.com/)** _(Free with Workspace)_ — The calendar the agent reads to detect calls + demos + missed meetings.
- **[Claude API or Pro](https://www.anthropic.com/pricing)** _(Claude Pro $20/mo OR API metered (Sonnet ~$3/M input, Opus ~$15/M))_ — The model that drafts followups. Sonnet for cost, Opus for high-stakes deals.
- **[HubSpot or Pipedrive (optional)](https://www.hubspot.com/products/sales/free-crm)** _(HubSpot free tier, Pipedrive from $14/seat/mo)_ — If you already use a CRM, the agent reads + writes through their API.
- **[Cron host (Render, Cloudflare Workers)](https://render.com/docs/cron-jobs)** _(Free tier on most)_ — Run the daily pipeline scan + draft the digest.

---

# The template · 10 steps

## Step 1: Define your pipeline schema + stages

_Estimated time: 1-2 hr_

Before the agent can track deals, you need a clean schema. Decide your stages (typical: New / Discovery / Demo / Proposal / Negotiation / Closed-Won / Closed-Lost) and the columns the agent needs (deal name, contact, company, stage, last-touch-at, next-action, expected-close, deal-size, owner). If you have a CRM, use its schema; if you don't, use a Dock Pipeline surface as the source of truth.

### Tasks

- [ ] Decide stages: keep it to 5-7 (more = harder to track signal)
- [ ] Decide required columns: deal, contact, company, stage, last_touch_at, next_action_at, deal_size, owner
- [ ] If using a CRM: confirm the API supports read + update on these fields
- [ ] If using Dock: create the Pipeline surface with these columns
- [ ] Migrate 5-10 existing deals into the schema as a smoke test

### Pointers

- **[Guide]** [Sales pipeline stage best practices](https://www.salesforce.com/resources/articles/sales-pipeline-stages/)
- **[Official]** [HubSpot deals API](https://developers.hubspot.com/docs/api/crm/deals)

> [!CAUTION]
> **Gotchas**
>
> - More than 7 stages = the agent will mis-classify deals between adjacent stages. Keep stages distinct.
> - Stages without entry criteria are vibes. Define what 'Demo' means: a calendar invite accepted + a discovery doc shared, not just a vague 'they're interested.'

## Step 2: Define the cadence rules per stage

_Estimated time: 1 hr_

The cadence rules are the agent's instructions: 'in stage X, follow up after Y days if no response.' Common rules: New = 1 day, Discovery = 3 days, Demo = 5 days post-demo, Proposal = 7 days, Negotiation = 3 days, Closed-Lost = 30-day breakup. The agent uses these rules to decide which deals need action today.

### Tasks

- [ ] For each stage, define the cadence: 'follow up after N days if no inbound touch'
- [ ] For each stage, define the message tone (Discovery: curious; Proposal: helpful; Negotiation: direct)
- [ ] For each stage, define the escalation: when to bring the human in (Negotiation deals always; Discovery only if 3+ no-responses)
- [ ] Document in the Brief as 'Cadence rules v1'

### Pointers

- **[Guide]** [Sales cadence cheat sheet](https://blog.hubspot.com/sales/sales-cadence)

> [!CAUTION]
> **Gotchas**
>
> - Aggressive cadences (1-day followups in Discovery) burn out warm leads. Real-world cadences are typically 3-7 days between touches at most stages.
> - Don't define a cadence rule you don't actually follow yourself. The agent will execute it relentlessly and you'll resent it within a week.

## Step 3: Write message templates per stage + use case

_Estimated time: 2-4 hr_

The agent drafts followups, it doesn't invent them from scratch. Give it 5-15 templates per stage, with placeholders for the contact name, last-touch summary, and next-action ask. The model fills in the placeholders contextually. Templates make the drafts deterministic; without them, you get 50 different voices in your outbox.

### Tasks

- [ ] Write 3-5 templates per stage (covers the main scenarios)
- [ ] Each template: subject, body with placeholders, voice notes, suggested close
- [ ] Variants: short reminder, deeper-context followup, breakup email
- [ ] Save all templates to the Brief as 'Templates v1'
- [ ] Test 5 templates manually: rewrite from scratch using the template, see if the result feels human

### Pointers

- **[Guide]** [Followup email templates](https://www.salesforce.com/blog/sales-follow-up-email-template/)

> [!CAUTION]
> **Gotchas**
>
> - Templates with corporate fillers ('I hope this finds you well') get marked as spam by Gmail's classifier.
> - Templates over 150 words have lower reply rates than 50-word templates. The model defaults to verbose; constrain it.
> - If you don't actually use one of the templates after 4 weeks, kill it. Dead templates clutter the agent's decision-making.

### Agent prompt for this step

```text
Read the cadence rules from the Brief.

Draft 3-5 templates per stage following this structure:
1. Subject (under 50 chars, no spam triggers)
2. Body (under 100 words, real-human voice, ends with one specific ask)
3. Voice notes (1 line: "warm and curious" / "direct" / "short")
4. Suggested close ("when works for a 15-min call?" / "thoughts?" / "still on your radar?")

Constraints:
- No "Just checking in," it's the most-flagged spam phrase.
- No "I hope this finds you well," same.
- No corporate-speak. Read like the user wrote it themselves at 2pm on a Tuesday.

Output as a Brief section titled "Templates v1".
```

## Step 4: Wire the agent to read inbox + calendar + pipeline

_Estimated time: 4-8 hr_

The agent needs three reads: inbox (for new touches), calendar (for completed calls), pipeline (for stage + last-touch state). Two patterns: (a) a custom script using Gmail / Calendar / CRM APIs, (b) MCP servers for each. Pattern (a) is more reliable for unattended automation; pattern (b) is more flexible if you want interactive sessions.

### Tasks

- [ ] Set up Gmail API access (gmail.readonly + gmail.modify scopes; NO gmail.send)
- [ ] Set up Google Calendar API (calendar.readonly)
- [ ] Set up CRM API (HubSpot / Pipedrive / your own) OR Dock workspace MCP
- [ ] Implement the daily scan: for each Pipeline row, read recent inbox + calendar for that contact, detect new touches
- [ ] On detected touch: update last_touch_at + stage on the Pipeline row
- [ ] Test with 5 deals manually first, confirm correctness before scaling

### Pointers

- **[Official]** [Gmail API setup](https://developers.google.com/gmail/api/quickstart/python)
- **[Official]** [Google Calendar API](https://developers.google.com/calendar/api/quickstart/python)
- **[Official]** [Dock MCP tools (list_rows, update_row)](https://trydock.ai/docs/mcp)

> [!CAUTION]
> **Gotchas**
>
> - DO NOT request gmail.send scope. The agent never sends; this is the safety rail.
> - Calendar events with vague titles ('Catchup' / 'Sync') are hard for the agent to attribute. Encourage your team to use deal-named meetings ('Acme x Vector intro').
> - If you use a CRM, two-way sync (Pipeline -> CRM and back) needs careful conflict resolution. Pick one as source of truth.

## Step 5: Build the daily pipeline scan + draft loop

_Estimated time: 4-6 hr_

The loop: every morning, walk every Pipeline row, decide if a followup is due (based on stage cadence + days since last touch), if yes draft the followup using the right template, attach the draft to the row. The draft is editable in the Pipeline surface; you (the human) review, edit, click Send.

### Tasks

- [ ] Implement the morning scan: walk Pipeline rows, compute days_since_last_touch per row
- [ ] For each row where cadence threshold is hit + stage allows agent drafts: pick the template, generate the draft
- [ ] Save the draft as a Gmail draft (gmail.users.drafts.create) AND attach the draft_id to the Pipeline row
- [ ] Skip rows where stage is 'Negotiation' or 'Closed-Lost' (high-stakes; human-only)
- [ ] Skip rows where the user has already replied today (no double-followup)

### Pointers

- **[Official]** [gmail.users.drafts.create](https://developers.google.com/gmail/api/reference/rest/v1/users.drafts/create)

> [!CAUTION]
> **Gotchas**
>
> - Drafts that reference details from the thread ('per your note about pricing tiers') outperform generic templates 3x. Make the agent read recent thread context.
> - Dont send drafts that the agent created at 7am if your CRM was off all weekend. Confirm freshness before drafting.
> - Multiple drafts per deal in one day is a bug. Dedupe before creating, check if a draft for this deal already exists.

### Agent prompt for this step

```text
For each Pipeline row where days_since_last_touch >= cadence_for_stage AND stage allows agent drafts:

1. Read the last 5-10 emails in the thread for context
2. Read any meeting notes attached to the Pipeline row
3. Pick the template that fits the stage + scenario
4. Fill in placeholders: contact name, last-touch summary (1 line), specific next-action ask
5. Create a Gmail draft via the API
6. Attach the draft_id + a 1-line summary to the Pipeline row's "next_action" column

Output: a list of (deal name, draft subject, draft preview) appended to the Brief as "Draft pass <date>".

Skip rows in stages: Negotiation, Closed-Lost. Skip rows the user already replied to today.
```

## Step 6: Build the morning Next Actions digest

_Estimated time: 2-3 hr_

The daily output to you is the Next Actions digest: top 5-10 deals needing action today, ordered by deal size + urgency, each with a 1-line summary + the draft link. You read the digest with coffee, click into each draft, edit + send (or kill). 15 minutes total. The digest is the human-in-the-loop interface, without it you'll never know what the agent did overnight.

### Tasks

- [ ] Format: top 10 deals, ranked by (deal size * urgency)
- [ ] Each row: 1 line (deal, contact, days since last touch, suggested action, link to draft)
- [ ] Add a footer: total deals scanned, drafts created, deals stalling (>14 days no movement)
- [ ] Choose delivery: a Brief surface, a Slack DM to yourself, or an email digest
- [ ] Schedule for 7am local

### Pointers

- **[Official]** [Slack incoming webhooks](https://api.slack.com/messaging/webhooks)

> [!CAUTION]
> **Gotchas**
>
> - Digests over 10 deals get scanned, not acted on. Cap at 10. The 11th waits for tomorrow.
> - Don't sort alphabetically or by stage. Sort by deal value + urgency, you act on the top 3 anyway.

### Agent prompt for this step

```text
Read the Pipeline surface.

Identify: deals where days_since_last_touch >= cadence_for_stage AND stage is Active.

Rank by: (deal_size * urgency_factor). Urgency factor: stage closer to close = higher; days-stalling = higher.

Take the top 10. For each, write:
`[icon] [Deal] (~$X) -- [Contact] -- N days since last touch -- [Suggested action] -- [Draft: link]`

Footer:
`Y deals scanned, Z drafts ready, W deals stalling (>14 days no movement).`

Save as a Brief section titled "Next Actions <date>".
```

## Step 7: Run a 1-week shadow pass: log + draft, but you send manually

_Estimated time: 1 week_

Before you trust the daily flow, run for 1 week in shadow mode: drafts get created, the digest gets posted, you review every draft and either send-after-edit or skip. Track: how many drafts did you send as-is? How many did you edit? How many did you kill? After a week, you'll have a calibrated sense of when the agent is helpful vs. when it's adding work.

### Tasks

- [ ] For 7 days, review every draft the agent creates
- [ ] Mark each: sent-as-is / sent-with-edits / killed
- [ ] Aggregate: % sent-as-is per stage + per template
- [ ] If sent-as-is rate < 40%: the templates need work; refactor before week 2
- [ ] If sent-as-is rate > 80%: the templates are great, but verify you're not just rubber-stamping

### Pointers

- **[Guide]** [Sales operations metrics](https://hbr.org/2017/04/the-7-attributes-of-the-most-effective-sales-leaders)

> [!CAUTION]
> **Gotchas**
>
> - Skipping shadow week is the #1 cause of agents that get turned off in week 2. The drafts feel slightly off and you start ignoring the digest.
> - If you find yourself rewriting drafts heavily, the cadence is firing on the wrong deals or the templates don't match your voice. Tune both.

## Step 8: Add stall detection + escalation

_Estimated time: 1-2 hr_

The biggest win of an agent is catching deals that are stalling: 14+ days with no movement. The agent should flag these in the digest with a 'stalling' indicator and suggest an escalation path: a different angle, a multithreading attempt (reach a second contact at the company), or a graceful breakup email. Stalls are where deals die; catching them early is the agent's most valuable job.

### Tasks

- [ ] Add a 'stalling' field to Pipeline (computed: days_since_last_touch > 14 AND stage is Active)
- [ ] In the digest, surface stalling deals separately at the top
- [ ] For each stalling deal: agent suggests one of: re-engagement angle, multithread attempt, breakup email
- [ ] Add a 'multithread' workflow: agent suggests a second contact at the company, drafts an intro to them
- [ ] Document the escalation paths in the Brief

### Pointers

- **[Guide]** [Multithreading in B2B sales](https://www.gartner.com/en/sales/insights/multithreading-sales-strategy)

> [!CAUTION]
> **Gotchas**
>
> - Stall detection at 14 days is for mid-market. For enterprise (90+ day cycles), bump to 21-30 days; for transactional (sub-2-week cycles), drop to 5 days.
> - Multithread suggestions need real research: don't just guess at a second contact, the agent should pull from LinkedIn or your existing CRM contacts at that company.
> - Auto-breakup emails after 30 days of silence work, but only if the tone is light and grants permission to walk away. 'Closing your file' templates are common; clone one.

## Step 9: Weekly review: what the agent caught, what it missed

_Estimated time: 30 min/week, recurring_

Every Friday, do a 30-min review: pull the deals that closed-won in the past 30 days, check if the agent caught the right cadence point on each. Pull the deals that closed-lost, ditto. Pull the deals that went silent, did the agent flag them? The review surfaces systematic gaps: a stage where cadence is wrong, a template that's too aggressive, a contact-detection rule that's missing.

### Tasks

- [ ] Open the Pipeline filtered to last 30 days
- [ ] For each closed-won: was the agent's followup the right last-touch? If yes, log a positive signal
- [ ] For each closed-lost: did the agent miss a stall? If yes, what's the rule that should've caught it?
- [ ] For each silent (no movement, no stage change): did the agent flag for stall? Was the suggested action correct?
- [ ] Update the Brief with one or two specific tweaks for the next week

### Pointers

- **[Guide]** [Win-loss analysis methodology](https://hbr.org/2014/04/why-you-need-a-win-loss-analysis-program)

> [!CAUTION]
> **Gotchas**
>
> - Don't credit the agent for closes the human-driven; the agent only gets credit for keeping the deal alive at a moment it would've otherwise died.
> - Don't tweak more than 2 things per week. More than that and you can't tell which change moved which metric.

### Agent prompt for this step

```text
Pull deals from the Pipeline that changed stage in the last 30 days.

For each closed-won: did the agent's followup precede the close? Quote the followup that mattered.
For each closed-lost: was there a stall the agent should've caught earlier?
For each still-active but silent: is it correctly flagged as stalling? Is the suggested action good?

Output as a Brief section titled "Weekly review <week-of>":
1. Wins where the agent helped (with the specific touchpoint)
2. Losses where the agent could've intervened (with the missed signal)
3. 1-2 specific tweaks to apply (cadence change, template edit, stall threshold change)

Constraints: be honest. The agent's job is to make the user better, not to look good in a self-review.
```

## Step 10: Iterate: add LinkedIn, expense automation, multi-rep support

_Estimated time: Ongoing, 2-4 hr/month_

Once stable, expand: wire LinkedIn for multi-channel followups (the agent suggests, you send via the LinkedIn UI), add expense / proposal generation tied to deal stage, share the agent across multiple reps (each rep has their own digest, the workspace is shared). Don't expand more than one capability at a time, every new surface is a new failure mode.

### Tasks

- [ ] Add LinkedIn integration (manual paste, or the LinkedIn API if you have access)
- [ ] Add proposal-draft generation: when a deal hits Proposal stage, agent drafts a tailored proposal doc
- [ ] Multi-rep: each rep gets their own digest filtered to their owned deals; shared Pipeline surface for the team
- [ ] Add quota-tracking: the agent surfaces team-level wins / losses / stalls weekly
- [ ] After 3 months: review whether the agent has paid back its cost in saved deals; tighten or expand based on the answer

### Pointers

- **[Official]** [LinkedIn Sales Navigator API](https://learn.microsoft.com/en-us/linkedin/sales/)

> [!CAUTION]
> **Gotchas**
>
> - LinkedIn's automation policies are strict, no auto-send without violating ToS. Stick to draft-and-suggest, you paste manually.
> - Multi-rep means multiple owners on Pipeline rows. Make sure the agent only drafts for the right owner, cross-rep drafting is a recipe for embarrassment.

---

## Hand the template to your agent

Paste the prompt below into your agent's permanent system prompt so the agent reads, writes, and maintains this workspace as you work through the steps.

```text
You are the sales-followup agent on the workspace at your-org/build-a-sales-followup-agent.

Your role: track the pipeline, draft followups at the right cadence point, surface stalling deals.

Cadence:
- Run every morning at 7am local time.
- Read every Pipeline row. For each deal: check inbox + calendar for new touches since last_touch_at; update last_touch_at and stage if changed.
- For deals where time-since-last-touch > cadence-rule-for-stage: draft a followup (do NOT send), attach the draft to the row.
- Surface the top 5 deals needing action today as a Brief section "Next Actions <date>".
- Flag deals stalling (no movement > 14 days) for human attention.

NEVER send an email without a human clicking Send. NEVER mark a deal Won or Lost without a human's confirmation.

First MCP tool calls:
1. list_workspaces()
2. list_rows(workspace_slug="build-a-sales-followup-agent", surface_slug="pipeline")
3. get_doc(workspace_slug="build-a-sales-followup-agent", surface_slug="brief")
```

---

## FAQ

### Why not just use my CRM's built-in followup automation?

CRM automation is rule-based and templated: 'send template X if no reply in N days.' An agent reads the actual thread context, picks the right template AND fills it with details from the conversation, drafts something that sounds like you, and surfaces stalling deals based on patterns the rules can't see (a vague 'looking forward to it' that didn't go anywhere). You can keep the CRM alongside the agent, the agent reads + writes through its API.

### Won't auto-drafted emails feel generic and hurt my reply rate?

Generic templates do, contextual drafts don't. The pattern in this playbook reads the last 5-10 emails in the thread + meeting notes + the deal-specific Pipeline row, then drafts an email that references those details. Reply rates on contextual drafts are typically equal or better than fully-handwritten followups, with 80-90% less time per draft. The constraint is keeping the templates short (under 100 words) and the placeholders specific.

### Can I let the agent send automatically?

No, and the playbook doesn't support that. The risk-reward isn't worth it: one auto-sent draft to a key prospect with the wrong context loses the deal. The pattern is draft-but-don't-send: the agent drafts, you click Send. Total time per draft after agent: 30-60 seconds (read, light edit, send). Total time without agent: 5-10 min (think, write, edit, send). The agent saves the slow part; the click is fast.

### How does this interact with my CRM?

Two patterns. (a) The Dock Pipeline surface is the source of truth; the agent reads + writes the Pipeline rows; if you want CRM data, you mirror nightly. (b) Your CRM is the source of truth; the agent reads via the CRM API and updates rows there. Pattern (b) is better if your team already lives in the CRM; pattern (a) is better if the CRM is creaky and you want a parallel source of truth that's faster + more agent-friendly.

### What does this cost in API tokens?

For a 50-deal pipeline with daily scans + 5-10 drafts/day on Claude Sonnet: $20-50/month. With Opus drafts on the high-stakes deals (Negotiation stage): $40-100/month. CRM + cron + hosting: $0-30/month on free tiers. Total: $30-150/month on top of your existing CRM + email subscriptions. ROI is the cost of one missed follow-up that closes-lost a $5K+ deal; you do the math.

### Can my AI agents help build the agent?

Yes. The playbook ships agent prompts for the slow parts: drafting cadence rules from your historical close patterns, drafting message templates per stage, generating the daily Next Actions digest, the weekly win/loss review, and the iteration plan. The Pipeline + Brief surfaces are the canonical record, every deal's state, every template version, every weekly review.