Lazy Backlog

AI-powered Jira intelligence. Not just CRUD — deep insight.

Lazy Backlog is an MCP server that turns your AI assistant into a Jira power user. It indexes your Confluence docs, learns your team's patterns from completed tickets, and uses that intelligence to give Product Owners, Scrum Masters, and Engineers the deep insight they need — without manually collecting data or making the LLM guess.

Ask a simple question, get back analysis built from hundreds of historical tickets, team patterns, velocity data, and quality scores. The complexity is all internal.

What Makes This Different

| You ask | What happens internally | |---------|------------------------| | "Create a ticket for OAuth migration" | Searches KB for context, suggests assignee/points/labels from team patterns, detects duplicates, finds similar resolved work with typical effort range, scaffolds AC from your team's format | | "How's the sprint going?" | Health score, blocker aging, WIP limit warnings, per-person workload balance, stale item detection — one call | | "Prepare my standup" | Per-person digest: completed, started, blocked since yesterday. Aging blockers flagged. New items added mid-sprint highlighted | | "Run my retro" | Velocity trends, cycle time (P50/P75/P90), scope creep %, carryover analysis (chronic slippers flagged), estimation accuracy, workload distribution, sprint-over-sprint comparison | | "Help me plan next sprint" | Velocity average, risk-adjusted capacity, carryover detection, greedy bin-packing of backlog items, per-assignee workload balance, overcommit warnings | | "Triage this bug" | Completeness scoring, severity inference from keywords, sprint recommendation, team convention check, component rework rate warning, recent bug pattern detection | | "Show me the backlog" | Per-item quality flags (orphaned, stale, unestimated, thin), duplicate clusters, aging analysis, health summary |

Every response includes contextual next-step suggestions so the LLM knows what to call next without memorising all the tools.

Installation & Setup

Requires Node.js 18+ and an Atlassian API token.

Claude Code

claude mcp add lazy-backlog \
  -e ATLASSIAN_SITE_URL=https://your-site.atlassian.net \
  -e [email protected] \
  -e ATLASSIAN_API_TOKEN=your-api-token \
  -- npx -y lazy-backlog

Then just ask: "Set up my Jira project" — the AI will prompt you for your project key, board ID, and Confluence spaces, then run setup to get everything ready.

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "lazy-backlog": {
      "command": "npx",
      "args": ["-y", "lazy-backlog"],
      "env": {
        "ATLASSIAN_SITE_URL": "https://your-site.atlassian.net",
        "ATLASSIAN_EMAIL": "[email protected]",
        "ATLASSIAN_API_TOKEN": "your-api-token",
        "JIRA_PROJECT_KEY": "BP",
        "JIRA_BOARD_ID": "266",
        "CONFLUENCE_SPACES": "ENG,PRODUCT"
      }
    }
  }
}

Add to your .mcp.json:

{
  "mcpServers": {
    "lazy-backlog": {
      "command": "npx",
      "args": ["-y", "lazy-backlog"],
      "env": {
        "ATLASSIAN_SITE_URL": "https://your-site.atlassian.net",
        "ATLASSIAN_EMAIL": "[email protected]",
        "ATLASSIAN_API_TOKEN": "your-api-token",
        "JIRA_PROJECT_KEY": "BP",
        "JIRA_BOARD_ID": "266",
        "CONFLUENCE_SPACES": "ENG,PRODUCT"
      }
    }
  }
}

git clone https://github.com/Ricky-Stevens/lazy-backlog.git
cd lazy-backlog
npm install
npm run build

Then point your MCP client at the local build:

{
  "mcpServers": {
    "lazy-backlog": {
      "command": "node",
      "args": ["/path/to/lazy-backlog/dist/index.js"],
      "env": {
        "ATLASSIAN_SITE_URL": "https://your-site.atlassian.net",
        "ATLASSIAN_EMAIL": "[email protected]",
        "ATLASSIAN_API_TOKEN": "your-api-token"
      }
    }
  }
}

Environment Variables

