convez.ai
MCP ServerAutomaçãoIntermediário
mazen160

Backlog MCP Server

mazen160/backlog

Fila de tarefas distribuída e com memória para agentes de IA

Ver no GitHub
BomPluginScore · de 0 a 100

MCP server que fornece fila de tarefas e banco de dados local-first para agentes de IA. Permite que múltiplos agentes leiam e escrevam tarefas de forma sincronizada, com atribuição automática de quem fez cada ação. Resolve o problema de perda de memória entre sessões de agentes de IA.

Instalação

$npx convez-ai mazen160/backlog

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
18
Forks
3
Acompanhando
0
Saúde
71%
Último commit
há 4 meses
Versão
v1.0.4
Issues abertas
0
Contribuidores
1

Casos de uso

  • Orquestração de múltiplos agentes de IA em paralelo
  • Manutenção de contexto entre sessões de agentes
  • Rastreamento atribuído de quem (humano ou IA) executou cada tarefa
  • Automação de workflows de desenvolvimento com agentes independentes

Veredito

Backlog resolve um problema real de agentes de IA: perda de contexto entre execuções. O design é sólido — fila centralizada, atribuição de ações, integração via MCP. Ideal para quem quer paralelizar agentes sem perder rastreabilidade.

README

A tradução para o português deste README ainda está na fila.

A local-first task queue and database your AI coding agents can read and write directly.

CI Latest Release License: MIT GitHub Stars

Website · Docs · MCP setup · Changelog


Why Backlog

Most AI coding agents lose state the moment a chat ends. Their "memory" is a 500k-token thread that costs you a subscription and forgets the project the next morning.

Backlog moves the queue out of the chat and into a Backlog DB your agents read and write through MCP. Same database your CLI uses. Same database your other agents use. Every write is signed by the actor that made it (human:alice, ai:claude-code, ai:semgrep), so you always know who did what.

The result is the agentic loop: spawn a fresh subagent, let it pull a task, plan, ship, and exit — then do it again. Four parallel sessions, ~12× the throughput of one developer running one agent, ~10× cheaper per task than a long-running thread.

One queue. Many agents. Every write attributed.


Install

Grab a pre-built binary for macOS or Linux (arm64 + amd64):

OS=$(uname -s | tr '[:upper:]' '[:lower:]')
ARCH=$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/')
curl -L https://github.com/mazen160/backlog/releases/latest/download/backlog_${OS}_${ARCH}.tar.gz | tar xz
sudo mv backlog /usr/local/bin/

Or install from source:

go install github.com/mazen160/backlog/cmd/backlog@latest

One binary. No dependencies. No runtime to install.


See it

Everything runs from your shell. backlog init creates the Backlog DB. Every command attributes the write to the actor who made it.

backlog web serves a clean, inline-editable dashboard from the same Backlog DB. Tasks created from a CLI or an AI agent show up here instantly with full attribution.

Wire Backlog into Claude Code, Cursor, Codex, or OpenCode via MCP. Your agent's writes land in the same database your shell reads from — fully attributed to the AI that made them.


The agentic loop

A loop is one unit of work: pick → plan → ship → review → attribute. Backlog stores the queue, attributes every step, and keeps multiple agent sessions from stepping on each other.

Each task spawns a fresh subagent with only the context it needs. The average session fits in under 50k tokens instead of the 500k a long-running thread bloats into. Same quality, dramatically cheaper.


Quickstart

# 1. Create a workspace in your project directory
backlog init

# 2. Add a project
backlog project add "My App" --alias app

# 3. Create some tasks
backlog task add -p app -t "Fix login timeout" --type bug --priority P2
backlog task add -p app -t "Add rate limiting" --type feature --priority P3

# 4. See what's open
backlog task list

# 5. Start working on TASK-1
backlog task move TASK-1 --status doing

# 6. Attach a versioned plan
backlog plan add --task TASK-1 --title "Fix plan" \
  --content "1. Increase timeout\n2. Add test"

# 7. Done
backlog task move TASK-1 --status done

That's the whole workflow. No accounts. No webhooks. No SaaS.

For step-by-step setup, see Getting Started.


Concepts

A quick glossary of the vocabulary used throughout Backlog. Full detail in Core Concepts.

TermWhat it is
WorkspaceA directory holding a backlog.db (and a config.toml). Every project, task, plan, and comment lives in that one SQLite file. Created by backlog init.
ProfileA named pointer to a workspace, registered in ~/.config/backlog/config.toml, so you can switch workspaces without typing paths.
ProjectA named group of tasks inside a workspace, identified by a short alias (e.g. api) — the alias is what you pass to -p / --project.
TaskThe unit of work. Has a type, status, priority, and actor; addressed as TASK-N.
PlanA versioned markdown document attached to a task. Every edit creates a new immutable version; the full history stays readable.
CommentAn append-only, actor-attributed note on a task.
LabelA per-project tag for filtering tasks.
DocA versioned markdown document attached to a project (not a task) — runbooks, ADRs, design notes.
MemoryA free-form, taggable, mutable note for cross-session agent context.
ActorThe human:name or ai:name attributed to every write.
ActivityAn append-only log of every write across the workspace.

