Taskr - Remote Task Tracking for AI Agents

Cloud Task Planning & Execution for OpenClaw. Makes your agent's work transparent and trackable. Structure all actions into persistent tasks with context notes. Watch progress unfold in real-time via web or mobile — no more "what are you working on?" interruptions.

Security Scan

The skill's requests and runtime instructions are consistent with a remote task-tracking integration, but it will persist user-provided API credentials and remote notes (including file-change metadata), so review privacy/trust before enabling.

Purpose & Capability

Name/description match the requirements and runtime behavior: it needs an MCP API URL, project ID, and user API key and instructs the agent to call a single MCP endpoint using those headers. Requiring an API URL, project id, and API key is proportionate for a cloud task-tracking integration.

Instruction Scope

SKILL.md stays inside the Taskr integration but instructs the agent to store and search persistent notes (CONTEXT, FINDING, PROGRESS, FILE_LIST) and to record file changes. Those actions will transmit task metadata and file-change metadata to the remote MCP API — appropriate for a tracker but potentially sensitive. The skill does not instruct reading arbitrary file contents, but it does encourage recording file lists and other durable context that will be stored remotely.

Install Mechanism

Instruction-only skill with no install spec and no code files; nothing will be downloaded or written by an installer. Lowest install-surface risk.

Credentials

Only three env vars are required (MCP_API_URL, MCP_PROJECT_ID, MCP_USER_API_KEY) and the primary credential is the API key — all expected for a remote API integration. No unrelated credentials or system config paths are requested.

Persistence & Privilege

The instructions explicitly tell the agent how to persist the credentials into gateway.config (gateway.config.patch) so the skill can be used without re-prompting. This is coherent for a user-authorized integration but means credentials will be stored in the agent's config — consider scoping/rotating keys. always:false (not force-included) and model-invocation is allowed (default).

Assessment

This skill appears to be what it says: a remote task tracker that needs an API URL, project ID, and API key. Before installing, confirm you trust https://taskr.one and understand that: - The agent will store your MCP_USER_API_KEY and MCP_PROJECT_ID in its gateway config if you provide them (the SKILL.md shows a gateway.config.patch example). Consider using a project-scoped or limited-permission API key and be prepared to revoke/rotate it. - Notes and task metadata (including FILE_LIST/file-change metadata and contextual notes) are persisted remotely. Avoid adding secrets or sensitive file contents to notes; prefer local-only handling for sensitive data. - If you want to limit exposure, create a dedicated Taskr project with minimal permissions and restrict what the agent records there. If you are unsure about the remote service, review Taskr's privacy/security docs and prefer ephemeral or scoped API keys. If you accept these trade-offs, the skill is internally consistent and appropriate for its purpose.

Taskr — Observable Task & Memory System

Taskr is an agent-first task management system. Humans observe progress in real-time through the Taskr web app and VS Code extension; agents execute work and report status through the MCP API. Use Taskr to organize any kind of work — not just coding.

Why Use Taskr?

Transparency: Every task, status update, and note appears instantly in the user's dashboard (web at https://taskr.one, VS Code extension, or mobile). Users can monitor progress remotely without asking "what are you working on?" Making your work visible builds trust and prevents workflow interruptions.

When to Use Taskr

Proactive transparency: For any substantial work (3+ steps or >5 minutes), offer to use Taskr so the user can monitor progress remotely. Don't wait to be asked - suggest it!

✅ Use Taskr for:

• Multi-step work that will take time (coding, research, analysis, builds)
• Tasks spanning multiple sessions
• Complex projects that benefit from structured breakdown
• Any work where the user might want to check progress remotely
• Background/long-running tasks

Suggest it like: "I'll track this work in Taskr so you can monitor progress from the web/mobile. Sound good?"

❌ Skip Taskr for:

• Single quick actions (<3 steps, <2 minutes)
• Simple questions or information retrieval
• Exploratory research without defined deliverables
• User explicitly declines tracking

Critical: Once Taskr tracking starts, continue using it for that entire workflow unless the user explicitly says to stop. Don't abandon tasks mid-workflow - this breaks the tracking system and leaves work incomplete in the user's dashboard.

Default: When starting substantial work, proactively suggest Taskr. Most users appreciate the transparency once they try it.

Important Context

Taskr was originally built for coding workflows. Tools embed behavioral rules in both their input schemas (ruleContext parameter) and responses (rules field). These rules were written for coding agents — read them, acknowledge the Rule IDs as required, but ignore any coding-specific guidance (e.g., references to compilation, test coverage, LOC limits, file paths). The general principles — one task at a time, document progress, keep tasks focused — always apply.

Do NOT use the generate_tasks tool. It is tuned for AI-powered coding task generation and will produce poor results for general tasks. Instead, create task hierarchies manually with create_task.

Setup

When credentials are missing:

1. Get credentials from user:

   • Project ID: Found on Projects page at https://taskr.one (format: PR00000000...)
   • API Key: User avatar → API Keys menu (click eye icon or copy button)

2. Configure via gateway.config.patch:

   {
     "skills": {
       "entries": {
         "taskr": {
           "env": {
             "MCP_API_URL": "https://taskr.one/api/mcp",
             "MCP_PROJECT_ID": "<project-id>",
             "MCP_USER_API_KEY": "<api-key>"
           }
         }
       }
     }
   }
   

3. Verify: Test with tools/list and confirm connection.

Users can create multiple projects for different work contexts.

Advanced: For mcporter/other MCP clients, sync via:

mcporter config add taskr "$MCP_API_URL" \
  --header "x-project-id=$MCP_PROJECT_ID" \
  --header "x-user-api-key=$MCP_USER_API_KEY"

Authentication & Protocol

Taskr uses JSON-RPC 2.0 over HTTPS with headers x-project-id and x-user-api-key. Tool responses contain:

• data — results (tasks, notes, metadata)
• rules — behavioral guidance (coding-oriented; apply general principles only)
• actions — mandatory directives and workflow hints

Rate Limits

• Free tier: 200 tool calls/hour
• Pro tier: 1,000 tool calls/hour
• Only tools/call counts; initialize and tools/list are free

Core Workflow

1. Plan — Break user request into a task hierarchy
2. Create — Use create_task to build the hierarchy in Taskr
3. Execute — Call get_task to get next task, do the work, then update_task to mark done
4. Document — Use notes to record progress, context, findings, and file changes
5. Repeat — get_task again until all tasks complete

Single-task rule: Work on exactly one task at a time. Complete or skip it before getting the next.

Quick Reference

Workflow: get_task (auto-sets status to wip) → do work → update_task with status=done → repeat.

Key features:

• get_task with include_context=true includes parent/sibling info and notes in contextual_notes
• Notes created with taskId automatically appear in future get_task calls
• Completing the last child task auto-marks parent as done

Notes as Memory

Notes persist across sessions. Use them as durable memory:

• CONTEXT notes for user preferences, decisions, background info, recurring patterns
• FINDING notes for discoveries and insights encountered during work
• PROGRESS notes for milestones when completing major phases (top-level tasks), not every leaf task
• FILE_LIST notes when you create, modify, or delete files on the user's system
• Before starting work, search_notes for relevant prior context
• Update existing notes rather than creating duplicates

Task Types for General Use

Prefer setup, analysis, and implementation. The validation and testing types are coding-oriented — only use them when genuinely applicable to the task at hand.