Build a sales-followup agent that never forgets

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.

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.

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.

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".

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.

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.

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.

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.

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>".

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.

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.

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.

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.

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.