| Variable | Required | Description | |----------|----------|-------------| | ATLASSIAN_SITE_URL | Yes | Your Atlassian site URL (e.g. https://acme.atlassian.net) | | ATLASSIAN_EMAIL | Yes | Atlassian account email | | ATLASSIAN_API_TOKEN | Yes | API token | | JIRA_PROJECT_KEY | No | Default project key (e.g. BP) — can also be set via configure | | JIRA_BOARD_ID | No | Default board ID — required for sprint ops and board-scoped queries | | CONFLUENCE_SPACES | No | Comma-separated space keys to index (e.g. ENG,PRODUCT) | | LAZY_BACKLOG_DB_PATH | No | Custom path for SQLite database (defaults to .lazy-backlog/knowledge.db) |

Settings can also be saved via configure setup, which is the recommended approach since it also discovers your Jira schema, indexes Confluence, and learns team conventions.

Tools

8 tools, 25 actions. You don't need to memorise them — just describe what you want and the AI picks the right one.

configure — Get Started

Run setup once to connect everything. It discovers your Jira schema, indexes Confluence docs, analyzes completed tickets to learn conventions, and reports on data quality.

| Action | What it does | |--------|-------------| | setup | Run this first. Connects Jira + Confluence, learns team patterns. Returns data quality report with pass rates and top weaknesses. | | set | Save a single setting | | get | Show config status with setup freshness indicator and re-run recommendations |

"Set up my Jira project BP with board 266 and index ENG and PRODUCT spaces"

insights — Team Intelligence & Analytics

The intelligence hub. Every action returns deep analysis, not just raw data.

| Action | What it does | |--------|-------------| | team-profile | Who owns what, estimation accuracy, description patterns, rework rates, conventions. Flags anomalies: single points of failure, slow components. Zero API calls — reads stored analysis. | | epic-progress | Completion stats with velocity-based forecast and confidence intervals. Detects blocker chains across epic children. | | retro | Auto-detects the right sprint. Returns velocity trends, cycle time (P50/P75/P90), scope creep, carryover (chronic slippers flagged), estimation accuracy, workload distribution, sprint-over-sprint comparison vs 3-sprint average. | | plan | Sprint planning assistant. Computes risk-adjusted capacity from velocity + historical carryover rate. Greedy bin-packing of backlog items with assignee suggestions from ownership data. Overcommit and low-capacity warnings. |

"Show me the team profile" "How's epic BP-100 looking?" "Run my retro" "Help me plan next sprint"

issues — Create & Manage Tickets

Create, update, search, and decompose Jira issues. Creates always preview first — you see a rich card with everything before anything hits Jira.

| Action | What it does | |--------|-------------| | get | Full issue details with cycle time context vs team averages. Flags at-risk items exceeding P75 cycle time. | | create | Single ticket, bulk (pass tickets array), or epic decomposition (pass epicKey). Preview includes smart defaults, team conventions, KB context, duplicates, and similar resolved issues with typical effort range. | | update | Modify fields, transition status, assign, rank, link, remove links. Shows enrichment suggestions for missing fields. On status transition to Done: shows impact ripple (unblocked issues + epic progress delta). | | search | Universal JQL search (auto-scoped to project). Results include analytics: status breakdown, average age, priority distribution, unassigned count. |

"Create a task for migrating to OAuth2" — review preview — "Looks good, confirm" "Search for open bugs in the payments component"

bugs — Triage Pipeline

Complete bug assessment in one call. No more bouncing between find, assess, and triage.

| Action | What it does | |--------|-------------| | triage | Scores completeness (steps to reproduce, expected/actual, environment). Infers severity from keywords. Recommends sprint placement. Evaluates team conventions. Warns about high-rework components. Detects bug patterns (3rd bug in 'payments' this month — systemic issue?). Optionally auto-applies with autoUpdate=true. |

"Triage BP-45 and BP-67"

For bug searches, use issues search with type = Bug JQL.

backlog — Board Backlog with Health Intelligence

Every backlog view is a health check.

| Action | What it does | |--------|-------------| | list | Backlog items with per-item quality flags (orphaned, stale, unestimated, thin descriptions). Always-on duplicate detection. Aging analysis: items bucketed by age with stale item warnings. Health summary footer. | | rank | Reorder items with impact preview: shows issue context, story points, and what % of team velocity this item would consume if pulled into the next sprint. |

"Show me the backlog" "Move BP-42 to the top"

For JQL-filtered queries, use issues search with sprint is EMPTY.

sprints — Sprint Management

Context-adaptive sprint views that give you the right information for the right moment.

| Action | What it does | |--------|-------------| | list | Sprints with quick health indicators for active sprints (completion %, days left, SP progress) | | get | Context-adaptive. Active sprint: full dashboard with health, blockers, WIP limit warnings, per-assignee workload. Pass since=24h for standup digest (per-person completed/started/blocked). Closed sprint: release notes grouped by type (features, bugs, tech debt), carryover, metrics. | | create | New sprint with optional goal. Returns capacity pre-calculation from team velocity. | | update | Set goal (with alignment check — what % of sprint items relate to the goal), rename, modify dates. | | move-issues | Assign issues to sprint with capacity impact analysis. Warns on overcommitment vs team velocity. |

"How's the current sprint going?" "Prepare my standup" "What did we ship last sprint?" "Move BP-42 and BP-43 into the next sprint"

knowledge — Search & Explore Your Docs

Source-agnostic knowledge base with built-in intelligence.

| Action | What it does | |--------|-------------| | search | Full-text search across all indexed content. Results include intelligence: type/source/age breakdown, staleness warnings. | | stats | KB dashboard: counts, context summary (ADRs, designs, specs), recent changes, stale docs, health indicator, coverage gap detection (undocumented components, missing ADRs/runbooks). | | get-page | Full page content with freshness indicator, related pages, and Jira ticket references. |

"Search docs for authentication" "How's the knowledge base looking?"

confluence — Index & Write-Back Confluence

Spider Confluence spaces into the knowledge base and publish back. To search indexed content, use knowledge.

| Action | What it does | |--------|-------------| | spider | Crawl and index pages. Content-hash incremental sync — re-indexes when body or metadata (labels) changes, not just when updatedAt advances. Returns quality report: content depth, type distribution, pages needing classification review. | | list-spaces | Show available Confluence spaces | | publish | Create or update a page from markdown. Preview-and-confirm gated — without confirm: true returns a preview only; never auto-writes. Pass pageId to update (uses optimistic concurrency on the page version), or spaceKey + title to create. Optional parentId for nesting. |

"Re-index the engineering docs" "Publish this design doc to the PRODUCT space" → review preview → "Confirm"

Rich Content Fidelity

Lazy Backlog preserves rich content end-to-end instead of flattening it to plain text:

• Tables round-trip both directions (markdown pipe tables ↔ Jira ADF, Confluence storage <table>).
• Panels & blockquotes are preserved as admonition syntax (> **Note:**, > **Warning:**, etc.) and rendered back into the right ADF/storage node on the way out.
• Confluence macros — info / note / warning / tip panels, code macro (with language), expand, status, toc, jira issue macro — are rendered into markdown instead of being stripped. Unknown macros degrade gracefully to their inner text.
• Images & media — Confluence <img> / <ac:image> and Jira ADF media / mediaSingle / mediaGroup nodes are surfaced as markdown ![alt](url). Confluence image references are resolved against the page's attachment manifest so diagram URLs work.
• Security invariants kept — <script> / <style> and event handlers are never emitted by the markdown→storage converter, even on round-trip.

Attachments & Downloads

| Capability | How | |------------|-----| | Surface Jira attachments | issues get lists filename, mime type, human-readable size, author, created date, and download URL. Image attachments are flagged. | | Upload to Jira | issues create / issues update accept an attachments array of local file paths. Files are validated before upload — must exist, ≤10MB each, ≤50MB per batch — and symlinks are rejected so the server can't be tricked into uploading arbitrary local files. The API token is never logged. | | Download from Jira | issues get with download: true fetches attachment bytes to the configured directory. Optional attachmentIds filter selects specific files. | | Confluence page attachments | Spider fetches the per-page attachment manifest. knowledge get-page lists attachments and resolves inline image references. | | Download from Confluence | knowledge get-page with download: true saves selected attachments to disk. |

Safety rails on downloads:

• Filenames returned by the server are sanitised against path traversal (.., absolute paths, separators are stripped).
• A size cap is enforced per file; content-type is recorded.
• Download URLs are validated with the same validateSiteUrl / PRIVATE_HOST_RE guard used for the configured site — Atlassian may serve media from a different host, but it is validated, not blindly fetched. Redirects are followed manually and the final URL is re-validated (no SSRF via a redirect to a private host).
• Files are saved only into the configured directory (see downloadDir below).

downloadDir config key

Where downloaded attachments are saved. Defaults to $HOME/lazy-backlog-downloads. Set it via:

configure set --downloadDir /absolute/path/to/dir

This is the only user-controlled disk-write location and the single source of truth: issues get / knowledge get-page always write to it via the download flag — there is intentionally no per-call directory override (a malicious or prompt-injected client must not be able to redirect writes elsewhere). configure set validates it (absolute path, no .. segments, not under a forbidden system path).

Spec → Ticket Loop

The Stage D workflow closes the loop between Confluence specs and Jira work — without adding new actions:

• Spec → tickets. Pass sourcePageId to issues create to ground the generated epic + child tickets in a Confluence page from the KB. The preview inlines the spec context (tables, images, panels all preserved per A). On confirm, the epic is linked back to the source page (KB spec-link + Jira remote issue link). Use it for one-off creates, bulk creates, or epic decomposition.
• Status → spec. insights epic-progress renders an Implementation Status markdown block ready to feed into confluence publish (confirm-gated) so the spec page tracks what shipped.
• Freshness loop. When the epic completes, the source spec is automatically flagged stale and an "update the spec" suggestion is surfaced.

Example Workflows

First-Time Setup

"Set up my Jira project and index our engineering docs"

The AI asks for your project key, board ID, and Confluence spaces, then runs setup. Schema discovery, doc indexing, team analysis — one call. Returns a data quality report showing your team's strengths and areas for improvement.

Sprint Planning

"Help me plan the next sprint"

Returns risk-adjusted capacity (factoring historical carryover and estimation bias), recommends backlog items that fit, suggests assignees from ownership data, warns on overcommitment.

Daily Standup

"Prepare my standup"

Per-person digest: what was completed, started, or blocked since yesterday. Aging blockers flagged. New items added mid-sprint highlighted. No manual Jira trawling needed.

Ticket Creation

"Create tickets for migrating to the new payment gateway"

Rich preview with KB context, smart defaults from team patterns, duplicate detection, similar resolved work with typical effort range, and acceptance criteria scaffolded from your team's actual template format. Review it, then confirm.

Sprint Retrospective

"Run my retro"

Velocity trends, cycle time analysis, scope creep quantification, chronic carryover detection, estimation accuracy, workload balance assessment, and sprint-over-sprint comparison — all in one call.

Bug Triage

"Triage the latest bugs"

Complete pipeline per bug: completeness scoring, severity inference, sprint recommendation, team convention evaluation, component rework rate warnings, and pattern detection (is this component seeing a spike?).

Development

npm install          # Install dependencies
npm run check        # Typecheck + lint + test (all at once)
npm run typecheck    # TypeScript strict mode
npm run lint         # Biome linter
npm test             # Vitest (1300+ tests)
npm run build        # Compile to dist/

Why Not Atlassian Rovo?

Atlassian has Rovo, and it may well catch up over time. But right now, there's a fundamental difference in approach.

Rovo is CRUD with a chat interface. It can create tickets, search issues, and answer questions about your Jira data. It's a natural language wrapper around the Atlassian API. Ask it to create a ticket and it creates a ticket. Ask it about your sprint and it shows you the sprint board.

Lazy Backlog is an intelligence layer. It doesn't just read and write Jira — it learns your team's patterns from completed tickets, indexes your documentation, and uses that context to give you insight you didn't ask for but actually need:

• Rovo creates a ticket. Lazy Backlog creates a ticket and tells you that 3 similar tickets were resolved at 3-5 SP over 4-6 days, suggests the right assignee based on component ownership, scaffolds acceptance criteria from your team's actual format, and warns you about duplicates.
• Rovo shows you the sprint. Lazy Backlog shows you the sprint and flags that Alice has 4 items in progress (WIP limit exceeded), the payments component has had 3 bugs this month (systemic issue?), and you're overcommitted by 18% against your velocity.
• Rovo runs a search. Lazy Backlog runs a search and gives you the status breakdown, average age, priority distribution, and notes that 3 results are unassigned.

The value isn't in the CRUD operations — any tool can do those. The value is in the intelligence that helps Product Owners, Scrum Masters, and Engineers make better decisions without manually collecting data or asking the right questions. Lazy Backlog does the heavy lifting internally and surfaces what matters.

Rovo will likely get smarter. But the bar for "good enough" in agile intelligence is high, and the open-source community can move fast. Contributions welcome.

License

MIT