Rebar MCP server

rebar

An event-sourced, git-backed ticket store + Jira reconciler built for agent swarms — one store, exposed as a Python library, a CLI, and an MCP server.

library (import rebar), or an MCP server (rebar-mcp).

• Three surfaces, one store — drive rebar as a CLI (rebar), a Python

tickets git branch; no database, no daemon, and it travels with every clone.

• The tracker lives in the repo — tickets are an append-only event log on a

links let many agents and sessions write at once without lost work.

• Built for parallel agents — atomic claims, convergent merges, and provenance

before close, and its code before it merges.

• Optional LLM gates — review a ticket's plan before work, its completion

in step, so teammates stay in the loop.

• Bidirectional Jira sync — a level-triggered reconciler keeps tickets and Jira

must pass an LLM code review and CI, on Gerrit, before it lands.

• Dogfooded through two independent gates — every change to rebar's own main

Install

pipx install nava-rebar          # the `rebar` CLI (add [mcp] / [agents] for those extras)
brew install navapbc/rebar/rebar # or via Homebrew

Quickstart

Run one ticket end-to-end with the CLI or the Python library; the JSON block is the MCP server config so agents can drive the same loop over MCP. rebar --help (and rebar --help) is the authoritative command reference.

# CLI: one ticket through init -> create -> ready -> claim -> close
rebar init
tid=$(rebar create task "Add a login page" -o json | python3 -c 'import json,sys; print(json.load(sys.stdin)["id"])')
rebar ready                                              # lists it as ready to work
rebar claim "$tid"                                       # open -> in_progress
rebar transition "$tid" in_progress closed              # in_progress -> closed

import rebar                                            # the same loop via the Python library
tid = rebar.create_ticket("task", "Add a login page")
rebar.claim(tid)
rebar.transition(tid, "in_progress", "closed")

{ "mcpServers": { "rebar": { "command": "uvx", "args": ["--from", "nava-rebar[mcp]", "rebar-mcp"] } } }

That's the whole loop — init → create → ready → claim → close. The CLI and Python blocks each drive one ticket end-to-end (the same id threaded through every step, no hard-coded id); the JSON is the MCP server config — add it to your client so an agent can run the same loop via the MCP tools. State is shared through the repo so many agents (and teammates via Jira) coordinate without stepping on each other.

How it works

rebar stores tickets as an append-only event log on a dedicated tickets git orphan branch (worktree at .tickets-tracker/); ticket state is computed by replaying events, and every write auto-commits and pushes so the store is shared immediately. A level-triggered reconciler bidirectionally syncs tickets with Jira. The branch name and worktree dir are configurable (tracker.branch / tracker.dir — see Configuration). Reads stay sub-second into the thousands of tickets; for measured numbers and git-growth expectations see docs/scale-envelope.md.

Shortened. The full README is on GitHub.