Home › Guides › MCP for task management: guide and comparison

MCP for task management: guide and comparison

A task-management MCP server is a remote process an agent calls to move real work: it is neither a directory of servers nor a screenshot of an interface. This guide explains what it is, what each server exposes, what it costs and how to read a catalogue before depending on it. Prices were read from each product’s official page on 20 and 21 October 2026 and can change.

Reviewed · Published

What a task-management MCP server is

MCP (Model Context Protocol) is the protocol an AI client —an IDE, a CLI, an agent— uses to talk to external tools. In a task-management MCP server that server lives somewhere else: it is reached over HTTP with the streamable-http transport and authenticated with an API key that travels in the Authorization header as a Bearer token. Every call is a tool with a name, a description and arguments: list tasks, create a task, move it across a column, comment on it, plan a sprint.

Two things get confused every day, so it is worth separating them: the directory and the server. A directory —mcp.so, Glama, MCP Market, the official MCP Registry— is a list: it tells you the server exists and sometimes how many tools it exposes. The server is what does the work. Being listed in a directory says nothing about whether the surface is designed to coordinate people and agents, and that you read in the tool catalogue, not on the front page.

  • The protocol decides how you talk: MCP standardises tool discovery and the shape of a call, so the same client can use servers from different vendors without rewriting anything.
  • The transport decides where the server runs: streamable-http means an HTTP endpoint with Server-Sent Events, which is what allows a multi-user remote server with its own authentication.
  • The credential decides what the agent sees: in AI Tasker the API key with the atkr_ prefix decides the workspace, the permissions and the quota of every call. Without that header, the initialize step returns 401.
  • The directory decides nothing: publishing in the official registry costs no money, but it does not guarantee that the server fits your work. You check that in the tool list.

Five task MCP servers and AI Tasker, with their official price

The table gathers the MCP servers that show up in the comparison of this niche plus AI Tasker, with the price read from each product’s official page on 20 and 21 October 2026, plus the transport and the number of tools where the page publishes them. Prices can change: check the source before you sign anything. When a figure was not published, the cell says it is not verified instead of filling it with an estimate.

Task-management MCP servers: official price read, transport and number of tools (2026-10-21).
ServerOfficial URLPrice readTransport and endpointTools
AgentTaskagent-task.comFree $0 · Pro $7/month yearly ($9 monthly) · Team $12/seat/month yearly ($15)Remote, Streamable HTTP: app.agent-task.com/v1/public/mcp, OAuth 2.1 + API key with scopesNot verified
Hypertaskhypertask.aiFree $0 · BYOK $8/user/month yearly ($96) · Pro $16/user/month yearly ($192)Remote: mcp.hypertask.ai/mcp, plus CLINot verified
Kanban AIkanbanai.devHobby free · Pro $6/monthRemote on /api/mcp (returns 401 without credentials), MIT licence11
Kanbokanbo.devPro $8/user/month, $5 yearlynpx @kanbodev/mcp login125
Stacksmcpmarket.com/server/stacks-1Open source, self-hostableTokens with scopes; the agent appears on the board as a named teammate54
AI Taskermcp.ai-tasker.theboomer.dev/mcpFree plan 0 € + billable unit of 2,00 €/month per approved unit + one-time credit packsRemote, streamable-http, published in the official MCP Registry as dev.theboomer/ai-tasker40

The number of tools is not a measure of quality: a server with 125 tools is not better than one with 11 for having more. The question is whether each tool does one legible thing. And per-user price and per-agent-unit price are not the same figure: with a per-seat table, a team of three people and five agents pays for five users who are not people.

The configuration you copy

This is the generic mcpServers block for a remote server with the streamable-http transport. Every client has its own format: Claude Code uses .mcp.json, Cursor uses mcp.json and Codex CLI uses config.toml. The JSON below is the common pattern; the destination file and some key names change, the structure does not.

Generic mcpServers configuration for a remote MCP server with streamable-http and an API key.

{
  "mcpServers": {
    "ai-tasker": {
      "type": "http",
      "url": "https://mcp.ai-tasker.theboomer.dev/mcp",
      "headers": {
        "Authorization": "Bearer <AI_TASKER_API_KEY>"
      }
    }
  }
}

