integration_instructionsMCP-native

The Only Tracker Where AI Work Becomes a Timesheet and an Invoice

mcptask.online is the only project tracker where the work your AI agent logs over MCP flows straight into your timesheet — and from there, into a real invoice. Context it reads on its own. No copy-paste.

Start Free TrialSee the Autonomous Runner

One task — the full lifecycle

1
task_alt
Task
in mcptask.online
2
smart_toy
Agent
reads via MCP
3
merge
PR
AI opens and merges
4
schedule
Timesheet
AI logs itself
5
receipt_long
Invoice
from the same timesheet
ZeroCopy-Paste
AutoLogging

Finally Know What AI Really Did — And What It Cost You

Manager asks: "What exactly did the AI help with this sprint?" — and the next question: "Can we justify the AI tool cost?" With mcptask.online, every AI action is logged, attributed, and exportable. You stop guessing and start reporting.

fact_check

Full Audit Trail

Every piece of work the AI logs carries attribution: which token, when, what changed, how long it took. No scattered chat logs. No fuzzy memories.

  • arrow_rightWhich agent wrote which code
  • arrow_rightTime spent per task — by the AI
  • arrow_rightWhat changed, exported as history
receipt_long

Justify AI Tool Costs

When leadership asks whether the AI subscription pays off, you have a number. AI effort is logged the same way human effort is — comparable, reportable, billable.

  • arrow_rightHours of AI work per sprint
  • arrow_rightHours of human work per sprint
  • arrow_rightCost per task, in your currency
rule

Human Approval Workflow

In the Professional plan, the AI works, but a human approves before changes land. Manager sees every diff before merge. AI moves fast, humans stay in control.

  • arrow_rightAI logs work as 'pending review'
  • arrow_rightManager reviews and approves
  • arrow_rightOnly approved work hits the timesheet

From Assistant to Autonomous Developer

Hand off the work in the evening, read the diffs in the morning. mcptask_runner is an optional gem for Rails projects that wraps Claude Code in a full autonomous harness — the machine picks up today's tasks, writes the code, opens the PR, and merges after CI goes green. Need an extra developer without hiring? Add an AI teammate that works on your infrastructure and bills like a human.

psychology

Model-Agnostic

Three tiers (genius/smart/primitive) are roles, not specific models. Map anything to them — Claude, Kimi, DeepSeek, MiniMax, local ollama. A cheap model for reading and triage, a strong one for heavy code — and 'strong' can just as easily mean a cheap third-party cloud model.

dns

Runs on Your Infrastructure

The runner is a Ruby gem in your project. It reads your real database, runs your real test suite, talks to your real Git host. No third-party service handles your code.

bug_report

Self-Spawn on Foreign Bugs

When the runner hits an URGENT bug that has nothing to do with its current task, it commits the in-progress work, files a tracked bug task, fixes the bug first, and only then returns to the original task. Concrete flow: commit the half-finished feature, file the bug as a tracked piece, push the fix, then resume the original task. Chaos becomes owned work.

See the Autonomous Runner

What You Need

Three things. No Ruby, no servers, no CLI magic. A free mcptask.online account is enough to try it today.

1

An MCP-capable AI client

Any client that speaks the Model Context Protocol — the open standard Claude Code uses to connect to external tools.

Examples: Claude Code, Claude Desktop, Cursor, Cline, Continue.

2

A free mcptask.online account

Sign up, create a project, add a few tasks. Two minutes.

No credit card. 30-day Professional trial on every new account.

3

Your MCPTASK_TOKEN from your user profile page

A long secret string that proves the agent is acting as you. Treat it like a password — anyone with it can act as you on mcptask.online.

Free on every plan. Open your user profile page → API Token and click the token to copy it. To remove an agent, revoke access in Connected applications.

Optional for autonomous overnight loops: the `mcptask_runner` gem (Rails projects only) — see the install guide.

AI Reads Tasks Directly via MCP