Features

  • Local-first — the Backlog DB sits next to your code. Commits with your repo (or doesn't — your call).
  • Single binary — ~17 MB. No runtime, no dependencies, no daemon.
  • JIRA-style refs — tasks are TASK-1, TASK-2, … No UUIDs in your terminal.
  • Versioned plans — every plan edit creates an immutable version. Full history is always readable.
  • Actor attribution — every write is signed human:name or ai:name. Filter, audit, blame.
  • MCP server — plug into Claude Code, Cursor, Codex, OpenCode, or anything that speaks MCP.
  • Full-text search — backlog task list --search "injection*" runs in milliseconds.
  • Workflow health reports — backlog activity analyze and backlog doctor project surface cycle time, stale work, and weakly-closed tasks across parallel agent sessions.
  • Bulk findings import — structured JSON intake for security scanners and AI agents.
  • Web UI — backlog web serves a clean dashboard from the same Backlog DB.
  • Export anywhere — JSON, CSV, or Markdown.
  • HTTP API — embedded server for scripts and integrations.
  • No telemetry, no tracking — period.

CLI reference

CommandDescription
backlog initCreate a Backlog workspace
backlog project add/list/show/update/archiveManage projects
backlog task add/list/show/update/move/archiveManage tasks
backlog plan add/update/show/historyVersioned plans on tasks
backlog comment add/listComments on tasks
backlog label create/attach/detachPer-project labels
backlog activity / activity analyzeAudit trail and project workflow-health report
backlog doctor projectLint a project for stale, orphaned, and weakly-closed work
backlog import-findings <file.json>Bulk import from scanners/agents
backlog import <other.db>Merge another workspace
backlog export --format json|csv|mdExport tasks
backlog syncReconcile backlog.json with DB
backlog mcp serveStart MCP stdio server
backlog webServe the web UI
backlog doctor check|backupHealth check and backup
backlog schemaPrint JSON Schema for all payload types
backlog profile add/list/set-defaultNamed workspace shortcuts

Full reference: CLI Reference.


Actor attribution

Every command accepts --as kind:name. Without it, the actor defaults to human:$USER.

backlog task add -p app -t "Investigate memory leak" --as human:alice

backlog plan add --task TASK-1 --title "Memory profiling plan" \
  --content "Run pprof on /api/v2/search endpoint" \
  --as ai:claude-code

backlog task list --actor-kind ai
backlog task list --actor-name alice

Every row in the Backlog DB carries the actor that wrote it. Audit trails are free.


MCP server

Connect any MCP-compatible AI assistant directly to your backlog:

backlog mcp serve --as ai:claude-code --db /path/to/backlog.db

Claude Code (~/.claude.json):

{
  "mcpServers": {
    "backlog": {
      "command": "backlog",
      "args": ["mcp", "serve", "--as", "ai:claude-code"],
      "env": { "BACKLOG_DB": "/path/to/backlog.db" }
    }
  }
}

Setup for Cursor, Codex, and OpenCode: MCP guide.


Findings import

Security scanners and AI agents can write a structured JSON file and bulk-import:

cat > findings.json << 'EOF'
{
  "version": 1,
  "project": "app",
  "items": [
    {
      "title": "SQL injection in /search",
      "type": "vulnerability",
      "priority": "P1",
      "source": "semgrep",
      "plans": [{ "title": "Fix", "body": "Use parameterized queries." }]
    }
  ]
}
EOF

backlog import-findings findings.json --as ai:semgrep

Every finding becomes a task. Every task is attributed to the scanner that found it.


Workflow health

When several agents are closing tasks against the same queue, an empty backlog doesn't mean the work was done well. Two read-only reports tell you whether it actually was:

# How is this project trending over the last week?
backlog activity analyze --project app --since 7d

Cycle time by task type, status-transition latency (todo→doing, doing→done), WIP by actor, reopened work, bug follow-ups, label churn, and the human-vs-AI close ratio — one report, no dashboard required. Add --json to pipe it into your own.

# What did the agents close badly?
backlog doctor project --project app

Flags stale doing tasks, tasks created but never started, tasks closed with no plan or completion evidence, and final-audit tasks marked done while earlier work is still open. Every issue carries a severity, a code, and the evidence behind it — so the next agent (or you) can fix it instead of rediscovering it.


Documentation

PageDescription
Getting StartedInstall, init, first task, plans, MCP setup
Core ConceptsWorkspaces, projects, tasks, plans, actors, profiles
CLI ReferenceEvery command and flag with examples
MCPWire into Claude Code, Cursor, Codex, OpenCode
SkillsThe five embedded agentic-loop skills
HTTP APIRoutes exposed by backlog web
Working Across SessionsThree-day cross-session walkthrough

Development

git clone https://github.com/mazen160/backlog
cd backlog
make build      # build binary
make test       # run all tests
make fmt        # gofmt
make vet        # go vet
make cover      # test + coverage report

See CONTRIBUTING.md for the full guide.


Found this useful?

If Backlog saves you a context window, please star the repo — it's the only signal that tells me to keep building it in the open.

Share what you build:

Tweet HN Reddit LinkedIn


Under the hood

The Backlog DB is an embedded SQLite store with WAL mode, full-text search (FTS5), and atomic backups. Backlog itself is written in Go and ships as a single static binary.


License

The project is currently licensed under MIT License.


Author

Mazin Ahmed

Ver o original no GitHub

Bom para

Relacionados