You replace the API key with the real one, with the atkr_ prefix. Without it the server answers 401 at the initialize step. Before pasting the block, read your client’s page: how the secret is stored —environment variable, secrets file or the client’s own credential store— is not standardised, and that is where copies between applications usually go wrong.

How to read a server catalogue before adopting it

A well-published MCP server can be audited in full before you call anybody. AI Tasker exposes four entry points, and any of them is enough to decide.

  1. The official manifest, at https://ai-tasker.theboomer.dev/server.json. It follows the MCP Registry schema (2025-12-11) and declares the name, the version, the transport type, the authentication headers, the number of tools and the prices. It is the same document the official registry and the directories consume.
  2. The registry entry, at registry.modelcontextprotocol.io. AI Tasker is published as dev.theboomer/ai-tasker, version 1.1.8. There you see something unusual: a remote server with Bearer authentication can live without a public repository, because the reverse-DNS namespace is granted by authenticating the domain over DNS.
  3. The machine-readable catalogue: /llms-full.txt gathers the full list of the 40 tools with their descriptions, grouped by area (agent identity and lifecycle, tasks and attachments, comments, projects and notes, relations between tasks, sprints and planning, credits and balance, decision engine, workspace onboarding and discovery). /llms.txt is the short version and /.well-known/ai-tasker.json the JSON summary.
  4. The operations and price table: /api/plans publishes which operations exist and how many units each one consumes. There you read that reading or mutating a collection costs 1 unit, that sprint planning, task generation and breakdown are hosted AI operations of 1 unit, and that webhook delivery, retries on 5xx or timeout and human reading in the dashboard are 0 units.

Reading the tools, not the marketing page, is what says whether the server is designed for the work: a tool that does one thing (create task, comment, move) is legible and composable, while a catalogue that exposes the whole database forces the agent to know things it should not know. The price belongs to the same criterion: a server charging 5 or 6 times per unit is changing the metric, not just the price. AgentTask, which charges 5-6× per unit, is the example.

MCP or HTTP API: when to use which

If the client speaks MCP, use MCP: it is the same work with tool discovery, typed arguments and header-based authorisation, and the agent does not have to reinvent the call every time. If the client does not speak MCP, or what you need is your own script, a webhook integration or an exact response from one endpoint, use the REST API. Both surfaces belong to the same product: the API publishes its OpenAPI at https://api.ai-tasker.theboomer.dev/docs, with 102 paths, where the same hierarchy appears (workspace, project, task, subtask) and the same agent operations as the 40 MCP tools.

The practical rule is this: what an agent does often and needs to discover —what is in my backlog, what can I do here— goes over MCP. A flow you already wrote in any language goes over HTTP, because there you already know the contract. And an integration that must notify another system without anyone asking goes over webhook.

Publishing in a directory: what it costs and what it does not

The official MCP Registry is the canonical registry and it is free: it asks for no payment account, no public repository and charges nothing for the listing. AI Tasker is published there as dev.theboomer/ai-tasker, version 1.1.8, with the reverse-DNS namespace granted by authenticating the domain over DNS (a TXT record at the apex and a signature with an Ed25519 key). Third-party directories work on a different model: some ask for an account, one charges for the remote listing and another has announced its shutdown.

MCP server directories: entry cost and the status of AI Tasker (2026-10-21).
DirectoryURLFigureAI Tasker listing
Official MCP Registryregistry.modelcontextprotocol.ioCanonical registryYes, 1.1.8: dev.theboomer/ai-tasker
mcp.somcp.so/tags/task-management59 servers in #task-management, 61 in #productivityNo: listings pending an account
Glamaglama.ai/mcp/connectors~107,756 indexed serversIndexed by ingestion from the official registry, status «Not tested»
MCP Marketmcpmarket.comServer listingsNo: the remote listing costs 69 $
Smitherysmithery.aiDirectory with MCP hostingNo: shutdown announced for 2026-10-31
awesome-mcp-serversgithub.com/punkpeye/awesome-mcp-serversPR in the projects and tasks categoryNo

A directory charging 69 $ for a remote listing is not a technical problem: it is a decision. The official registry covers canonical discovery and costs zero; third-party directories buy visibility, and that visibility has a price or friction (an account, a card or a public repository). Publish in the official one and decide afterwards, with the table in front of you.

It is worth saying it plainly: third-party listings can ask for money, and that is how they pay for themselves. Meanwhile, what decides whether a server is fit for purpose is something else: the tool catalogue and the price table of each product, both published and verifiable without installing anything.

