mcptask.online

Autonomous AI developers on your own infrastructure. People and AI developers share one task queue; the runner (Claude Code, Codex, OpenCode) works against your repo and tests and delivers a pull request to GitHub, GitLab or Bitbucket. Remote MCP server with OAuth.

View on mcptask.online

Hosted MCP Server

npx add-mcp 'https://mcptask.online/mcp'

Installs into Claude Code, Codex, Cursor and more

Documentation

← Back to the integrations overview

Run your project from chat — no terminal, no new UI

Paste one URL into Claude Cowork or claude.ai and you can plan, log time, and reply to clients straight from the conversation. OAuth 2.0 — no token, no config file.

link

Remote MCP server URL

https://mcptask.online/mcp

Paste this URL into Customize → Connectors → Add custom connector in Cowork / claude.ai

Using Claude Cowork or claude.ai? Connect in 2 minutes with one URL — no terminal, no new dashboard.

  1. 1 Create an account 30-day free trial, no card.
  2. 2 Paste the URL One URL, no token, no Client ID.
  3. 3 Approve and chat OAuth in your browser, then chat.

menu_bookDetailed steps

expand_more

groups

On a Team or Enterprise plan?

An Owner first adds the connector in Organization settings → Connectors (https://claude.ai/admin-settings/connectors): Add → hover Custom → Web → paste the URL → Add. Each member then connects it themselves in Customize → Connectors — it carries a Custom label.

cloud

Heads up on architecture

For a custom connector added via claude.ai / Cowork, the connection originates from Anthropic's cloud infrastructure, not from your machine. mcptask.online is publicly reachable, so no firewall or VPN setup is required.

  1. Create your mcptask.online account

    Free 30-day trial, no card. You can do this right now in a different tab. person_addCreate account

  2. Be logged in

    The OAuth approval happens in this browser, so the account you just created has to be the active session here. loginLog in

  3. Open Customize → Connectors in Cowork / claude.ai

    In Cowork or claude.ai, go to https://claude.ai/customize/connectors. Click the + and choose Add custom connector.

  4. Paste the mcptask.online URL

    Paste this URL — no Client ID or Secret, no token. Dynamic client registration handles the rest. 
    https://mcptask.online/mcp

  5. Click Connect and approve

    Click Connect. Your browser opens the mcptask.online OAuth approval page — log in (if you aren't already) and click Authorize. No token, no password is shared with Anthropic.

  6. Enable the connector in your chat

    In a new chat, click + (lower left), choose Connectors and toggle mcptask.online on. Try a first prompt: List my projects and my next task.

A PM Tool the Agent Drives

mcptask.online is built MCP-first. The agent doesn't just read your tasks — it uses the workspace as its work queue: GetNextTaskTool → work → LogWorkProgressTool → AddMessageTool.

What an autonomous workflow looks like

Plug in an MCP client and the workspace becomes the agent's to-do list, progress log, and hand-off channel.

check_circleWorkspace = the agent's work queue (MCP-first PM tool).

check_circleEvery action is scoped to the user's permissions and logged under their name.

open_in_newmcptask_runner uses this MCP server as its work queue

What is MCP?

mcptask.online is built so your AI assistant can drive the whole workspace through MCP — speak one protocol, get the full tool surface (list, read, create, log, message). No HTML to scrape, no bespoke HTTP per integration. For a one-paragraph definition of the acronym, see the glossary below.

Open the glossary

check_circleAI understands data structure immediately

check_circleNo custom integration code needed

check_circleReliable, versioned protocol

check_circleSame interface for all MCP clients

What you can do over MCP

Write:

  • editUpdate piece status
  • editLog work efforts
  • editAdd comments
  • editAttach files
  • editCreate pieces and subtasks

Query:

  • searchGet next available piece (priority-sorted)
  • searchPage through the list of pieces

Priority Factors

Priority levelUrgent > High > Normal > Low
Task typebugs and complaints before other tasks
Ageolder tasks surface

publicAny System

Connect Any AI Agent via MCP

mcptask_runner is optional. Any MCP-capable AI agent — Claude Code, Claude Desktop, Copilot in your IDE, or any other client — can read and work your tasks directly, no autonomous loop required. No binary, no install, just a tiny config file.

If your AI client speaks MCP, the connection takes about two minutes: get a token, add one server entry, and tell your agent which project to work on. The acronym MCP is explained in the glossary a few sections below. Open the glossary

Which clients work?

Anything that speaks MCP. Each row carries the date it was last re-checked.

Claude Code (CLI)

Works

Best fit. Add the server to your.mcp.json and Claude Code can read, list, and create tasks.

Verified 2026-08

Claude Desktop

Works

Add the same server entry to Claude Desktop's MCP settings. Same token, same endpoint.

Verified 2026-08

Other MCP clients

Works

Any client that accepts the standard MCP server config (VS Code Continue, Cursor when MCP-enabled, custom agents) works the same way.

Verified 2026-08

GitHub Copilot (IDE: VS Code, JetBrains, Eclipse, Xcode)

Works

Copilot speaks MCP natively in the IDE and supports custom MCP servers. Add the same.mcp.json entry as Claude Code.

Verified 2026-08

GitHub Copilot (github.com/copilot web)

Not supported

The web chat at github.com/copilot cannot connect custom MCP servers, so mcptask cannot be wired in there.

Verified 2026-08

GitHub Copilot (cloud agent / code review)

Partial

MCP tools work, but MCP resources and prompts do not. A large part of mcptask's surface is served as resources under mcptask:// URIs, so resource reads fail there.

Verified 2026-08

mcptask.online as Your Agent's Task Queue

The Agent Workflow

1

Agent calls GetNextTaskTool via MCP

arrow_downward

2

mcptask.online returns highest priority task

arrow_downward

3

Agent works on task (coding, testing, etc.)

arrow_downward

4

Agent calls LogWorkProgressTool with progress

arrow_downward

5

Agent logs 100% via LogWorkProgressTool: mcptask.online marks the task complete on its own

arrow_downward

6

Loop: Agent calls GetNextTaskTool again

check

A task goes only to the user it is assigned to

check

Priority-based task selection

check

Effort logging in a single tool call

check

Completion follows from a hundred-percent progress

check

Continuous operation loop

For Developers

No middleware, no scraping, no fictional endpoints. Set up in 5 minutes and drive mcptask.online from your AI client, Git host, or server script.

  • account_circleClaude Cowork / claude.ai — detailed OAuth walkthrougharrow_upward
  • codeGitHub webhooks — push + pull request

    GitHub Integration

    check_circleLive (Inbound Webhooks)schedule5 minutes

    Features

    codeWebhook event processing (push, pull request) codeTwo repository webhooks — one for push events, one for pull request events codeCommit messages link work to a piece and set its progress percentage codePull request body references link the PR and approve the piece on merge codeSigned with your account secret token via X-Hub-Signature-256

    How it works

    1. 1Copy your account secret token from mcptask.online (Account settings → Integrations → Secret token).
    2. 2In your GitHub repository, add a webhook with Payload URL https://mcptask.online/github/efforts, select Just the push event, and paste the secret token.
    3. 3Add a second webhook with Payload URL https://mcptask.online/github/pulls, select Let me select individual events → Pull requests, and paste the same secret token.
    4. 4In commit messages, add a line https://mcptask.online/ACCOUNT/tasks/ID NN% where NN is the progress percentage.
    5. 5In pull request descriptions, add a line mcptask: https://mcptask.online/ACCOUNT/tasks/ID.
    6. 6When the PR is merged, the referenced piece is approved and the last effort is set to 100%.

    How to reference a piece

    Use the piece's public URL https://mcptask.online/ACCOUNT/tasks/ID. ACCOUNT is your account code and ID is the piece's relative ID shown on the piece page and in the URL. Examples: 
    https://mcptask.online/ACCOUNT/tasks/47 40%https://mcptask.online/ACCOUNT/tasks/48 100%mcptask: https://mcptask.online/ACCOUNT/tasks/47

    Pull Request Integration

    • mergePR opened → a note with the PR link is added to the piece
    • mergePR merged → the piece is approved and a completion note is added
    • mergeThe last effort's progress is set to 100% on merge
    • mergeWorks with any public or private repository that can reach mcptask.online

    Configuration

    settingsTwo webhooks per repository (separate endpoints for push and pull request events) settingsPrivate repository support settingsNo source code access — only webhook metadata is processed settingsTLS required
  • codeGitLab webhooks — push + merge request

    GitLab Integration

    check_circleLive (Inbound Webhooks)schedule5 minutes

    How it works

    1. 1Copy your account secret token from mcptask.online (Account settings → Integrations → Secret token).
    2. 2In your GitLab project, add a webhook with URL https://mcptask.online/gitlab/efforts, trigger Push events, and paste the secret token into the Secret token field.
    3. 3Add a second webhook with URL https://mcptask.online/gitlab/merge\_requests, trigger Merge request events, and use the same secret token.
    4. 4In commit messages, add a line https://mcptask.online/ACCOUNT/tasks/ID NN% where NN is the progress percentage.
    5. 5In merge request descriptions, add a line mcptask: https://mcptask.online/ACCOUNT/tasks/ID.
    6. 6When the MR is merged, the referenced piece is approved and the last effort is set to 100%.

    How to reference a piece

    Use the piece's public URL https://mcptask.online/ACCOUNT/tasks/ID. ACCOUNT is your account code and ID is the piece's relative ID shown on the piece page and in the URL. Examples: 
    https://mcptask.online/ACCOUNT/tasks/47 40%https://mcptask.online/ACCOUNT/tasks/48 100%mcptask: https://mcptask.online/ACCOUNT/tasks/47

    Merge Request Integration

    • mergeMR opened → a note with the MR link is added to the piece
    • mergeMR merged → the piece is approved and a completion note is added
    • mergeThe last effort's progress is set to 100% on merge
    • mergeWorks with GitLab.com and self-hosted GitLab (12.0+) that can reach mcptask.online

    Configuration

    settingsTwo webhooks per project (separate endpoints for push and merge request events) settingsSelf-hosted GitLab support (12.0+) settingsNo source code access — only webhook metadata is processed settingsTLS required
  • terminalREST API — JSON over HTTP

    REST API

    check_circleLive (Stable)workspace_premiumAll plans JSON over HTTP, scoped to your account. Use it when MCP isn't a fit (server-to-server scripts, dashboards, non-MCP tools).

    Authentication

    One credential, one header. The same MCPTASK_TOKEN you use for the MCP server authenticates every REST API call as a Bearer token. 
    Authorization: Bearer <MCPTASK_TOKEN>
    Get a token in mcptask.online → View user → Advanced info → API Token. JWT-encoded, signed with HS256, scoped to your user — no separate API key, no per-account rotation.

    Endpoints

    All endpoints are scoped to your account code (the short code from your mcptask.online URL). Real paths use /pieces (the generic term) rather than /tasks — we use "piece" as the umbrella word for task, story, epic, recurent.
    Projects
    codeGET /api/{account_code}/projects - List projects
    Pieces (Tasks, Stories, Epics, Recurents)
    codeGET /api/{account_code}/pieces/{id} - Get piece codePOST /api/{account_code}/pieces - Create piece
    Efforts
    codeGET /api/{account_code}/pieces/{id}/efforts - List efforts codePOST /api/{account_code}/pieces/{id}/efforts - Log effort
    Users
    codeGET /api/{account_code}/users/{id} - Get user codeGET /api/{account_code}/users/current - Current user
    Bug reports (Professional, Enterprise and trial)
    codePOST /api/{account_code}/bug_reports - File a bug (bug report key)

    Rate Limits

    Enforced on the MCP server (/mcp): 60 requests/minute per token, plus the hourly per-account cap below, set by the plan (a trial gets the Professional cap). REST API calls do not count against these limits. Contact us if you need a higher ceiling. Starter 1,000/hour Professional 10,000/hour Enterprise Unlimited The REST API itself is available on every plan; filing bugs through /bug_reports needs Professional, Enterprise or a trial.

    Documentation

    Real calls you can paste in a terminal right now. Replace $MCPTASK_TOKEN with a token from View user → Advanced info → API Token and $ACCOUNT with your account code. codeCheck API version (no token needed) 
    curl https://mcptask.online/api

    { "message": "mcptask.online REST API v0.10", "version": "0.10", "version_app": "5.72", "revision": "1272" }

    curl https://mcptask.online/api/$ACCOUNT/users/current \
  -H "Authorization: Bearer $MCPTASK_TOKEN"

    { "id": 7, "user_nick": "george", "email": "george@example.com", "default_account_code": "bcp" }

    curl https://mcptask.online/api/$ACCOUNT/projects \
  -H "Authorization: Bearer $MCPTASK_TOKEN"

    [ { "id": 1, "code": "bcp", "name": "BCP Development" } ]

    curl -X POST https://mcptask.online/api/$ACCOUNT/pieces \
  -H "Authorization: Bearer $MCPTASK_TOKEN" \
  -H "Content-Type: application/json" \
  -d ''{"piece_type":"Task","name":"Review PR","project_id":1}''

    { "id": 42, "name": "Review PR", "piece_type": "Task", "state": "new" }
  • bug_reportBug report API — let your app file bugs into a project

    Bug report API

    check_circleLiveworkspace_premiumProfessional, Enterprise and trial Let your own application file bug reports straight into a project: one POST with a bug report key, and the bug lands as a Task in the project's Epic for errors — with the page URL, browser, screenshot and console log attached.

    Requirements

    The bug report API is part of the Professional and Enterprise plans; a trial account can use it too. On Starter the keys stay stored but file nothing until you upgrade. See pricing

    Setup in 3 steps

    1. Open the project's settings and scroll to the Bug report API card.
    2. Name the key (e.g. "My app production") and, if you like, pick a default assignee. Bugs go to the project's Epic for errors — it is created automatically when the project has none — and are authored by whoever created the key.
    3. Click Create key and copy it right away: it is shown only once (we store only its fingerprint). Keep it on your server, e.g. in an environment variable. Revoke it in the same card whenever you need to.

    Examples

    warningNever put the bug report key into code that runs in a visitor's browser — anyone could read it and flood your project. Let the browser send the report to your own backend and call mcptask.online from there. 
    curl -X POST https://mcptask.online/api/$ACCOUNT/bug_reports \
  -H "Authorization: Bearer $BUG_REPORT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title":"Save button does nothing","description":"Clicking Save on the invoice form has no effect.","url":"https://app.example.com/invoices/1","priority_code":"urgent"}'
    codecurl — multipart with a screenshot 
    curl -X POST https://mcptask.online/api/$ACCOUNT/bug_reports \
  -H "Authorization: Bearer $BUG_REPORT_KEY" \
  -F "title=Save button does nothing" \
  -F "description=Clicking Save on the invoice form has no effect." \
  -F "screenshot=@screenshot.png" \
  -F "files[]=@invoice.pdf"
    codeJavaScript — your backend (Node 18+), the key stays on the server 
    app.post('/report-bug', express.json({ limit: '12mb' }), async (req, res) => {
  const { title, description, url, user_agent, viewport, screenshot } = req.body;
  const response = await fetch(\`https://mcptask.online/api/${process.env.MCPTASK_ACCOUNT}/bug_reports\`, {
    method: 'POST',
    headers: {
      'Authorization': \`Bearer ${process.env.MCPTASK_BUG_REPORT_KEY}\`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ title, description, url, user_agent, viewport, screenshot })
  });
  res.status(response.status).json(await response.json());
});
    codeJavaScript — your web page, optional screenshot (html2canvas) 
    // The browser talks to YOUR backend only — never to mcptask.online with the key.
const canvas = await html2canvas(document.body); // optional
await fetch('/report-bug', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    title: 'Save button does nothing',
    description: 'Clicking Save on the invoice form has no effect.',
    url: location.href,
    user_agent: navigator.userAgent,
    viewport: \`${innerWidth}x${innerHeight}\`,
    screenshot: canvas.toDataURL('image/png')
  })
});
    A filed bug answers 201 Created with the new Task's relative ID and link: 
    {
  "relative_id": 1234,
  "url": "https://mcptask.online/acme/tasks/1234"
}

    Field reference

    FieldRequiredDescription
    titleyesBug title — becomes the Task name.
    descriptionyesWhat happened. The fields below are added to the Task description as sections.
    expected_behaviornoWhat should have happened.
    url, user_agent, viewportnoWhere and in which browser the bug appeared.
    reporter_name, reporter_emailnoWho reported it in your application.
    console_lognoBrowser console output; attached as console.log, its end also goes to the description.
    html_snapshotnoThe page HTML; attached as snapshot.html.
    screenshotnoA multipart file or a base64 data URL (data:image/png;base64,…).
    files[]noMore attachments — multipart files or base64 data URLs. All attachments together may take at most 10 MB.
    assigned_user_idnoOverrides the key's default assignee; the user ID of a member of your workspace.
    priority_codenoOverrides the default priority high: low, medium, high or urgent.

    Errors

    Errors answer JSON with an errors array; each item carries a name and a message (validation errors also the attribute).
  • menu_bookQuick glossary

    Quick glossary

    A few terms used across this page, in plain English. MCP Model Context Protocol — a standard way AI assistants (Claude, Cursor, Cline, …) talk to external tools. mcptask.online speaks MCP natively, so any MCP client can drive it. SSE Server-Sent Events — a legacy HTTP transport that MCP used for streaming tool calls. New clients should use the current streamable HTTP transport at https://mcptask.online/mcp; the legacy SSE endpoint is still served for backwards compatibility only. Webhook An HTTP call one app makes to another when something happens. Inbound = something calls mcptask.online (e.g. GitHub on push). Outbound = mcptask.online calls your system (planned, not live yet). MCPTASK_TOKEN A long random string that proves to mcptask.online that a request really comes from you. Generate it once in mcptask.online → View user → Advanced info → API Token and use it as a Bearer token. Treat it like a password. Custom connector The claude.ai / Cowork UI for adding a remote MCP server by URL. You give it the URL, click Connect, and the OAuth flow finishes the wiring — no token to copy, no config file to edit.
  • constructionAvailable MCP tools

    Available MCP Tools

    The 22 tools below are the real ones shipped by mcptask.online's MCP server today. AddMessageTool, AddAttachmentTool, CreatePieceTool, LogWorkProgressTool and the read-side tools work end-to-end.
    ToolDescription
    AddAttachmentToolAttach a file to a piece
    AddMessageToolAdd a comment / message to a piece
    BlockTaskToolBlock or unblock a task that cannot be finished right now, with an optional reason (state only — creates no dependency between pieces)
    CreatePieceToolCreate a new piece (task, story, epic, recurent)
    ExportTimeSheetReportToolExport a timesheet report as JSON, CSV or PDF (the PDF comes back base64-encoded)
    GetAccountToolFetch account details: attributes, account-level users, permitted projects and companies
    GetAttachmentToolFetch attachment metadata and a direct download URL for a piece
    GetCurrentUserToolIdentify the user behind the current token
    GetNextStorySubtaskToolGet the next subtask to work on inside one Story
    GetNextTaskToolGet the highest-priority available task
    GetPieceEffortsToolRead time-tracking entries for a piece
    GetPieceToolFetch a single piece by ID
    GetProjectToolFetch one project's metadata
    GetProjectTreeToolGet the project hierarchy (epics/stories/tasks)
    GetUsageGuideToolSelf-describe the server (capabilities and usage hints)
    ListPiecesToolList pieces with filters (project, status, type)
    ListProjectsToolList projects you have access to
    ListTimeSheetReportOptionsToolList the filters the timesheet report accepts (companies, projects, workers, layout)
    LogWorkProgressToolLog effort on a piece and update its progress
    ManageBlockerLinksToolDeclare or clear a dependency: the piece you name waits for the blockers you list, and drops out of the next-task queue until they are done (adding is all-or-nothing — one bad id rejects the whole call)
    SearchPiecesToolSearch one project's pieces by type, state, assignee, author and text
    UpdatePieceToolUpdate a piece's mutable attributes and get before/after for each one touched
  • vpn_keyAuthentication

    Authentication

    Two ways in, depending on your client. Claude Code / Cursor / Cline use a long-lived MCPTASK_TOKEN (Bearer). Claude Cowork / claude.ai use OAuth 2.0 with dynamic client registration — you never touch a token.

    MCPTASK_TOKEN (Bearer — for Claude Code, Cursor, Cline):

    • vpn_keyView user → API token in mcptask.online
    • vpn_keyTied to your user account, scoped to your workspaces
    • vpn_keyIt has no expiry date; Regenerate on the same page issues a new one and the old one stops working at once
    • vpn_keyTreat it like a password — anyone holding it acts as you

    OAuth 2.0 (for Claude Cowork / claude.ai):

    • lockNo client secret, no manual credential — dynamic client registration
    • lockPKCE S256 — secure even on public clients
    • lockApproval is per-workspace — you pick which mcptask.online workspace the connector can act on
    • lockRevoke from claude.ai at any time (Customize → Connectors → Remove)

    Permissions:

    • securityToken inherits your user permissions — no extra scopes today
    • securityRead-only vs. read-write is controlled by the actions you call
    • securityPer-project isolation is enforced server-side
    • securityAll calls are logged under your user

Technical details

How the MCP server and the integrations work

For the tech lead who wants to know what happens underneath before connecting a team.

Transport and sign-in

The MCP server speaks the Streamable HTTP transport at https://mcptask.online/mcp. A client config names it with "type" set to "http" and sends the user's MCPTASK_TOKEN in an Authorization Bearer header. Claude Cowork and claude.ai sign in over OAuth 2.0 instead.

  • The token is a JWT signed with HS256. It carries the permissions of its user — there are no extra scopes.
  • The MCP server is rate limited: 60 requests a minute per token, plus an hourly cap per account set by the plan (REST API → Rate limits below).

What a task read returns

GetPieceTool hands back the whole task, so nobody has to copy the context in by hand.

  • Name, description in Markdown, state, priority, type and assignee
  • The parent Story or Epic, the subtasks and the tasks that block it
  • Messages and attachments
  • A link to the work log, read with GetPieceEffortsTool

What is logged

Work time is logged explicitly, one entry per step. What an AI developer writes — work logs, messages, attachments, new tasks — carries its user's name, like anything a person writes.

  • LogWorkProgressTool: what was done, the duration in minutes and the progress in percent
  • BlockTaskTool: a task that cannot be finished right now, with the reason
  • The loop: GetNextTaskTool → work → LogWorkProgressTool → the next task

Several AI developers at once

Each AI developer is its own user with its own token, its own role in each project and its own name in the logs and the timesheet. It is billed like a person.

  • Its project roles decide which projects it works on
  • People and AI developers take tasks from the same queue

Commits and pull requests

GitHub and GitLab (GitLab.com and self-managed) report pushes and pull or merge requests to mcptask.online through webhooks.

  • A commit logs work when its message holds a line with the task URL and, optionally, the progress: https://mcptask.online/ACCOUNT/tasks/ID 80%
  • A pull request that names the task in its description is linked to it; merging it approves the task
  • Bitbucket Cloud has no webhooks. There, only mcptask_runner opens, reads and merges pull requests, through its own pr command.

Jira, Trello and Redmine

Issues and cards are imported one at a time into an existing project. From then on the work happens in mcptask.online.

  • Logged work, messages and completion are written back to the original issue or card as comments
  • Redmine also gets its done ratio updated
  • Changes made in Jira, Trello or Redmine after the import do not come back
{
  "mcpServers": {
    "mcptask-online": {
      "type": "http",
      "url": "https://mcptask.online/mcp",
      "headers": { "Authorization": "Bearer YOUR_MCPTASK_TOKEN" }
    }
  }
}

The entry for Claude Code and other MCP clients that read a config file. Replace the token with your own.

compare_arrowsComparison

mcptask.online vs. other task queues for AI coding

An AI developer running on your infrastructure, which reports and invoices like a human. TaskPeace, AgentTask, Task Master AI and taskqueue-mcp hand an AI its next task. Jira and Linear track tickets. Here is what each one does, checked against their own websites and READMEs.

Featuremcptask.onlineTaskPeaceAgentTaskTask Master AItaskqueue-mcpJira + AILinear
Code runs on your side: real database, real system tests????*?
Runner fleet: more machines, more projects, different coding CLIs (Claude Code / Codex / OpenCode), quotas per machine, one dashboard????*?
An MCP server the AI developer picks its next task from on its own?**?
Choice of model / your own API key
Local or open-weights model, model picked per task by complexity (genius / smart / primitive triage)????*?
Fully local mode: the model runs on your side (Ollama / open weights), no cloud inference????*?
Merges on its own after green CI (optional auto-squash)????***?
Recovers from a crash or context overflow and picks up on the work-in-progress branch?????
Someone else's failing test → files a bug, fixes it, returns to the task?????
Epic → Story → Task hierarchy and blocking between tasks???
GitHub, Bitbucket Cloud, GitLab incl. self-managed?GitHub??Bitbucket Cloud / GitHub Cloud ***GitHub
AI work in the same timesheet as people's work?????
People and AI in the same task queue???
What you pay for running the AIOnly your own API key or a local model, no markup????Rovo Dev credits + Bitbucket Pipelines build minutes *?
Price per user30-day free trial, then 300 Kč per user per monthFree in beta, Pro $10/month afterFree for 1 user, paid from $12/user/monthFree, open sourceFree, open source (MIT)Free up to 10 users, then paid per userFree, paid from $10/user/month
  1. * Jira + AI: everything runs in Atlassian's cloud — Rovo Dev, or Claude Code / Codex inside Bitbucket Pipelines. Agentic pipelines don't support self-hosted runners, the model can't run on your side, and every agentic step consumes build minutes.Agentic CI/CD is not supported on self-hosted runners Bitbucket Pipelines supports integrating agents using either Rovo Dev (Atlassian-managed) or Codex or Claude Code (bring-your-own account).All agentic steps consume Bitbucket Pipelines build minutes in the same way as any other pipelines step.
  2. ** Jira + AI: via the official Atlassian Remote MCP Server (OAuth 2.1).
  3. *** Jira + AI: Rovo Dev's work ends at a merge-ready PR, and the code has to live in Bitbucket Cloud or GitHub Cloud.creates merge-ready PRs in a safe, configurable sandbox Bitbucket Cloud or GitHub Cloud is connected to your Jira site

✓ stated on the tool's own website or docs · ✗ stated that it does not, or missing from its own feature page ·? no public page says either way. Checked on 2026-09-14.

Sources for every ✓ and ✗

mcptask.online vs. the alternatives

How is mcptask.online different from TaskPeace?

expand_more

TaskPeace keeps one flat, ranked queue that an AI reads over MCP. mcptask.online has the same GetNextTaskTool flow, plus an Epic → Story → Task hierarchy with blocking, GitHub / GitLab integration, time tracking and invoicing, and a runner that works the task on your own machine.

mcptask.online vs. AgentTask?

expand_more

Both let people and AI work from one backlog over MCP and link GitHub activity to tasks. mcptask.online adds a runner that executes tasks on your infrastructure against your real tests, and carries the work on to time reports and invoices.

mcptask.online vs. Task Master AI or taskqueue-mcp?

expand_more

Task Master AI and taskqueue-mcp are free, open-source task lists for one developer's editor. mcptask.online is a shared queue for a whole team of people and AI developers, with roles, time tracking, billing and a runner that takes a task all the way to a merged PR.

How is mcptask.online different from Jira with Rovo Dev?

expand_more

Driving a project from chat over MCP is something Jira does too these days — Atlassian runs an official Remote MCP Server — so we don't claim it as a difference.

The difference fits in one sentence: mcptask.online is an AI developer running on your infrastructure, which reports and invoices like a human.

In Jira an agent is a button on a ticket; with us it's a user with an identity, a timesheet, a daily budget and an invoice. Concretely:

  1. Where it runs. mcptask_runner works on your own machine against your real database and real system tests.
    • It resumes on the branch it left behind after a crash or a context overflow.
      • It scales into a fleet — more machines, more projects, quotas per machine, one dashboard. Atlassian runs in the cloud and does not support self-hosted runners.
  2. Which model. In Jira it's Rovo Dev or Claude/Codex in Bitbucket Pipelines. With us it's any model:
    • including a fully local mode (Ollama), where inference never leaves your side,
      • with triage that picks the model tier per task by complexity — routine runs on a cheap model.
  3. Where the work lands. In Jira it ends at a PR and spent credits. With us it goes all the way:
    • through CI, optionally merging itself when green,
      • into the same timesheet as human work,
      • to an invoice in Fakturoid or iDoklad.

Already on Jira? You don't have to throw it away — mcptask.online imports tasks from it and writes the completed work back to it as comments.

Why not Linear with an AI agent?

expand_more

Linear can assign an issue to AI. We found no MCP tool in it that hands out the next task, and no runner that works the task on your own machine. mcptask.online is built around that loop, and it ends at a paid invoice, not at the ticket.

infomcptask.online is the only platform that takes AI work all the way to a billable invoice.

FAQ

help_outline

Where do I find my MCPTASK_TOKEN?

Log in to mcptask.online, open Show user → Advanced information, and copy the API Token value (click to copy). Treat it like a password — anyone holding it acts as you on mcptask.online. The token has no expiry date; the Regenerate button next to it issues a new one and the old one stops working at once (changing your password does the same). Connected applications revokes OAuth access (Claude Cowork / claude.ai) only, not the API token — a revoked application loses access immediately.

help_outline

What address does the MCP server run on?

https://mcptask.online/mcp — streamable HTTP transport, one entry in your client config. The older SSE endpoint is still served for backwards compatibility, but point new clients at /mcp. It is not unlimited: 60 requests per minute per token plus the hourly account cap from your plan (see Rate limits above).

help_outline

Which AI tools support MCP?

Claude Code, Claude Desktop, Claude Cowork, Cursor, Cline, Continue, Codex CLI, OpenCode, and a growing list of MCP-native clients. If your tool speaks MCP, mcptask.online works with it. If not, use the REST API.

help_outline

What is a "piece"?

A piece is the umbrella name for tasks, stories, epics, and recurents. The MCP URI for a piece is mcptask://pieces/{account_code}/{piece_id} — there are no separate /tasks/ or /stories/ paths. Projects are not pieces; they have their own URI, mcptask://projects/{account_code}/{project_id}. Both take the relative ID — the number you see in the mcptask.online URL. There is no REST fallback for this: the REST API finds a piece by its internal id, so passing a relative ID to curl returns the wrong piece or a 403.

help_outline

Can an agent create pieces?

Yes, if the role of the user whose token it connects with allows it — the rule keys off role and authorship, not off who is at the keyboard. To prevent writes, give that user a read-only or limited project role; the same holds for anyone else on the team.

help_outline

Is work done over MCP visible in the log?

Yes. Every MCP write action creates an event with full attribution — which user, when, what changed.

help_outline

Can my own application report bugs into a project?

Yes, on the Professional and Enterprise plans (trial included). Create a bug report key in the project settings and POST each report to /api/{account_code}/bug_reports from your backend — the bug lands as a Task in the project's Epic for errors. The key files bug reports into that one project and does nothing else; see Bug report API above.