Skip to main content
Local-first evidence layer for AI-authored software changes

Git-native infrastructure for traceable AI work.

AgentPlane records what an AI agent was asked to do, which plan was approved, what changed, which checks ran, and why the work is safe to merge or revert - all as reviewable artifacts inside your Git repository.

task → plan → approve → implement → verify → finish

Generate your first ACRView on GitHub
  • No hosted runtime
  • No telemetry
  • No vendor lock-in
  • Your repository stays the source of truth
AgentPlane CLI demo showing task evidence and ACR generation

The diff is not the whole story.

AI agents can produce real code changes faster than teams can reconstruct why those changes happened. A pull request shows what changed. It rarely shows what the agent was asked to do, which plan was approved, which checks actually ran, or why the work is safe to merge.

  • What task was the agent executing?
  • Which plan constrained the change?
  • What verification evidence exists?
  • Can another human or agent safely review, merge, or revert it?

One agent task. One reviewable evidence trail.

Quickstart shows the repo-visible artifact shape before you let an agent touch product code. Reviewers do not need to trust an agent transcript; they can inspect files, commits, checks, hashes, and the ACR.

First visible payofflocal
$agentplane task new --title "Demo task" --owner <agent-id> --tag docs$agentplane task plan set <task-id> --text "Inspect the artifact."$agentplane task start-ready <task-id> --author <agent-id> --body "Start: inspect artifacts."$agentplane task verify-show <task-id>$ls .agentplane/tasks/<task-id>/
npm i -g agentplane
agentplane init
agentplane quickstart
View on GitHub

Extensions, not the core story.

Recipes are optional signed packages for teams that want reusable agent profiles, prompt modules, skills, or repository mapping assets.

Start with the task -> plan -> verify -> ACR flow first; add recipes only when you need reusable behavior.

AgentPlane does not replace your stack.

Claude Code, Codex, Cursor, Aider, Git, CI, and PR review keep their jobs. AgentPlane records the missing evidence around their work.

Claude Code / Codex / Cursor / Aider

They generate or edit code; AgentPlane records the review trail around the work.

AGENTS.md alone

Policy text tells agents what to do; AgentPlane turns policy into lifecycle artifacts and gates.

Git alone

Git stores the final diff; AgentPlane stores task intent, plan, verification, and closure.

Hosted dashboards

They move workflow state elsewhere; AgentPlane keeps the durable record in the repository.

Read comparison

How AgentPlane wraps AI work.

Use any coding agent. Keep the evidence in Git.

01

Create a task before mutation

Record the scope before the agent edits files.

02

Approve a plan

Keep the intended route visible before implementation.

03

Let your agent work

Use Claude Code, Codex, Cursor, Aider, or another coding agent.

04

Verify and finish with Git context

Attach checks, notes, CI results, findings, commit metadata, and ACR.

AgentPlane does not replace your agent, editor, terminal, or Git.

.
|-- AGENTS.md
`-- .agentplane/
    |-- WORKFLOW.md
    `-- tasks/<id>/
        |-- README.md
        |-- pr/
        `-- acr.json

What AgentPlane writes.

AgentPlane creates ordinary repository artifacts that can be inspected, reviewed, and committed with the rest of your project.

  • `AGENTS.md` is the repository policy gateway.
  • `.agentplane/WORKFLOW.md` is the workflow contract.
  • `.agentplane/tasks/<id>/` stores task state, plan, verification, and PR artifacts.
  • `acr.json` is a machine-readable Agent Change Record.
  • Git remains the source of truth.
Read the docs

Agent Change Record: the evidence file for AI work.

Every meaningful agent change should leave behind one machine-readable record: task intent, approved or waived plan, agent and toolchain identity, Git base and work commits, policy decisions, verification results, and merge readiness.

ACR reviewer pathlocal
$agentplane acr generate <task-id> --work-commit HEAD --write$agentplane acr validate <task-id> --mode local$agentplane acr check <task-id> --mode ci$agentplane acr explain <task-id>

Humans read `acr explain`. CI reads `acr check`. External tools read `acr.json`.

Read the ACR spec

AI work is becoming repository work.

Agents are no longer just drafting snippets. They edit real repos, open branches, run checks, change docs, touch release paths, and leave reviewers with incomplete context. The next failure mode is not whether the agent can write code; it is whether the team can reconstruct, verify, and govern what happened.

Read why

Choose your path.

New to AgentPlane?

Start with the 90-second local task and see the first evidence artifact before the abstractions.

Start quickstart

Using Claude Code or Codex?

Open the workflow guide for your agent and keep the work reviewable after the session is gone.

Open workflows

Reviewing agent PRs?

Add task evidence and ACR validation before merge.

Read ACR

Comparing alternatives?

See how AgentPlane differs from coding agents, AGENTS.md, Git-only workflows, CI, and hosted dashboards.

Read comparison

Building extensions?

Read the recipe model after you understand the core evidence trail.

Open recipes

Make AI work reviewable in Git.