SPUR

The control tower for your CLI coding agents.
Plan with one agent. Delegate to many. Review every change in one terminal.

Website · Documentation · Demos · Quick start · Contributing

[!WARNING] SPUR is early-stage software. APIs, configuration, and workflows may change while the project stabilizes.

Featured demo

spur-dag-aware-multi-agent.webm

_{Watch the 85-second WebM demo — a brain plans the work, parallel agents execute it, and SPUR brings every result back to one review lane.}

Why SPUR

Running one coding agent is simple. Running several across vendors, repositories, and worktrees quickly becomes an operations problem.

SPUR is a Rust-native terminal application that sits above the agents you already use. It turns a task or issue into a durable plan, delegates work into isolated git worktrees, streams progress into one TUI, and keeps a human in control of every change that reaches the staging branch.

Capability demos

Eight focused capability demos — plus the featured walkthrough above — cover the full SPUR workflow in under nine minutes. Follow them in order for a guided tour, or jump directly to the capability you need.

1. Get productive

Install, detect, initialize

spur-install-and-init.webm

_{Watch the 1:10 WebM demo — install the npm package, let spur init discover agent and PM tools, choose a brain, review permission settings, and launch the TUI.}

Learn the keyboard model

spur-help-and-shortcuts.webm

_{Watch the 8-second WebM demo — open the built-in help, understand navigation and compose modes, and learn the shortcuts for panels, lineage, review, and session control.}

2. Control the workspace

Navigate sessions and commands

spur-session-navigation.webm

_{Watch the 13-second WebM demo — open the session picker, return to prior work, inspect lineage, and use the universal command palette without leaving the keyboard.}

Tour the operating surfaces

spur-tui-tour.webm

_{Watch the 36-second WebM demo — move through the command palette, lineage and worker views, sprint browser, plan inspector, and the task detail surfaces used during real work.}

3. Orchestrate real work

Follow live delegation

spur-live-delegation.webm

_{Watch the 1:26 WebM demo — watch a brain dispatch complementary reviews to multiple vendors, follow each worker in real time, and keep the active fleet visible in one terminal.}

Use Kiro as a cross-vendor brain

spur-kiro-brain-multi-agent.webm

_{Watch the 1:59 WebM demo — run Kiro as the orchestrator while Gemini, Kimi, and Codex inspect the same code from distinct angles, then bring their outcomes back for consolidation.}

4. Explore code with spur-graph

spur-graph-explore-code.webm

_{Watch the 33-second WebM demo — resolve current source, follow consumers, and assemble a concrete impact model from graph-backed evidence. The spur-graph guide covers the underlying pipeline and query surface.}

5. Prove constraints with spur-solver

spur-tui-solver.webm

_{Watch the 67-second WebM demo — translate a real engineering question into constraints, return concrete sat models, and separate correctness gaps from explicit design limits. The spur-solver guide explains the model-finding loop.}

DAG-aware planning and integration · 1:25. The featured demo above shows staged dependencies, parallel branches, plan inspection, and convergence into one review flow.

Quick start

You need Git and at least one supported coding-agent CLI installed and authenticated.

npm install -g @getspur/spur-cli

cd your-project
spur init
spur

spur init discovers available agents and creates the project configuration under .spur/. Once the TUI opens, enter a task directly or select one from your project-management integration.

Validate the generated configuration at any time:

spur config check

Prefer not to install globally? Run SPUR through npm:

npx @getspur/spur-cli tui

How it works

flowchart LR
    task["Task or issue"] --> brain["Brain agent"]
    brain --> plan["DAG plan"]
    plan --> worktrees["Isolated worktrees"]
    worktrees --> worker1["Worker A"]
    worktrees --> worker2["Worker B"]
    worktrees --> worker3["Worker C"]
    worker1 --> review["Review lane"]
    worker2 --> review
    worker3 --> review
    review --> staging["DAG-ordered staging branch"]

• The brain reasons about the task, chooses workers, and submits a plan.
• Workers execute bounded subtasks concurrently in isolated worktrees.
• SPUR records lineage, events, outcomes, and cost while work is running.
• The review lane keeps integration human-controlled; rejected work can retry with your feedback.
• Approved commits land on a staging branch in dependency order.

SPUR speaks Agent Client Protocol to agents and exposes delegation tools over MCP. It coordinates agents; it does not replace their in-session experience.

Core capabilities

• Cross-vendor brain switching. Move orchestration between vendors when a model rate-limits or a different agent is a better fit.
• Parallel and DAG-aware delegation. Dispatch independent work concurrently while preserving dependency order.
• Structured review and retry. Every completion becomes a reviewable result with bounded Reflexion-style retries.
• Local-first durability. Plans, events, and outcomes remain inspectable on disk and recover after interruptions.
• Unified analytics. Read supported vendors' local session data into one DuckDB-backed cost and usage view.
• Plan mutation. Split, replace, or amend work while a plan is in flight.
• Multi-brain safety. Ownership and session checks prevent two orchestrators from mutating the same plan accidentally.
• Code-graph context. Stable symbol IDs, call edges, documentation sections, and incremental indexing support code-aware retrieval.

Scope

SPUR is an orchestration and review layer for a fleet of coding agents.

It is not an IDE, chat client, CI/CD system, or fully autonomous “set and forget” engineer. The review gate is intentional. SPUR works alongside your editor, project-management tool, and agent subscriptions rather than replacing them.

Native project-management support currently covers beads and GitHub Issues through gh.

Configuration

Configuration lives in .spur/config.toml. Agent entries describe the executable, transport, role, permissions, cost tier, and delegation hints used by the brain when routing work.

• Start with spur init.
• Browse the example configuration.
• Read the configuration guide.

Documentation

Development

Clone the repository, then use the workspace wrapper for Rust commands:

git clone https://github.com/getspur/spur.git
cd spur

scripts/spur-cargo build --workspace
scripts/spur-cargo test --workspace
scripts/spur-cargo clippy --workspace -- -D warnings
scripts/spur-cargo fmt --all

See CONTRIBUTING.md for test tiers and contribution conventions.

Workspace map

Crate	Responsibility
spur-cli	Binary entry point and CLI commands
spur-core	Orchestration, review, lineage, and the event pipeline
spur-acp	ACP clients, transports, capabilities, and event types
spur-tui	The ratatui terminal interface
spur-mcp	Delegation tools exposed to brain agents
spur-context	DuckDB analytics and agent-log extractors
spur-cost	Pricing registry and session ledger
spur-graph	Tree-sitter code graph and stable symbol identities
spur-analyst	DuckDB-backed graph and documentation analysis
spur-worktree	Worktree isolation, liveness, and cleanup
spur-pm	Project-management adapters
spur-interactive	Frontend bridge for non-TUI clients
spur-bot	Telegram frontend
spur-blob-store	Content-addressed delegation outcomes
spur-license / spur-license-admin	License and feature-key registry

Telemetry and privacy

Tier 1 crash diagnostics and performance telemetry are on by default; Tier 2 usage telemetry is opt-in.

Disable telemetry for one run:

SPUR_TELEMETRY=0 spur

Or disable it persistently:

spur telemetry disable all

See the privacy documentation for collected fields, retention, and deletion steps.

Community and license

Issues, feature requests, and pull requests are welcome. Start with CONTRIBUTING.md, open a GitHub issue, or send product feedback through getspur.dev/feedback.

SPUR is licensed under the GNU General Public License v3.0 only (GPL-3.0-only). The Community tier requires no license key; paid feature entitlements are separate from the source license.