Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Atlas - Mission anchored planning framework

    2

    A planning framework your agent installs and follows. It turns any project folder into a mission-based wiki with phase gates, decision records, and context that survives across sessions.

    $4.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Atlas - Mission anchored planning framework

    Atlas - Mission anchored planning framework

    Example session with this skill installed

    I would like to create a new project with the atlas planning skill. We are going to build a t-shirt print to order business.

    • Read your context and instructions
    • Compiled the atlas - mission

    As this appears to be your first time using Atlas, here is a quick run down of how it works.

    Welcome to Atlas, the plan-anything framework. I keep a registry of the projects I maintain, so once this one exists I can resume it, or any of them, in future sessions.

    Everything traces to one file: the mission. You'll confirm it today.

    Two nouns do the work.

    Systems are things you build (software, a product line, a room conversion). Each moves through phases, typically research → design → build, advancing only on named evidence. Systems emerge as we understand the work: I'll recommend, you'll confirm.

    Workstreams are processes you finish (sourcing, research, choosing a supplier), tracked with tasks, notes, and decisions but no phase gates. And the moment we decide anything, it becomes a short

    Decision Record, indexed and checked against earlier decisions for conflicts.

    A few habits keep this alive over months: a state file means any new session resumes in three file reads; two roll-ups (all tasks, all decisions) update at the moment of change; and an optional scheduled audit verifies integrity and reports issues without ever rewriting your content.

    Day one is only about 7 files. Nothing is created until it's real. A project a few weeks in looks roughly like:

    planning/
    ├── AGENTS.md                  # house rules for me
    ├── project/
    │   ├── mission.md             # the anchor; you confirm it today
    │   ├── DASHBOARD.md           # scoreboard: phase/status per system, milestones
    │   ├── systems/
    │   │   ├── system-a/          # in design: research/, design/decisions/, TASKS.md
    │   │   └── system-b/          # still in research; lighter so far
    │   ├── workstreams/
    │   │   └── workstream-a/      # a process being completed: tasks, decisions, notes
    │   ├── overview/              # always-current roll-ups: all tasks, all decisions,
    │   │                          # open questions, costs, risks
    │   └── conception/research/   # exploration that predates any system
    └── sessions/                  # CURRENT_STATE.md + dated logs
    

    You've already told me the short version: a print-to-order t-shirt business. Three quick setup questions before we dig into the mission itself:

    1. Where should the planning repo live? This folder, a planning/ subfolder, or another path.
    2. Git? Recommended; I'd run git init and make the first commit.
    3. Projects registry: keep it at the default ~/.atlas/projects.md?

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Long projects stall when planning lives in scattered chats and half-remembered notes. Atlas turns a plain folder into a structured planning wiki that stays accurate over weeks of work, with a written mission at the center and every decision traced back to it.

    What it does

    • Fits into any folder you choose. First run opens with a one-screen intro to the framework, asks where your plans should live and whether to use git, then onboards conversationally.
    • Keeps a lightweight registry of your projects, so any project can be resumed later from a single file, whichever agent or machine you are on.
    • Onboards any project: software, research, business, physical builds. A short interview produces a mission file and an initial structure of about 7 files, which grows only as the project needs it.
    • Separates systems from workstreams. Systems are things you build, tracked through phases. Workstreams are processes you finish, tracked with tasks and decisions. Both are created when you need them, not in advance.
    • Enforces phase gates. A system moves from research to design to build only when each exit criterion is met by a named file.
    • Writes a Decision Record the moment a choice is made, with context and consequences. Each decision is indexed and checked against earlier decisions for conflicts.
    • Keeps two global roll-ups current: one full task list and one decision index covering every system and workstream. They are updated at the moment of change and checked by the audit.
    • Resumes work in three file reads: dashboard, current state, mission. Long sessions are compacted weekly so the summary stays short.
    • Supports timeboxed spikes: a spec written before the experiment, results written after, with code kept in the repo or linked externally.
    • Diagrams when conversation gets spatial or structural. Your agent suggests Mermaid diagrams for system relationships, architecture, layouts, and floor plans instead of waiting to be asked. Everything renders in GitHub and Obsidian.
    • Tracks costs with confidence levels. Per-system and project-wide cost registers distinguish one-off from recurring spend and flag weak estimates, with an optional spreadsheet for living budgets. Unusual for a planning tool, and built in.

    How it works

    1. Install Atlas in your agent. It loads when you ask for project work, or directly with /atlas.
    2. Onboard: Atlas asks a few questions, writes the mission, and suggests the first systems for your approval.
    3. Work normally. Atlas maintains the wiki as you plan, decide, diagram, and advance.
    4. Run an audit on demand or on a schedule (cron and CI recipes included). The audit verifies links, gates, and roll-ups and reports any problems. It never rewrites your content without approval.

    Compatibility and output

    Works with any agent that can read and write files. Included adapters cover Claude Code, Cursor, Codex CLI, Gemini CLI, OpenClaw, Hermes, and Devin/Windsurf, plus a generic adapter for anything else. Output is plain Markdown with standard links, YAML frontmatter, and Mermaid diagrams, so it renders in GitHub, Obsidian, and any editor. Two domain packs ship with it: software (requirements, feature specs, spikes) and general. A complete example project is included so you can see the output before running it.

    Why this beats prompting it yourself

    A prompt asking an agent to "keep a plan updated" works for a session or two, then conventions slip and artifacts drift apart. Atlas encodes the full process as reference files the agent loads on demand: onboarding, system lifecycle, session continuity, and audit. The rules survive long sessions because they live in files, not in the conversation.

    Use cases

    • Software projects that need ADRs, spikes, and traceability from plan to code.
    • Research work where sources and findings should feed requirements instead of sitting unread.
    • Business and operations processes such as financing, procurement, or certification, tracked as workstreams with tasks, decisions, and budgets.
    • Personal builds and long projects that need to resume cleanly after weeks away, with costs and layouts on record.

    Known limitations

    Requires an agent environment with file read and write access. The audit reports problems instead of fixing them automatically; this is deliberate, so generated content is never changed without your approval. There is no web UI. The output is Markdown-first by design.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Business & Operations.

    Requires file system access. Does not self-heal during audits. Optimized for Markdown-capable environments like Obsidian.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 14 days ago

    Nothing to install. It runs in your AI agent.

    Optional
    Git

    Permissions

    Network Access
    Read Files
    Write Files

    File Scopes

    project/**
    sessions/**
    *.md
    ~/.atlas/projects.md

    ~/.atlas/projects.md - permission only needed if the default project registry location is chosen. You can instruct the agent to create the registry anywhere you like.

    Listed14 days ago

    What's inside

    Frequently Asked Questions

    Atlas is a project management framework that transforms flat file directories into structured, phase-gated wikis. It solves the problem of 'agent drift' and lost context by enforcing mission-alignment and Architecture Decision Records (ADRs) across all sessions.

    Atlas is domain-agnostic and compatible with any AI agent that has file system read/write access, including Claude Code, Cursor, Windsurf, and Devin. It generates portable Markdown and Mermaid diagrams optimized for tools like Obsidian.

    Setup is simple: just run the provided activation prompt in your agent's environment to initialize the host-specific tool mappings. From there, the 'Onboard' command will automatically generate the mission-anchored folder structure and project dashboard.

    Phase-gating ensures project integrity by requiring specific exit criteria—such as research evidence or architectural sign-offs—before an agent can move a system from 'Design' to 'Build.' This prevents agents from rushing into implementation without proper planning.

    The 'Resume' function uses session-state tracking to re-orient the agent at the start of every new interaction. By reading the current mission dashboard and system hierarchy, the agent immediately regains context of where it left off and what the current priorities are.

    New in Business & Operations