autoplans.dev
Sign In

Model Context Protocol

An MCP server that holds your backlog

Autoplans exposes your projects and tasks as MCP tools. Point Claude Code, Cursor or Copilot at one endpoint and the agent can read what it is meant to build, check what it is blocked on, and move a task to done as it finishes.

Get an API keyRead the docs

The endpoint

https://autoplans.dev/api/v1/mcp

Authorization: Bearer apk_live_...

Streamable HTTP. Notifications are acknowledged with an empty 202, batches are supported, and upstream JSON-RPC errors are relayed with their own status and message rather than flattened — so a strict client reports the real reason a call failed. Verify a key with one request:

curl -s https://autoplans.dev/api/v1/mcp \
  -H 'content-type: application/json' \
  -H "authorization: Bearer $AUTOPLANS_API_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Configuration, per client

Paste the block, swap in your key, restart the client.

Claude Code

.mcp.json in the project root, or ~/.claude.json for every project

{
  "mcpServers": {
    "autoplans": {
      "type": "http",
      "url": "https://autoplans.dev/api/v1/mcp",
      "headers": { "Authorization": "Bearer apk_live_..." }
    }
  }
}

Cursor

.cursor/mcp.json in the project, or ~/.cursor/mcp.json globally

{
  "mcpServers": {
    "autoplans": {
      "url": "https://autoplans.dev/api/v1/mcp",
      "headers": { "Authorization": "Bearer apk_live_..." }
    }
  }
}

VS Code and GitHub Copilot

.vscode/mcp.json

{
  "servers": {
    "autoplans": {
      "type": "http",
      "url": "https://autoplans.dev/api/v1/mcp",
      "headers": { "Authorization": "Bearer ${input:autoplansKey}" }
    }
  },
  "inputs": [
    { "id": "autoplansKey", "type": "promptString", "description": "Autoplans API key", "password": true }
  ]
}

A client that only speaks stdio

Claude Desktop, Windsurf, and anything else without HTTP transport

npm install -g autoplans-mcp

{
  "mcpServers": {
    "autoplans": {
      "command": "autoplans-mcp",
      "env": { "AUTOPLANS_API_KEY": "apk_live_..." }
    }
  }
}

What the tools do

Every argument is listed in the MCP tools reference. Each answers with { success, data, message? }.

Projects

list_projects, get_project, create_project

Find the project a folder belongs to, or create one from the agent.

Tasks

list_tasks, get_task, create_task, update_task, delete_task, bulk_create_tasks, bulk_update_tasks

One list_tasks call returns the whole graph — parents, dependencies, subtask and comment counts — so an agent gets the plan in a single round trip.

Subtasks and comments

create_subtask, list_subtasks, list_task_comments, create_task_comment, update_task_comment, delete_task_comment

Break a task down and leave a trail of what was decided and why.

Assignment

assign_task, list_user_assigned_tasks

Hand work to a person or to the agent, and ask what is on your plate.

Code agent

code_agent_get_my_tasks, code_agent_get_task_with_dependencies, code_agent_update_task_status, code_agent_add_comment

Shaped for an agent working a backlog rather than for browsing. get_task_with_dependencies answers "can I start this yet" in one call.

Branding and business plans

get_branding, create_branding, update_branding, get_business_plan, create_business_plan, update_business_plan

The non-code artefacts of a project, reachable from the same place as the tasks.

Telemetry

telemetry_list_errors, telemetry_error_stats, telemetry_security_events, and others

For operating a deployment. Needs a key with the right scope.

Questions

What is an MCP server for project management?

The Model Context Protocol is a JSON-RPC standard for connecting an AI client to an external system. An MCP server for project management exposes projects and tasks as tools the model can call, so a coding agent can read its backlog, check dependencies and update task status without a human relaying any of it. The Autoplans server is one of these: a hosted endpoint at https://autoplans.dev/api/v1/mcp exposing around forty such tools.

Which MCP clients does Autoplans work with?

Any client that speaks the Model Context Protocol. That includes Claude Code, Cursor, GitHub Copilot in VS Code, Claude Desktop, Windsurf and OpenCode. The endpoint is Streamable HTTP; clients limited to stdio connect through the autoplans-mcp npm package, which bridges to the same server.

How does the server authenticate?

With an API key as a bearer token: Authorization: Bearer apk_live_.... Keys are created in the dashboard under Settings → API keys, and each one is scoped to your account. There is no OAuth dance to complete and no separate credential for each client.

Why does the tool count matter?

Around forty tool schemas attached to every model call is a large payload, and some inference endpoints reject it outright — free endpoints in particular have answered 503. That is why the Autoplans desktop app and CLI ship a bundled plugin exposing eleven task-shaped tools instead of the whole server. If your own client fails in a way that looks like the model choking rather than the server refusing, reducing the exposed tool set is the first thing to try.

Does the agent keep the plan between sessions?

Yes, because the plan does not live in the context window. It lives in the Autoplans backlog, and every session — in any client — reads the same one. Closing a session loses the conversation, not the project state.

Can I run this against my own deployment?

Yes. The stdio bridge takes AUTOPLANS_MCP_URL, so autoplans-mcp can point at a self-hosted deployment instead of the hosted endpoint.

Give your agent something to work from.

Create an account, make a key, paste one JSON block.

Start free