> ## Documentation Index
> Fetch the complete documentation index at: https://docs.hiveku.com/llms.txt
> Use this file to discover all available pages before exploring further.

# AI SDR Reminders

> Tell the AI SDR to ping you later — one-off or recurring — and it takes action when the reminder fires

A **reminder** is a scheduled ping the AI SDR fires to *itself* at a future time. When it fires, the AI SDR re-enters your chat as if you'd just typed the reminder's prompt, and takes whatever follow-up action is appropriate — updating a deal, drafting an email, checking a queue, posting to Slack. Reminders can be one-shot or recurring.

This is the "set it and forget it" side of the AI SDR — instead of you remembering to check back, the agent remembers for you.

<Info>
  Reminders run on the server even when you're offline. If a reminder fires at 2am, it still executes — the results wait for you in the chat history the next morning.
</Info>

## When to use a reminder

Good fits:

* **Follow-up nudges** — "remind me in 3 days to check if Jane replied"
* **Recurring audits** — "every Monday at 9am, summarize at-risk deals"
* **Time-bound triggers** — "when the contract I just sent hits 7 days unsigned, draft a gentle bump email"
* **Queue-polling** — "every 30 minutes, check if my Calendly job is done and let me know"

Not a fit:

* Immediate tasks — just ask the AI SDR now
* CRM activities like call reminders — use a **Task** ([Sales Sequences → task steps](/how-tos/crm-sales-sequences) or the **Tasks** page)
* Calendar invites — create a real calendar event, not a reminder

## Create one

### From the chat

Just ask:

```
Remind me in 2 business days to check if Acme replied to the
proposal email I just sent.
```

```
Every Monday at 9am, give me a briefing on deals that closed
last week and what's due this week. Stop after 8 weeks.
```

```
In 30 minutes, poll the Calendly job with id cgp_abc123 and
tell me if it finished. If it did, stop pinging. Otherwise,
check again in 30 minutes.
```

The AI SDR creates the reminder row, shows a confirmation in chat, and returns you a **reminder id** you can reference later.

### From the UI

Go to [**CRM → Reminders**](https://app.hiveku.com/dashboard/crm/reminders) for a table of every reminder on the account. You can create one manually (**New reminder**) but the natural-language path is usually easier.

## Fields

Each reminder has:

| Field                          | Purpose                                                                                                                        |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------ |
| **prompt**                     | The instruction the AI SDR runs when it fires, verbatim — as if you'd typed it.                                                |
| **label**                      | Short human-readable name for the list UI.                                                                                     |
| **fire\_at**                   | When the *next* fire happens (for one-shot, the only fire).                                                                    |
| **context**                    | Optional JSON payload the agent may need (job\_id, thread\_id, deal\_id) so the prompt doesn't have to embed it.               |
| **repeat\_every\_seconds**     | Null = one-shot. Set to e.g. `604800` (= 1 week) for recurring.                                                                |
| **max\_fires**                 | Cap on how many times a recurring reminder will fire before auto-stopping.                                                     |
| **stop\_if\_output\_contains** | List of phrases. If the AI SDR's output on any fire contains one, the reminder auto-stops. Great for "stop polling when done". |

### Example: polling-until-done

```
Every 30 minutes, check the Calendly job status for
job_id = cgp_abc123. If the status is "completed" or "failed",
say so explicitly in your reply. Otherwise say "still running".
Max 20 fires.
```

Then set:

* `repeat_every_seconds: 1800`
* `max_fires: 20`
* `stop_if_output_contains: ["completed", "failed"]`

The reminder polls every 30 minutes, up to 10 hours, and stops automatically when the job finishes.

## Recurring fires and dedupe

Recurring reminders bump `fire_at` forward by `repeat_every_seconds` after each successful fire, up to `max_fires`. Each fire is deduped independently — a retry of fire #3 won't re-run the successful fire #2.

<Warning>
  Behind the scenes, each fire has its own audit key (`sales_agent.reminder.<id>.fire.<n>`) with a 10-minute dedupe window. That's how recurring reminders know to re-fire on schedule rather than being blocked by the dedupe on a prior fire. You generally don't need to think about this — it Just Works — but if a reminder seems to have fired only once and stopped, check **Reminders → row → Last error** for the diagnostic.
</Warning>

## Manage live reminders

The [**Reminders page**](https://app.hiveku.com/dashboard/crm/reminders) shows all reminders on the account with status, next-fire time, attempts, and any last error. Per row:

* **Pause** — freeze future fires. Status flips to `paused`.
* **Resume** — unfreeze.
* **Cancel** — terminate; row stays for audit but never fires again.
* **Fire now** — force an immediate fire for testing (useful when debugging a prompt).
* **Scanner heartbeat** — small timestamp indicating the last time the cron scanner picked up this row. If it's stale, the scheduler isn't running.

You can also update a scheduled reminder through the AI SDR:

```
Reschedule reminder r_abc123 to fire tomorrow at 9am instead of now.
```

```
Change the prompt on reminder r_abc123 to include the deal id
deal_xyz789.
```

Once a reminder has fired (status `fired`, `failed`, or `cancelled`), the row is immutable.

## What the AI SDR sees on fire

When a reminder fires, the AI SDR gets:

* Your original `prompt`, injected as a fresh user message
* Any `context` JSON merged into its working state
* The full account + user context (so it acts as *you*, not as a generic agent)

So a prompt like *"check if Jane replied to the proposal email"* works — the agent uses your identity and account to look up Jane and the thread.

<Tip>
  Write the prompt as if you were typing it fresh to the AI SDR right then. "Check the deal I sent on Monday" won't work because "Monday" is ambiguous at fire time. Instead: "Check deal deal\_abc123 and report if it's been signed." Or embed the deal id in `context`.
</Tip>

## Troubleshooting

<AccordionGroup>
  <Accordion title="My recurring reminder fired once and never re-fired">
    Look at **Reminders → row → Last error**. If it's blank, the scanner heartbeat may be stale — check that the reminders cron is running. If there's an error like a tool failure, fix the underlying cause (bad id, revoked OAuth, missing permission) and the next scheduled fire will run normally.
  </Accordion>

  <Accordion title="Reminder keeps firing after the task is done">
    Add a `stop_if_output_contains` phrase that matches the "done" case, or lower `max_fires`. Or just cancel the row.
  </Accordion>

  <Accordion title="I missed the chat while the reminder fired. Where's the output?">
    Open the chat for that reminder's session — the reminder's fire shows up as a chat turn with the full AI SDR output. The **Reminders** page also logs the last fire's output snippet.
  </Accordion>

  <Accordion title="Can I schedule a reminder to fire when something happens, not at a time?">
    Not directly. Reminders are time-based. For event-based actions, use the sequence engine's exit triggers or a workflow. A middle-ground: schedule a poller (recurring reminder) that checks the condition every N minutes and stops when satisfied.
  </Accordion>
</AccordionGroup>

## Related

* [AI SDR overview](/how-tos/ai-sdr) — what the sales agent can do
* [Sales Sequences](/how-tos/crm-sales-sequences) — for cadence-based follow-ups (not one-off reminders)
* [Slack notifications workflow](/how-tos/workflow-slack-notifications) — if you want reminder-style pings in Slack instead of the AI SDR chat