A persistent, cross-session task management server for AI agents with full task lifecycle management, rich filtering, documentation, and archiving.
Create & Import
task_add — Add tasks with description, priority, due date, tags, project, agent, recurrence, and dependencies
task_log — Record already-completed work
task_duplicate — Copy an existing task with optional field overrides
task_import — Bulk-create tasks from a JSON array
Query & Discover
task_list — Filter tasks by status, project, priority, tags, virtual tags (+OVERDUE, +ACTIVE, +BLOCKED, +READY), dates, and boolean operators
task_count — Count matching tasks without fetching full data
task_info — Get full details for a single task
task_projects / task_tags — List all projects or tags with pending/recurring tasks
Status & Lifecycle
task_start / task_stop — Mark tasks as active or paused
task_done — Complete a task
task_modify — Partial-update any field on matching tasks
task_delete — Soft-delete (restorable)
task_purge — Permanently remove deleted tasks
task_undo — Reverse the most recent operation
Annotations & Docs
task_annotate / task_denotate — Add or remove timestamped short notes
task_doc_write / task_doc_read / task_doc_delete — Attach, read, or remove full markdown documents (specs, design notes, handoffs)
Archiving
task_archive — Move old completed/deleted tasks to quarterly segments
task_archive_list / task_archive_load — List and inspect archived tasks read-only
Persistent, cross-session task management for Claude Code. Tasks survive sessions so work started by one agent can be picked up by another.
Built on @backloghq/agentdb — typed schemas, auto-increment IDs, virtual filters, blob storage. Pure TypeScript, zero native dependencies.
/plugin marketplace add backloghq/backlog
/plugin install backlog@backloghq-backloggit clone https://github.com/backloghq/backlog.git
cd backlog && npm install && npm run build
claude --plugin-dir /path/to/backlogAdd to your project's .claude/settings.json:
{
"mcpServers": {
"backlog": {
"command": "node",
"args": ["/path/to/agent-teams-task-mcp/dist/index.js"],
"env": {
"TASKDATA": "/path/to/task-data"
}
}
}
}Related MCP server: MCP Project Manager
Skill | Description |
| Show the current backlog — pending, active, blocked, overdue tasks |
| Break down a goal into tasks with dependencies, priorities, and specs |
| Daily standup — done, in progress, blocked, up next |
| Groom the backlog — fix vague tasks, missing priorities, broken deps, stale items |
| Write a spec document for a task before implementation |
| Pick up a task, read its spec, implement it, mark done |
| Prepare for next session — annotate progress, stop active tasks, summarize state |
The task-planner agent can be auto-invoked by Claude when someone needs to plan work. It reads the codebase, decomposes goals into tasks with dependencies, and writes specs for complex items.
Event | What it does |
| Shows pending task count when a session begins |
| Syncs Claude's built-in tasks to the persistent backlog |
| Marks the matching backlog task as done when Claude completes a built-in task |
| Auto-assigns unassigned pending tasks to the spawned agent |
Tools for full task lifecycle management:
Tool | Description |
| Query tasks with filter syntax. Returns JSON array with all fields. |
| Count tasks matching a filter. Same syntax as task_list. |
| Create a new pending task. Only description required; all other fields optional. |
| Record already-completed work directly in completed status. |
| Partial-update one or more tasks matching a filter. Only provided fields change. |
| Copy an existing task with optional field overrides. |
| Mark a task as completed with end timestamp. |
| Soft-delete a task. Restorable with task_undo. Use task_purge to permanently remove. |
| Add a timestamped note. Use task_doc_write for longer content. |
| Remove an annotation by exact text match. |
| Mark a task as actively being worked on. Visible in +ACTIVE queries. |
| Stop working on a task. Returns it to pending status. |
| Undo the most recent operation. Can be called repeatedly. |
| Get full JSON details for a single task by ID or UUID. |
| Bulk-create tasks from a JSON array. Atomic batch operation. |
| Permanently remove a deleted task. Irreversible. |
| Attach/replace a markdown document on a task (specs, notes, context). |
| Read the markdown document attached to a task. |
| Remove a task's document. Permanent. |
| Move old completed/deleted tasks to quarterly archive segments. |
| List available archive segments. |
| Load archived tasks for read-only inspection. |
| List project names with pending/recurring tasks. |
| List tags with pending/recurring tasks. |
status:pending # all pending tasks
project:backend +bug # bugs in backend project
priority:H due.before:friday # high priority due before friday
+OVERDUE # overdue tasks
+ACTIVE # tasks currently being worked on
+BLOCKED # tasks blocked by dependencies
+READY # actionable tasks (past scheduled date)
agent:explorer # tasks assigned to the explorer agent
( project:web or project:api ) # boolean with parentheses
description.contains:auth # substring matchSupports attribute modifiers (.before, .after, .by, .has, .not, .none, .any, .startswith, .endswith), tags (+tag, -tag), virtual tags (+OVERDUE, +ACTIVE, +BLOCKED, +READY, +TAGGED, +ANNOTATED, etc.), and boolean operators (and, or).
Attach markdown documents (specs, context, handoff notes) to any task:
task_doc_write id:"1" content:"# Spec\n\nBuild the auth flow.\n"
task_doc_read id:"1"
task_doc_delete id:"1"Writing a doc adds a +doc tag and has_doc:yes, so agents can discover tasks with docs:
task_list filter:"+doc"
task_list filter:"has_doc:yes"Tasks support an agent field for tracking which agent owns a task:
task_add description:"Investigate bug" agent:"explorer"
task_list filter:"agent:explorer status:pending"Each project gets its own task data automatically. When used as a plugin, task data lives in ~/.claude/plugins/data/backlog/projects/<project-slug>/. When used standalone, set TASKDATA explicitly.
Variable | Description |
| Explicit path to task data directory (overrides auto-derivation) |
| Root directory for auto-derived per-project task data |
| Explicit collection name (default: |
| Set to |
| Agent ID for multi-writer support (Claude, Gemini, etc.) |
| Storage backend: omit for filesystem (default), |
| S3 bucket name (required when |
| AWS region (optional if using default credentials) |
Backlog supports concurrent access from multiple processes (e.g., Claude Desktop and Gemini CLI) sharing the same data. To enable this:
Assign a unique BACKLOG_AGENT_ID to each process (e.g., claude, gemini).
When an agent ID is set, the engine uses per-agent write logs, avoiding file locks.
Each process automatically calls refresh() before operations to pick up changes from other agents.
If you want to use a single TASKDATA directory (like a shared S3 bucket or a global ~/.backlog folder) for multiple projects, you can use namespaces to keep tasks separate:
Manual: Set BACKLOG_NAMESPACE=my-project to use a specific collection name.
Automatic: Set BACKLOG_AUTO_NAMESPACE=true to have Backlog automatically derive a collection name from your current working directory (e.g. my-app-a1b2c3d4).
Example Configuration (.claude/settings.json):
{
"mcpServers": {
"backlog": {
"command": "node",
"args": ["/path/to/backlog/dist/index.js"],
"env": {
"TASKDATA": "/home/user/.backlog",
"BACKLOG_AUTO_NAMESPACE": "true",
"BACKLOG_AGENT_ID": "claude-desktop"
}
}
}
}Both methods allow multiple projects to share the same storage backend while maintaining isolated, project-specific backlogs.
Store task data in S3 for team sharing or cloud persistence. Requires @backloghq/opslog-s3:
npm install @backloghq/opslog-s3Configure via environment variables in .claude/settings.json:
{
"mcpServers": {
"backlog": {
"command": "node",
"args": ["/path/to/backlog/dist/index.js"],
"env": {
"TASKDATA": "my-project/tasks",
"BACKLOG_BACKEND": "s3",
"BACKLOG_S3_BUCKET": "my-team-backlog",
"BACKLOG_S3_REGION": "us-east-1"
}
}
}
}When using S3, TASKDATA becomes the key prefix in the bucket instead of a filesystem path.
docker build -t backlog .
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}' \
| docker run --rm -i backlognpm install
npm run build # compile TypeScript
npm run lint # run ESLint
npm test # run tests
npm run test:coverage # run tests with coverage
npm run dev # watch modeGitHub Discussions — questions, ideas, show & tell
Issue Tracker — bug reports and feature requests
Documentation — full docs, skills reference, filter syntax
If backlog is useful to you, consider giving it a star — it helps others find the project.
MIT
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 24 tools
Each tool has a distinct, clearly separated purpose with explicit cross-references in descriptions (e.g., 'use task_log instead', 'use task_doc_write instead'). No overlapping functionality—CRUD, lifecycle, archival, and document operations are cleanly partitioned.
Strict snake_case convention with consistent 'task_' prefix. Sub-resources follow predictable patterns (task_doc_read/write/delete, task_archive_list/load). Verbs are clear and consistently placed (task_add, task_delete, task_modify).
24 tools is above the typical ideal range but justified by the domain complexity. The set covers full task lifecycle, document attachments, archival management, annotations, and discovery without redundancy. Each tool earns its place for a comprehensive backlog system.
Excellent coverage of CRUD, status workflow (start/stop/done), soft-delete with purge, annotations, document attachments, and archival. Minor gap: archived tasks are view-only with no restore-to-active operation, though this appears to be an intentional cold-storage design.
Project management shared by people and AI agents, with persistent project state through MCP.
Persistent AI memory shared across Claude, ChatGPT, coding agents, and compatible MCP clients.
Persistent context for Claude. Your AI always knows your projects and next actions across sessions.
A task list shared by you and your coding agents (Claude Code, Cursor, Codex and any MCP client). Agents plan each task into steps, report live progress to a board, and block on questions you answer from your phone.
