MCP setup

1. Connect over OAuth (recommended)

Done is a full OAuth 2.1 authorization server for its MCP endpoint, so clients that speak OAuth — claude.ai, ChatGPT connectors, and Claude Desktop — connect themselves with no token to copy. Add Done as a custom connector by URL only:

1. Go to Settings → Connectors → Add custom connector.
2. Set the remote MCP server URL to https://trydone.app/mcp and click Add.
3. Click Connect. The client discovers Done's OAuth endpoints, registers itself, and sends you to Done to sign in and approve access.
4. Approve, and the connector is live — scoped to your account alone.

2. Or use a bearer token

For clients configured by hand (or a script), generate a token instead. Open the Account panel in the bottom-left of the sidebar and generate an MCP token — it's shown once, so copy it somewhere safe. You can mint a full-access token, a read-only one, or one scoped to a single project. Then point a client at the endpoint:

{
  "mcpServers": {
    "done": {
      "url": "https://trydone.app/mcp",
      "headers": { "Authorization": "Bearer <your-generated-mcp-token>" }
    }
  }
}

On claude.ai you can also paste that same Authorization: Bearer <token> as a request header under a custom connector's Advanced settings. Either way, an agent using the token only ever sees and edits what the token is scoped to.

3. Tools available to the agent

The MCP server exposes workflow-shaped tools, not raw CRUD:

Prompts & resources

Beyond tools, the server is fully MCP-native: it also exposes prompts and resources, so a client can offer ready-made workflows and attach live data as context.

• prompts/list · one-line templates that map to real workflows, so a client can surface them as slash-commands:
  • plan_my_day — Draft a realistic, prioritized plan for today from my open tasks.
  • work_next — Claim and work the single highest-priority ready task.
  • daily_review — Summarize what got done, what's overdue, and what to focus on next.
  • groom_board — Find the open work that quietly died and propose what to do about each — proposes only.
  • answer_backlog — Pick up the tasks whose parked questions I've already answered.
  • prep_meetings — Match today's calendar events to the tasks they're about, and prep each one.
  • triage_task — Assess one task and either plan it or flag what's blocking it.
• resources/list · read-only views a client can attach: done://digest, done://queue, and a done://task/<id> per open task. Scoped tokens only ever see their own project.

A typical agent run

get_digest → list_open_decisions → next_task → get_task → work, ticking check_criterion as each condition is met → comment_on_task once with the write-up → propose_completion. You review results in the task's thread and stay the accountable owner.

Asking without stalling

An agent that hits a genuine fork — spending money, anything outward-facing, anything irreversible — shouldn't guess, and shouldn't sit there either. It calls ask_decision and moves on: the task drops out of its queue as needs_input, you answer in the Control Room or straight from a Slack DM, and the task re-enters the queue with your answer attached — so the next run reads the answer instead of re-deriving the question.

Every question carries the agent's own recommendation and the reasoning behind it, so answering is usually one click rather than a writing task. Answering is not an approval: it hands the task back and never closes anything. Only one blocking question can be open per task, which keeps a decision inbox from becoming the comment feed it replaced.

This is what makes an overnight routine worth leaving running. Without it, the first ambiguity at 3am stops the whole night; with it, that one task parks and the agent keeps working the rest.

Run it on a schedule

Done ships no agent and no scheduler. It's a passive queue — it can't reach out and start a run — so to have your tasks worked unattended, something outside Done has to wake up on a cadence and call it. Every MCP client connects the same way; only the scheduling differs:

Whichever path you take, this is the prompt to give it:

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 the Control Room.
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 Account → Notifications, and call end_run when you finish.

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

Each run it proposes a plan for any substantial task and waits, and executes whatever you've approved in the Control Room since last time. You approve; the agent does the work — you never have to kick off a run by hand. The same setup is a click away in the Account panel (“Put an AI agent to work on your queue”).

Notes

• Connect over OAuth (clients that discover /.well-known/oauth-authorization-server) or with a long-lived per-account bearer token generated in-app — both work against the same endpoint.
• Every token and grant is scoped to a single account; there is no cross-account or global token. Bearer tokens can be further narrowed to read-only or a single project.
• Regenerating or revoking a token invalidates it immediately.
• The Free plan includes 100 agent (MCP) calls a month; Pro and Teams are unlimited. See pricing.