atlas

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, and SHIP_CHECK_OK make 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

1. Preflight — detects your environment (native backend, optional TaskMaster backend, model CLIs, research) and configures it. Zero setup questions.
2. Discovery — an adaptive, one-question-at-a-time interview captures your real constraints.
3. 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.
4. Handoff — detects what you have installed and recommends one execution mode.
5. Execute — a CDD-gated loop implements each task and proves it with evidence, ending in a deterministic SHIP_CHECK_OK token.

---

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 and validate-prd exits non-zero.
• A real task graph. Requirements become backend-neutral tasks.json tasks 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_OK is emitted only when every gate passes — and a single non-zero Exit status in 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/pilot to be notified at launch is coming).

| | Free (MIT) | Atlas Pro — private pilot | |---|:---:|