How to test a task MCP server in five minutes

A month-long proof of concept is not needed. With the public endpoint and an API key you can walk the whole path in five minutes, and the result says more than any directory listing.

  • List the tools: ask for tools/list at the endpoint and check that the list matches the published catalogue. In AI Tasker, 40 tools must appear. If the list differs from what the directory advertises, the server wins.
  • Call one read tool: ask for the backlog or the service status. It checks two things at once: that the credential is valid and that the agent sees its own workspace and not somebody else’s.
  • Call one write tool: create a task, move it and comment on it. Permissions show up here: if the agent can create but not move, what you have is a connector, not a shared task manager.
  • Read the trail: look at the task history, with actor and date, and at the operations table with its consumption. If a call leaves no trail and does not show up in the consumption, the server is a black box and does not fit auditable work.

What is left to decide

The gap in this niche is narrow and worth stating with data: there are task MCP servers that already coordinate people and agents, charging between 6 $ and 16 $ per user per month. AI Tasker enters the same table with 2,00 € per approved billable unit, 40 documented tools and a listing in the official registry. If what you want is the largest index, join a paid directory. If what you want is a server you can audit over HTTP before connecting it and that charges for what the agent consumes, the table and the manifest above are the starting point.

How to connect and test a task-management MCP server

The full path against a remote server with streamable-http: configuration, tool discovery, a first read, a first write and checking the trail.

  1. Configure the remote server and authenticate

    Copy the mcpServers block into the configuration file your client uses (.mcp.json in Claude Code, mcp.json in Cursor, config.toml in Codex CLI) and replace <AI_TASKER_API_KEY> with the real key, with the atkr_ prefix. Without the Authorization header the initialize returns 401.

  2. Discover the tools before writing anything

    Open the MCP session against https://mcp.ai-tasker.theboomer.dev/mcp and ask for tools/list: 40 tools must appear. If you want to cross-check without a client, GET /llms-full.txt returns the same machine-readable catalogue and GET /server.json the manifest with the transport, the headers and the prices.

  3. Run one read and one write

    Start with a read tool (list tasks or get_service_info) to confirm the credential is valid, then continue with create_task to create a task, update_task to move it and add_task_comment to comment on it. The code the tool returns is the readable one (for example TSK-42), not the internal identifier.

  4. Check the trail and the consumption

    Open the task history: the actor and the date of every move are recorded there. Then GET /api/plans shows which operations exist and how many units each one consumes, so that the 2,00 € bill for an approved unit has a line-by-line explanation.

Frequently asked questions

What is a task-management MCP server?

It is a remote process that exposes tools with the MCP protocol (Model Context Protocol). The client —an IDE, a CLI or an agent— discovers them and calls them with typed arguments. In the case of AI Tasker the transport is streamable-http and the authentication is an API key in the Authorization header as a Bearer token. Task management (creating, moving, commenting, planning) lives in those tools, not in an interface.

How many tools does AI Tasker expose and where is the full list?

Forty, generated from the MCP server code. The full list is in /llms-full.txt, with the description of each one; the /server.json manifest carries the names, the transport and the price. The entry in the official registry, dev.theboomer/ai-tasker, shows version 1.1.8.

How much does a task-management MCP server cost?

It depends on the metric. AgentTask charges 7 to 12 $ per user per month, Hypertask 8 to 16 $, Kanban AI 6 $ per month and Kanbo 5 to 8 $ per user. AI Tasker charges 2,00 € per month per approved billable unit (accepted human member, created agent API key or additional owner workspace), with a free plan of 0 € and one-time credit packs. Stacks is open source and self-hostable.

Does publishing an MCP server in a directory cost money?

In the official MCP Registry it does not: it is free, it asks for no payment account and no public repository, and the reverse-DNS namespace is granted by authenticating the domain over DNS. AI Tasker is published there as dev.theboomer/ai-tasker. In third-party directories it does: MCP Market charges 69 $ for the remote listing, mcp.so leaves the listings pending an account and Smithery has announced its shutdown for 31 October 2026. Whether to join is a decision; the technical part does not change.

Sources

Figures verified against the live API and each product’s official page on 21 October 2026. Third-party prices can change: check the official page before you commit.

Related guides

This guide exists to be indexed and cited. It is deliberately not in the menu.