The plan-of-record for AI coding agents
Spec, plan, and drift detection that stay in sync with your code — readable by you, writable by your agent, durable across sessions.
brew install felixgeelhaar/tap/roady After install, run roady demo to see the full spec → plan → drift loop on a sample project in under a minute.
Roady Cloud — coming
Hosted MCP, multi-repo dashboard, audit retention, SOC2. CLI stays MIT forever; Cloud is the open-core paid wedge. Drop your email if you want first access.
Opens your mail client — no third-party form backend, no hidden datastore.
See the roadmap for the full open-core boundary.
Built narrowly, on purpose
/clear and session resets
Spec → plan → execute → detect drift. The same loop whether you write the plan yourself or hand it to an AI agent. Roady doesn't replace your editor or your agent — it gives them durable state to work against.
Analyze your documentation tree. Roady extracts functional features and requirements deterministically.
Decompose features into atomic engineering tasks. Use AI to accelerate this, or write plans manually.
Roady monitors your code and state. If your implementation diverges from your plan, you'll know instantly.
Three days into a feature, your AI agent has forgotten what was decided yesterday and quietly rewritten the wrong file. Roady is the durable answer to what are we building, what's next, and where did reality diverge from the plan?
Plan + execution state live in .roady/, not the model's working memory. Survives /clear.
roady task ready answers it deterministically from the approved plan. No re-deliberation.
Spec-lock + drift detection make divergence loud and actionable instead of accumulating as debt.
Every task carries an Origin (heuristic / ai / human) and a from doc:line citation. AI's choices stay auditable.
Roady has 31 top-level commands. You will spend 95% of your time in five of them. Here they are.
# 1. Hook your AI agent to Roady (one command per supported tool)
roady setup claude-code # or claude-desktop, opencode, openai, gemini
# 2. Initialise + import your existing docs
roady init my-project
roady spec analyze docs/ # parses markdown, captures source citations
# 3. Generate a plan (heuristic by default; --ai for richer decomposition)
roady plan generate
roady plan approve
# 4. Drive execution from inside your AI editor
/roady-task # agent picks the next ready task
# ...agent implements, commits with [roady:task-id] marker...
roady git sync # state moves forward automatically
# 5. Ask the question that matters
roady drift detect # has reality diverged from intent? roady demo scaffolds a sample
project with intentional drift and runs the full loop in under a minute.
Zero AI keys, zero signup.
brew install felixgeelhaar/tap/roady && roady demo
Billing, debt scoring, deps graph, watch mode, dashboards, plugins,
audit verify — everything else lives in
docs/advanced.md, grouped by
audience.
Every Roady operation is an MCP tool. Your agent reads and writes the same
plan-of-record you see in roady status.
One roady setup command per supported tool.
roady_tasks List tasks by status (ready / in_progress / blocked / all)
roady_get_plan Read the approved plan
roady_transition_task Start / complete / block / verify
roady_detect_drift Has reality diverged from intent?
roady_plan_decompose Codebase-aware AI decomposition
roady_drift_recurring Drift unresolved > 7 days
roady_cost_estimate Token + USD pre-flight before AI ops
roady_query NL question over project state
Plus 30+ more — roady openapi emits the full schema. Streamed AI responses arrive as MCP progress notifications when the client subscribes.
roady mcp --transport http --transport ws roady setup claude-code
roady setup claude-desktop
roady setup opencode
roady setup openai
roady setup geminiroady_tasks { status: "blocked" }roady_drift_recurring {}Every MCP tool that returns structured data ships with an interactive D3 view (donut, force-directed graph, gauge, line chart, tree). Renders inside Claude Code's tool panel automatically — no separate dashboard install.
Roady is not a replacement for those. It runs in front of them for the AI-paired workflow — your agent reads and writes Roady, and a plugin keeps the human team's existing tracker in sync as a side effect. No migration, no rip-and-replace.
Pluggable syncers via HashiCorp go-plugin.
Build your own — reference plugins on GitHub.
A background sentinel that reacts to document changes, instantly updating your specification and checking for plan drift.
Roady parses your commit history for [roady:task-id] markers to automate status transitions.
Guard agentic spending with hard token limits and vendor-agnostic routing (OpenAI, Anthropic, Gemini, Ollama).
Sync tasks with external systems via plugins (GitHub Issues, Jira, Linear).
Role-based access, task assignment, optimistic locking, and git-based workspace sync for multi-user workflows.
Public Go client package with typed helpers, versioned MCP schema, and OpenAPI spec generation.