Turn any goal into shipped code.
prd-taskmaster by Atlas AI is an open-source engine for Claude Code that takes a one-line goal, interviews you like a senior PM, writes a graded, placeholder-proof PRD, compiles it into a dependency-ordered task graph, and executes every task with verification evidence — so "done" means proven, not claimed.
Free and MIT, forever.
⚠️ Pre-alpha — under active development. Atlas was recently consolidated into this engine and the newer systems (fleet orchestration, backend abstraction, token economy) have not been fully tested in the wild yet. Expect rough edges and breaking changes between releases, pin a version if you need stability, and please report what breaks. No warranty beyond the MIT license. Atlas Pro is not generally available — it is a private pilot (see below).
Atlas has four structural moats:
- cross-vendor fleet — Claude, Codex, and Gemini run as separate quota pools instead of one brittle model lane.
- Engine-enforced unfakable gates —
validate-tasks, evidence checks, andSHIP_CHECK_OKmake completion a deterministic state, not a claim. - persistent vendor-neutral
tasks.json— your PRD, task graph, and execution state stay as plain repo files that survive vendor swaps. - token-economy cost ledger — every orchestrated model call records routing, exit, latency, and escalation so cheap models do cheap work and expensive models justify themselves.
Atlas speaks TaskMaster natively — but doesn't need it. Existing TaskMaster projects get a
migration funnel: install task-master-ai only when you want the TaskMaster backend, while the
native backend keeps the same validated task graph available without that prerequisite.
Grade: GOOD ▰▰▰▰▰▰▰▰▱▱ 49/57 (86%) · 0 placeholders · 14 tasks parsed
How it works
goal → discovery interview → graded PRD → dependency-ordered task graph → verified execution
- Preflight — detects your environment (native backend, optional TaskMaster backend, model CLIs, research) and configures it. Zero setup questions.
- Discovery — an adaptive, one-question-at-a-time interview captures your real constraints.
- Generate — writes a PRD, scores it against deterministic quality checks (letter grade), then parses it into a task graph with complexity scores and full subtask coverage.
- Handoff — detects what you have installed and recommends one execution mode.
- Execute — a CDD-gated loop implements each task and proves it with evidence, ending in a deterministic
SHIP_CHECK_OKtoken.
Quickstart
90 seconds to your first run.
Path 1 — one-liner (recommended)
curl -fsSL https://atlas-ai.au/install | bash
# installs the skill + prd_taskmaster package
# TaskMaster install is optional — unlocks the TaskMaster backend
Path 2 — Claude Code plugin
# add the marketplace, then install the plugin
/plugin marketplace add anombyte93/prd-taskmaster
/plugin install prd
# optional — unlocks the TaskMaster backend
npm install -g task-master-ai
First run
Open any project in Claude Code and type:
/prd:atlas (or /prd:go, or just say: "I want to build …")
Requires Python 3.11+ and Linux / macOS / WSL. The free engine needs no paid API key — it
uses the model CLIs you already have; an optional local research proxy can be plugged in
(bring your own — not bundled). npm installs run a postinstall step that pip-installs the
MCP server's Python deps (non-fatal warning if pip is unavailable).
What "verified" means
Most AI coding tools tell you a task is done. This one makes "done" provable:
- Graded PRDs. Every spec is scored against deterministic checks (EXCELLENT / GOOD / ACCEPTABLE / NEEDS WORK). Placeholders (
TBD,{{...}},TODO— bare or bracketed) are a hard fail: the grade floors to NEEDS WORK andvalidate-prdexits non-zero. - A real task graph. Requirements become backend-neutral
tasks.jsontasks with dependencies, complexity scores, and full subtask coverage — not a flat checklist. - Evidence-gated execution. Each task is implemented and must produce execution evidence before it counts as done.
- A completion token you can trust.
SHIP_CHECK_OKis emitted only when every gate passes — and a single non-zeroExit statusin any evidence file blocks it. It is structurally hard to fake. (One escape hatch exists for incident recovery: an explicit admin override flag that is audit-logged and marks the token[OVERRIDE]on stdout — never silent.)
┌─ atlas ── PHASE 3/4: GENERATE ─────────────────────────────┐
│ Grade: GOOD ▰▰▰▰▰▰▰▰▱▱ 49/57 (86%) │
│ ✓ 11 checks passed structure · testability · metrics │
│ ⚠ 2 warnings (quoted + located, not just counted) │
│ ✓ 0 placeholders (TBD/TODO/{{...}} scan clean) │
│ Tasks: 14 parsed · 52 subtasks · dependencies mapped │
└────────────────────────────────────────────────────────────┘
Project status
Pre-alpha. The deterministic core — graded PRD validation, the task graph, the ship-check
gate, the CLI — is covered by ~300 tests and is the most stable surface. The newer systems
around it (cross-vendor fleet, backend abstraction, the token-economy ledger, the bundled Pro
MCPs) are recently built and not yet battle-tested; their numbers (e.g. cost savings) are
verified-rate estimates, not measured guarantees (see
docs/product/MODEL-ECONOMY.md). Expect breaking changes
between releases; pin a version for stability. Bug reports and use-case notes are the fastest way
to move it toward stable — open an issue.
Built for the token-shortage era
Every job runs on the cheapest model that can do it — and escalates only when a validator says it failed. One setting controls how aggressive that is:
// .atlas-ai/fleet.json
{ "token_economy": "conservative" } // or "balanced" (default) / "performance"
Task decomposition and research run through the selected backend. Native mode works without a
TaskMaster install; installing task-master-ai >= 0.43.0 unlocks TaskMaster's model-agnostic AI
(any API you configure — Anthropic, OpenAI, Perplexity, Gemini, openai-compatible…) and isolated
workdir expansion when that backend is selected. Complexity 2 scaffolding gets a haiku-class
model; the hardest long-running work gets the frontier model; nothing defaults to expensive.
Local telemetry (economy-report) shows your real success-rate and latency per model so the
routing gets smarter on YOUR workload — priors and sources in
docs/product/MODEL-ECONOMY.md.
Free vs Atlas Pro
Atlas Pro is in private pilot — not generally available and not yet for sale. Pricing is not set. During the pilot, access is granted at our discretion to testers with a strong use case (often free). The table shows what Pro will add; the Pro-only rows are experimental and not fully tested. Want in? Request pilot access → (an on-site signup at
atlas-ai.au/pilotto be notified at launch is coming).
| Free (MIT) | Atlas Pro — private pilot | |
|---|---|---|
| Discovery interview (adaptive, one question at a time) | ✓ | ✓ |
| Graded PRD validation + placeholder scan | ✓ | ✓ |
Dependency-ordered task graph (tasks.json) |
✓ | ✓ |
| Verified solo execution — evidence required per task | ✓ | ✓ |
| Model-agnostic: Claude / Codex / Gemini | ✓ | ✓ |
| Parallel research fan-out | ✓ | ✓ |
| Token economy — start cheap, escalate only on failure (conservative/balanced/performance) | ✓ | ✓ |
| Optional TaskMaster backend expansion — any configured API, isolated workdirs | ✓ | ✓ |
Local cost telemetry + economy-report |
✓ | ✓ |
| Adaptive routing auto-tuning from telemetry | — | ✓ (roadmap) |
| Atlas Fleet — parallel waves of isolated workers, checker-gated merges, one final PR | — | ✓ |
| Browser-verification MCP (UI proof, not just logs) | — | ✓ |
| Secrets-vault MCP (keys never in your repo or prompts) | — | ✓ |
| License & priority support | community | ✓ |
The engine is the whole engine — the free tier is not a demo. Pro adds the fleet orchestrator and bundled MCPs (both pilot-stage, not fully tested). Request pilot access →
Atlas Fleet (Atlas Pro)
When a build is big enough to want overnight parallelism, Atlas Fleet lifts the same engine
from one session to many. It splits your task graph into dependency waves of file-disjoint
chunks, spawns model-agnostic workers (Claude / Codex / Gemini) in isolated git worktrees,
collects results through a durable inbox rather than trusting an agent's word, and merges waves
sequentially into an integration branch behind a checker gate — never touching main until one
final green PR.
It runs entirely on your machine. Your specs and tasks are plain files in your repo, nothing is held hostage. Fleet is pilot-stage and not yet hardened — treat it as a preview.