How It Works

1

Set Up the MCP Connection

Add this entry to your client's MCP config (for Claude Code: `.mcp.json` in your project root; for Claude Desktop: Settings → Developer → Edit Config). The endpoint, transport, and auth header are exactly what every MCP-native client expects.

{
  "mcpServers": {
    "mcptask-online": {
      "type": "sse",
      "url": "https://mcptask.online/mcp/sse",
      "headers": { "Authorization": "Bearer ${MCPTASK_TOKEN}" }
    }
  }
}
  1. 1
    Sign up at mcptask.online (free, 30-day Professional trial)
  2. 2
    Open your user profile page → API Token and click the token to copy it
  3. 3
    Copy the token, then `export MCPTASK_TOKEN=mcptask_...` in your shell (or add it to ~/.zshrc / ~/.bashrc)
  4. 4
    Paste the config above into `.mcp.json` (or your client's MCP settings)
  5. 5
    Restart your AI client
  6. 6
    Ask the agent: "List the next open task from my mcptask.online project."

Where this goes: `.mcp.json` (Claude Code) or the developer's MCP config dialog (Claude Desktop, Cursor, Cline). The `${MCPTASK_TOKEN}` reference is resolved from the environment variable — export it once in your shell profile so every client picks it up.

arrow_downward
2

Ask the AI to Read a Task

In plain English, ask the agent to work on something. The agent resolves `mcptask://pieces/{account_code}/{piece_id}` against mcptask.online over MCP — no copy-paste.

"Read task #47 and implement the login feature"

The URI pattern is the canonical read entry point for pieces — tasks, stories, epics, and recurents — using `mcptask://pieces/{account_code}/{id}`. Projects use their own `mcptask://projects/{account_code}/{project_id}` URI.

linkmcptask://pieces/jchsoft/10575
arrow_downward
3

AI Gets Full Context Automatically

AI receives:

  • check_circlePiece name and full description
  • check_circleParent epic/story context
  • check_circleAcceptance criteria
  • check_circleRelated pieces and dependencies
  • check_circleAll comments and discussion
  • check_circleAttached files (specs, designs)
  • check_circleWork history
arrow_downward
4

AI Logs Work Automatically

When done, the agent calls MCP to log progress — duration, what changed, status, blockers. You can ask it to log, or you can run the optional `mcptask_runner` gem that handles the autonomous loop end-to-end.

  • check_circleLog time spent
  • check_circleDescribe what was done
  • check_circleUpdate task status
  • check_circleAdd notes and blockers

Note: Plain MCP access does not log work on its own — the agent has to call the log tool, or the runner has to drive it. Zero-effort logging is a property of a well-instructed agent or the runner, not of MCP itself.

verified

Zero manual context setup. Zero manual logging — when the agent (or runner) does the logging.

The AI Context Problem

content_copy

Manual Context Setup Every Time

Every Claude Code session starts the same:

  • closeCopy task description
  • closePaste into chat
  • closeCopy acceptance criteria
  • closePaste into chat
  • closeExplain the context
  • closeFinally start working
Daily Waste:1-3 hours
schedule

No Automatic Work Logging

AI helped you fix 5 bugs today. But your task system shows nothing. You spend 30 minutes at day's end reconstructing what AI did and logging it manually.

Lost Data:

  • cancelWhat AI actually implemented
  • cancelTime spent per task
  • cancelContext for future reference
extension

Inconsistent Context

Sometimes you copy the full task. Sometimes you summarize. Sometimes you forget related tasks. AI works with incomplete information. Results vary.

Consequences:

  • warningAI misses requirements
  • warningRework needed
  • warningFrustration
search_off

No Audit Trail

Manager asks: "What exactly did the AI help with this sprint?"

You have: scattered chat logs, fuzzy memories, no structured data.

Impact:

  • blockCan't justify AI tool costs
  • blockNo visibility into AI productivity
  • blockNo metrics for improvement

How It Works

AI gets the full piece context, but that's the easy part — every modern tracker with MCP can hand a task over. The differentiator is what happens to the work after the AI is done.

Automatic Work Logging

AI Logs (when instructed, or via mcptask_runner):

  • check_circlePiece worked on
  • check_circleDuration (estimated from session)
  • check_circleWhat was implemented
  • check_circleProgress percentage
  • check_circleAny blockers encountered

Human Effort:

Zero — once you tell the agent (or runner) to log, it logs. Plain MCP reads do not log on their own.

Consistent Workflow

Every Session:

  1. 1
    AI reads piece from MCP
  2. 2
    AI works on piece
  3. 3
    AI logs completion via MCP
  4. 4
    Human reviews when convenient

No more:

Copy-paste ceremonies, forgotten logging, inconsistent context.

Clear Attribution

Every Action Tagged:

"Effort logged by Claude-Code-1"

"Status changed by AI Agent"

"Comment added by AI Assistant"

Benefit:

Always know what AI did vs. what human did.

Workflow Examples

Bug Fix Session

close

Before mcptask.online:

  1. 1
    Open Jira, find bug ticket (2 min)
  2. 2
    Copy description, paste to Claude (1 min)
  3. 3
    Copy steps to reproduce (1 min)
  4. 4
    Claude investigates and fixes (15 min)
  5. 5
    Manually log time in Jira (2 min)
  6. 6
    Update ticket status (1 min)
Total:22 minutes
Overhead:7 minutes (32%)
check_circle

With mcptask.online:

  1. 1
    Tell Claude "work on bug #47" (10 sec)
  2. 2
    Claude reads piece via MCP automatically
  3. 3
    Claude investigates and fixes (15 min)
  4. 4
    Claude logs work via MCP automatically
  5. 5
    Timesheet is already up to date — and the fix is billable
Total:15 minutes
Overhead:10 seconds (<1%)

Feature Implementation

close

Before mcptask.online:

  1. 1
    Read epic and stories in Jira (5 min)
  2. 2
    Copy relevant context to Claude (3 min)
  3. 3
    Discuss approach with Claude (5 min)
  4. 4
    Claude implements feature (30 min)
  5. 5
    Manually document what was done (5 min)
  6. 6
    Log time across multiple tasks (3 min)
Total:51 minutes
Overhead:16 minutes (31%)
check_circle

With mcptask.online:

  1. 1
    Tell Claude "implement story #23" (10 sec)
  2. 2
    Claude reads story and all subtasks via MCP
  3. 3
    Discuss approach with Claude (5 min)
  4. 4
    Claude implements feature (30 min)
  5. 5
    Claude logs work automatically via MCP
  6. 6
    Effort flows into the invoice without a manual re-entry
Total:35 minutes
Overhead:10 seconds (<1%)

Illustrative Example

Note: The quote and numbers below are illustrative. We use them to show what an MCP-native workflow looks like in practice — we have not collected this testimonial from a named user.

format_quote
Claude Code is much more useful when it can read the full task context, understand the requirements, and log its own work. I haven't copy-pasted a task description in months.
person

Illustrative — full-stack developer

Full-Stack Developer

Using Claude Code with mcptask.online

What the workflow looks like

Context setup time:

5 min → 10 seconds (example)

Work logging time:

30 min/day → 0 (when the agent logs)

AI productivity:

Better context → better output (qualitative)

Audit trail:

Every MCP action is logged with full attribution

Technical Details

smart_toy

Supported AI Tools

Fully Compatible (MCP-native):

  • check_circleClaude Code (Anthropic)
  • check_circleClaude Desktop
  • check_circleCursor, Cline, Continue, and any MCP-compatible assistant

Via REST API:

  • apiCustom AI agents
  • apiTools that do not speak MCP yet
integration_instructions

MCP Capabilities

Read:

  • visibilityPieces (tasks, stories, epics, recurents, projects)
  • visibilityComments and attachments
  • visibilityProject structure
  • visibilityWork history

Write (when the agent decides to):

  • editLog efforts
  • editUpdate status
  • editAdd comments
  • editCreate or complete pieces
security

Security

Access Control:

  • shieldOne MCPTASK_TOKEN per agent or per user
  • shieldPermissions follow the token owner's project role
  • shieldProject-level access reflects your account membership
  • shieldToken rate limits per token

Audit:

  • fact_checkEvery MCP action is logged
  • fact_checkFull attribution (which token, when, what)
  • fact_checkExportable history

Pricing for AI Teams

Prices are always up to date — the same ones your payment gateway charges. No manual updates, no drift between this page and your invoice.

Starter

$19/month
  • check_circle5 projects
  • check_circleUnlimited pieces
  • check_circleMCP server access
  • check_circleGitHub/GitLab webhooks
  • check_circle1 user + 1 AI agent

Best For:

Solo developers using AI daily

Professional

$14/user/month
  • check_circleUnlimited projects
  • check_circleUnlimited team members
  • check_circleAdvanced MCP features
  • check_circleSprint management
  • check_circleAI work approval workflow
  • check_circleAdvanced reporting

Best For:

Teams where everyone uses AI assistants

MCP access for AI agents is free on every plan. You only pay for account users.

FAQ

Q

How is this different from a Jira or Linear MCP server?

Linear, Jira, and GitHub all have MCP servers that can hand a task to an AI assistant. Where mcptask.online differs is the lifecycle after the AI is done. The work the AI logs over MCP flows into the same timesheet a human would use, and from there into a real invoice. You get audit-ready attribution for every AI action, and the AI's hours are reportable and billable — not just editable tasks. Plain MCP gives an AI a task to read; mcptask.online gives the AI a place where its work counts.

Q

Where do I find my MCPTASK_TOKEN?

Log in to mcptask.online, open your user profile page, and copy the token from API Token (click to copy). Treat it like a password — anyone with it can act as you on mcptask.online. To disconnect an agent, revoke its access in Connected applications.

Q

What is MCP?

MCP — Model Context Protocol — is the open standard Claude Code (and other MCP-native clients) use to connect to external tools. mcptask.online runs an MCP server at https://mcptask.online/mcp/sse, so any MCP-compatible client can read and write your project data with one config entry.

Q

Do I need to install anything?

For the basic read/write flow: no. A free mcptask.online account, an MCP-compatible client, and a token are enough. For the fully-autonomous daily loop (an agent picking up today's tasks on its own), the optional `mcptask_runner` gem is a one-line addition in a Rails project — see the install guide.

Q

Which AI tools support MCP?

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

Q

Is the mcptask_runner required?

No. The runner is a convenience wrapper for the fully-autonomous loop in a Rails project. Plain MCP read and write works without it, on any stack.

Q

What is a "piece"?

A piece is the generic name for tasks, stories, epics, and recurents in mcptask.online. The MCP URI for a piece is `mcptask://pieces/{account_code}/{piece_id}` — there are no separate `/tasks/` or `/stories/` paths. Projects use `mcptask://projects/{account_code}/{project_id}`.

Q

Can AI create pieces?

Yes — if the user whose token you use has a role that allows it. Agents can create pieces, subtasks, and comments through MCP write tools. If you want to prevent writes, assign a read-only or limited project role to that user.

Q

Is AI access logged?

Every MCP action is logged with full attribution — which token, when, what changed. You always know what AI did.

Q

Do I need to change my workflow?

Minimally. You ask the AI to read pieces instead of copy-pasting, and (optionally) to log work when done. Everything else improves automatically.

Let AI Work — and Have Its Work on the Timesheet and the Invoice

30-day free Professional trial. MCP server included. Connect Claude Code in five minutes.

Start Free Trialarrow_forwardRead the Install Guidemenu_book

check_circleNo credit card. Unlimited MCP actions. Cancel anytime.