Your agents can work here too.

createtodo speaks the interfaces coding agents already use: an MCP server, a JSON-first command line, and an installable skill that teaches the agent the conventions. A todo filed by an agent is the todo you see in the app, in the same workspace, with the same real-time sync. I run my own sessions this way; most of the todos behind the changelog were claimed and closed by an agent.

Everything authenticates with a workspace API key, created in the app under Settings → API keys. Give each agent its own key, read-only if that is all it needs, and it can track work across sessions without a chat client running.

MCP server

@createtodo/mcp covers todos and subtodos, lists, labels, comments, dependencies, workflow states, members, bulk updates, questionnaires, memory and workspace health. Nothing to install: point a Streamable HTTP client at the hosted server with your API key as a Bearer token.

https://api.createtodo.com/mcp
Authorization: Bearer <your-api-key>

In Claude Code, that is one command:

claude mcp add --transport http createtodo https://api.createtodo.com/mcp \
  --header "Authorization: Bearer $CREATETODO_API_KEY"

Prefer a local process? The same server runs over stdio from npm, in any MCP client config:

{
  "mcpServers": {
    "createtodo": {
      "command": "npx",
      "args": ["-y", "@createtodo/mcp"],
      "env": { "API_KEY": "<your-api-key>" }
    }
  }
}

The ct command line

A command line is a cheaper agent interface than a tool-calling protocol: it returns compact text the agent can filter before it costs context. Every ct command prints JSON, so results pipe straight into jq, git hooks, or the agent's own reasoning.

npm install -g @createtodo/cli
ct login                      # approve this device in the browser
ct ready                      # actionable work: open, no blockers, unclaimed
ct claim MZ-123               # assign to yourself and start it, with a session lease
ct close MZ-123               # done; the response lists what it unblocked

Dependencies make the loop self-organizing: ct dep add MZ-124 MZ-123 means MZ‑124 waits on MZ‑123, ct ready hides blocked work, and closing a blocker reports what it freed up. ct health surfaces stale, orphaned and thin todos before they rot, and ct works offline, reads and writes both, and catches up when you're back.

Teach the agent the conventions

The agent also needs to know how to use the tools well. One command installs a skill file with the commands and the rules that matter: reference todos by identifier, never invent one, write a real description, and flag human decisions instead of guessing.

ct skill install claude-code   # also: codex, cursor, gemini, universal

For Claude Code there is session priming on top: ct init wires ct prime to run on session start, so the agent opens every session already knowing what is in progress, what is ready, and what the rules are.

Questions and memory

When an agent reaches a decision that is yours to make, it can ask instead of guessing: ct ask files a questionnaire against a todo (single or multiple choice, free text), you answer it on the Questions page in the app, and ct answers reads the result back in a later session. The exchange is recorded on the todo's timeline.

What an agent learns can outlive the session: ct remember stores a workspace fact, decision or convention, and ct memories searches them. The same memory is reachable from the MCP server, and you can read and prune it under Settings → Memory.

Whatever an agent does is attributed to it: comments and timeline rows show which agent acted, and through which member's key, so a shared workspace never has to wonder who moved what.

Create an API key in the app, hand it to your agent, and watch the todos move. MCP server docs, command line docs.