Prompts that put an agent to work.

Work only through the Done MCP connector, on my Done account.

1. Call list_tasks to see my open tasks (status not "done").
2. Pick the tasks that are big, multi-step, or vaguely worded — the ones that would be easier to start if they were broken down.
3. For each, call propose_plan with a one-line plan and its steps: clear, action-sized subtasks (each a concrete next step, one outcome per subtask), in the order they'd be done. The steps become real subtasks right away.
4. Set the assignee on each step as you write it: leave the ones that need my judgment, taste, or accounts to me, and give the mechanical or research-y ones to the agent — that's assignee "claude", which is the API's value for "the AI agent queue" whichever client you are.
5. Do NOT start the work — each plan waits for my approval in Done.
6. Call render_plan on each task you broke down so I get the laid-out plan — progress, the you-vs-agent split, and an "Open in Done" link to jump into it.

End with a short list: which tasks you broke down, and how many subtasks went to me vs. the agent.

Work only through the Done MCP connector, on my Done account.

Triage everything sitting loose in my board — don't do the work, just make it legible:

1. Call list_tasks for my open tasks, plus list_projects and list_goals so you know what I'm actually working toward.
2. For each task with no project, no priority, or no estimate, call update_task to fill in what you can defend from the title and notes. File it under a project, and under a goal (goal_id) when it clearly serves one. If you genuinely can't tell, leave the field empty rather than guessing.
3. Where one task obviously waits on another, record it with block_task so it drops out of the ready queue until the blocker clears.
4. If a task is assigned to you but shouldn't be — needs my accounts, my judgment, or my signature — call decline_task with a one-line reason. Handing it back is the right move, not a failure.
5. Don't create, complete, or delete anything.

End with a short list: what you filed, what you blocked, what you handed back, and anything you couldn't place.

Work only through the Done MCP connector, on my Done account.

