Planning tools that agents can use

Give agents a plan
they can use.
And verify.

Maps are tools for agents: structured, Git-native plans they can read, update, and use to guide work. Give your agent explicit dependencies, executable checks, and acceptance criteria you can review together.

Node.js + TypeScript · CLI + library + agent skills

API RELEASEmap/api-release

A plan an agent can use.

Read the plan. Find ready work. Verify results.

DEPENDENCY SATISFIED

The schema is complete. An agent can work on authentication and verify it against the declared acceptance criteria.

↳ Click a step to exploreIllustrative Map
Structured for agentsReviewable by peopleChecks built into the plan

FROM INTENT TO EVIDENCE

Give your agent
a way forward.

A Map gives an agent the context to choose ready work, follow dependencies, and check results. People define the outcome and review progress in the same plan.

01

Make the outcome concrete.

Give the agent a clear goal, stable step IDs, and acceptance criteria before implementation begins.

Plan a Map ↗
02

Connect the dependencies.

Let the agent inspect which steps are ready and which are blocked. Each step waits for all its prerequisites.

Explore the format ↗
03

Keep evidence with the plan.

Have the agent run declared checks against the implementation and record the tested revision. Review that evidence before marking a step done.

See verification ↗

TESTING, VALIDATION & EXECUTION

Plan the checks.
Run them.
Keep the evidence.

Testing belongs in the plan from the start. Each step can declare the checks an agent should run and the criteria a person should review.

MapForge validates the plan’s structure. The agent explicitly invokes test execution against the implementation, then uses the recorded results to assess completion.

Explore testing & validation ↗
01

Define what passing means.

Attach test commands and acceptance criteria to steps before implementation. Use unit tests, integration checks, or project-specific validation scripts.

02

Validate the plan before execution.

Check the graph, required documents, and completion evidence. Invalid references, dependency cycles, and unmet prerequisites stop invalid plan updates.

03

Execute ready checks explicitly.

The agent calls mapforge test to run declared checks in the implementation checkout. Blocked steps are skipped; each check has a two-minute timeout.

04

Record results. Review completion.

Keep passes, failures, and the tested revision with the plan. Passing checks leave completion for review; failed reruns reset affected steps and dependent completion. Revalidate after relevant changes.

See the execution and evidence workflow ↗

GIT-NATIVE, BY DESIGN

Your code has a history.
Your plan should too.

Maps live on their own map/<id> branches in managed planning worktrees. Keep developing in your checkout while the plan keeps its own history.

Understand the architecture ↗
PLANNING WORKTREE map/api-release
maps/api-release/
├── map.md               the outcome
├── map.yaml             the graph
├── steps/
│   ├── schema/step.md
│   ├── auth/step.md
│   └── verify/
│       ├── step.md
│       └── verify.sh     the check
└── operations/          the receipts

Readable files. Explicit updates. Reviewable history.

ONE PLANNING SYSTEM. THREE WAYS IN.

Put Maps within
your agent’s reach.

>_

At the terminal

Give agents and scripts a JSON-speaking CLI to inspect plans, update steps, and run verification.

CLI reference ↗
✳

Through agent skills

Load workflows that guide an agent through planning, updates, status, verification, and explicitly requested publication.

Agent workflows ↗

START SMALL. BUILD WITH DIRECTION.

Give your agent
its next Map.

Build from source and give your agent a plan it can inspect, update, and verify.

Read the getting started guide ↗
LOCAL CHECKOUT · NODE ≥22.22
git clone https://github.com/BillingsTechnology/MapForge.git
cd MapForge
npm ci
npm run build
node dist/cli.js --help

v0.1.0 · In active development · Build locally today