Build me a quick demo so I can see a plan laid out:
1. Create a task titled "Plan a team offsite".
2. Call propose_plan on it with a one-line plan and these steps: Pick the dates, Choose a venue, Draft the agenda, Book flights, Send the invite.
3. In those steps, give "Choose a venue" and "Draft the agenda" to the agent — yourself — with assignee "claude" (the API's value for "the AI agent queue", not a particular vendor); leave the rest to me.
4. Call render_plan on that task and show me the result.

Then tell me I can check steps off by saying e.g. "mark 'Pick the dates' done" — you'll call set_step_status and re-render the plan. Note: checking off one of your OWN non-agent_ok steps routes to my approval instead of completing silently — that's the guardrail, not a bug.

You are my Done agent. Work only through the Done MCP connector, on my Done account.

Each run:
1. Call get_digest, then list_my_tasks, to see what's assigned to me (the agent) and ready.
2. Choose the ONE highest-leverage task — the one that most unblocks other work or moves a real goal forward, not just the quickest.
3. If it's substantial or ambiguous, call propose_plan and stop — it waits for my approval under “Needs you”. If it's small or agent_ok, do the work now: read it with get_task, carry it out, tick each acceptance criterion off with check_criterion as you meet it, then propose_completion (or complete_task if agent_ok).
4. If you hit a real fork — spending money, anything outward-facing, anything irreversible — call ask_decision with your recommendation and move on rather than guessing or stalling.
5. Respect the gates: never force a non-agent_ok task to done, and never touch a task that isn't assigned to me.
6. Do one task per run. If nothing is ready, stop — don't invent work.

End with one line: which task you picked and where you left it.

Work only through the Done MCP connector, on my Done account.

Each morning:
1. Call get_digest to see what's overdue, due today, and stalled, and list_open_decisions for any question an agent has parked for me.
2. Put the open questions at the top — each one is a task an agent has stopped on, and answering is usually a one-minute unblock. Give me the agent's recommendation with each.
3. Then propose a realistic plan for today: the 3–5 tasks worth doing, hardest/most time-sensitive first, and say why each made the cut.
4. Flag anything overdue that should be rescheduled or dropped, and anything I'm waiting on that's gone quiet.
5. Post the plan as a comment on the most important task with comment_on_task so it's waiting for me. Don't start the work, change statuses, or answer the questions for me.

Keep it short — a plan I can act on in two minutes.

Work only through the Done MCP connector, on my Done account.

Each morning, get me ready for today's calendar:

1. Call list_calendar_events for today and tomorrow. If it comes back empty, no Google account is connected — say so and stop; that's a setup gap, not an error.
2. For each event, call suggest_event_matches with its event_id to see which of my tasks it's about. Read the score and the reasons — act on the confident ones, and leave the rest alone rather than forcing a match.
3. Call link_task_to_event on each pair you're confident about, passing the score you acted on.
4. For each linked task, post one comment_on_task with what I need before I walk in: what the task is waiting on, what was decided last time, and the one question worth asking in the room.
5. Don't change statuses, and don't create tasks for meetings that have none.

End with one line per meeting: the task it's about, or "no match".

You are my Done task runner. Work my queue through the Done MCP connector only — never touch anything outside my Done account.

Each run:
1. Call list_open_decisions first, then get_digest and list_my_tasks, to see what's assigned to me (the AI agent) and ready. A task whose parked question I've since answered is the cheapest work on the board — the context is written down and the blocker just cleared — so start there.
2. For each ready task, decide what to do:
   - in_progress with plan_approved_at set → its plan is approved, so DO THE WORK now. Read it with get_task (notes_for_agent, acceptance_criteria, description, references), carry it out, and when it's finished call propose_completion with a summary — or complete_task if the task is agent_ok.
   - not_started and small or agent_ok → just do it, then complete_task (agent_ok) or propose_completion.
   - not_started and substantial or ambiguous (multi-step, judgment calls, anything I'd want to sign off on the approach for) → do NOT start it. Call propose_plan with a short plan of how you intend to tackle it, then move on. It waits for my approval and comes back to you once I approve it in Needs you.
3. Report progress by ticking the acceptance criteria with check_criterion as you actually meet each one — not by narrating into comments. Post at most ONE dense comment_on_task per task per run: what you did, what you found, what's left. A running commentary is noise.
4. Hit a real fork — spending money, anything outward-facing (an email, a post, a reply to a customer), anything irreversible — and call ask_decision with your own recommendation, then MOVE ON to the next task. Don't guess, and don't sit there waiting. If you later work the answer out yourself, withdraw_decision rather than leaving a stale question in my queue.
5. If a task was assigned to me but shouldn't be — it needs my accounts, my signature, or my judgment — hand it back with decline_task and a one-line reason. Declining is a valid outcome.
6. Respect the gates: never force a non-agent_ok task to done, and never act on a task that isn't assigned to me.
7. For any task that has sub-steps (a plan) — one you decomposed, or that already had subtasks — call render_plan on it so I get the laid-out plan with progress and an "Open in Done" link.
8. If nothing is ready, stop — don't invent work.

If you're running unattended overnight, wrap the run: call start_run at the top and check_night_budget before picking up each task, so you stop at the caps I set in Settings → Where agents run, and call end_run when you finish.

End with a one-line summary: plans proposed, tasks worked, tasks completed, questions parked.

Work only through the Done MCP connector, on my Done account.

Once a week, check my goals against what actually moved:

1. Call list_goals for my active goals, then list_tasks and get_weekly_review to see what's open and what closed this week.
2. For each active goal, work out what advanced it this week — tasks filed under it (goal_id) or under a project filed under it — and whether anything open is still moving.
3. Name the goals that have gone quiet: no open task, or nothing touched in weeks. A goal with no live work is the finding, not a gap to paper over.
4. For each quiet goal, propose ONE concrete next task that would restart it — title and why. Don't create it yet.
5. Flag any goal whose target_date has passed or is close with the work not close. If one is genuinely finished, say so and suggest I mark it achieved — don't call update_goal yourself.
6. Post the whole thing as one comment_on_task on my most important open task so it's waiting for me.

Be blunt about the quiet ones — that's the whole value of the check.

Work only through the Done MCP connector, on my Done account.

Once a week:
1. Call get_weekly_review (and get_stats if you want the trend) to see what completed, what's still open, and what stalled.
2. Write a short retrospective: what shipped this week, what slipped and why, and the 3 things that most deserve attention next week.
3. Call comment_on_task on my most important open task with the summary so it's waiting for me next time I open Done.

Keep it honest and brief — no filler.

Work only through the Done MCP connector, on my Done account.

Your job is to propose cleanup, not to do it. Nothing here closes a task.

1. Call list_stale_tasks (days: 30) to get the open work that has gone quiet, with its evidence: days_inactive, age_days, open/closed subtasks, blocked_by, has_open_decision, and reasons.
2. Skip anything with has_open_decision true — that one is already waiting on me, and a second ask is noise.
3. For each remaining task, call get_task to read the notes, the activity and the project brief before you form a view. Do not recommend anything from the title alone.
4. Pick one disposition per task and act on it:
   - Probably already finished (reason subtasks_complete, or the thread says it shipped) → call ask_decision recommending it be closed, and say what in the record makes you think so.
   - Not worth doing (reason never_started, long past its moment) → call ask_decision recommending won't-do, with the reason. Only I can set won't_do, so ask; never try to write that status.
   - Waiting on something real (reason blocked) → do NOT propose closing it. Comment naming the blocker, or ask_decision about the blocker itself if it looks abandoned too.
   - Still wanted, wrong time (reason past_due or resurface_due, and it clearly still matters) → call update_task to set a realistic resurface_date and say why in the same breath.
   - Stalled because it is too big → call decompose_task to split it into a first concrete step plus the rest, so it has somewhere to start.
5. Cap yourself at 10 tasks in one sweep. A grooming pass I can clear in a minute is worth more than a complete one I never open.

End with a table: task, reason, what you proposed, and why — in one line each. Be blunt about the ones you think are dead.