Because AI agents build from context, not assumptions.
Planifest is an Agile context framework for AI development. It uses Just-in-Time planning to ensure your agents build from a solid Execution Plan rather than hallucinating in the dark.
Code is ephemeral; architecture is permanent. Planifest's paper trail gives you the ultimate choice: refactor what you can, or confidently rewrite what you must.
Planifest gives AI agents the structure they need to build software that a senior engineer would approve. It treats the human as the Product Owner and Technical Architect. The agent is the Tech Lead: highly capable, but operating within constraints the human sets.
The framework is LLM-agnostic and tool-agnostic. It works with any model (Claude, GPT, Gemini, etc.) and any agentic coding tool (Claude Code, Cursor, Codex, Antigravity, GitHub Copilot, etc.).
Planifest fully supports the Agent Skills specification and is designed for use with any tool that implements it.
Agile methodologies were invented to solve a human bottleneck: typing is slow. Because execution took months, heavy upfront planning was dangerous. The market would change before the code was finished.
In the AI era, execution takes minutes. When an agent can generate a 10,000-line feature in the time it takes to get coffee, the cost of execution drops to zero. But the cost of hallucination skyrockets. If an agent builds the wrong architecture at lightspeed, you spend days untangling it.
Planifest is built on three core realities of agentic development:
- Transparency beats brevity. When AI writes the code, the code is just the compiled output. The actual source code is your prompt and your plan. If your plan is vague, the AI will invent the missing pieces, leaving you with zero transparency into its architectural choices.
- Context makes refactoring safe (and rewriting trivial). AI struggles to safely modify large, undocumented codebases. Planifest makes your code ephemeral and your architecture permanent. With a perfect architectural record, you get the best of both worlds: the precise historical context an agent needs to confidently refactor existing code, and the full specification required to burn a component down and build it better from scratch.
- Agents build from context, not assumptions. Before a single line of code is generated, the agent must document its Execution Plan. If there are gaps in the Story Context, the agent stops and asks the human. It does not assume.
Planifest enforces a strict, fast-paced iteration loop to keep the AI aligned with human intent.
- Human writes a Feature Brief — What to build, why, and within what constraints.
- Agent interrogates — The Orchestrator Skill assesses the brief and asks focused questions until the context is complete.
- Agent plans — The agent generates an Execution Plan and an ADR (Architectural Decision Record).
- Agent builds — The agent executes the plan: code generation → validation → security checks → documentation updates.
- Human reviews — The Pull Request is the universal backstop.
(Note: Every artifact the agent produces follows a strict template, ensuring consistency across tools, models, and teams.)
repo/
├── planifest-framework/ ← The framework (drop in, don't modify per-project)
│ ├── skills/ ← Agent instructions (orchestrator + 7 phase skills)
│ ├── templates/ ← File format templates for every artifact
│ ├── schemas/ ← JSON Schema validation definitions
│ ├── standards/ ← Code quality standards
│ └── [feature-structure.md](plan/feature-structure.md) ← Canonical directory layout
│
├── plan/ ← Feature briefs, execution plans, ADRs, risk registers, scope docs.
│ Organized by feature. Everything that describes WHAT to build and WHY.
│
├── src/ ← Code (organized by component)
│ Implementation, tests, config, manifests.
│ Each component has a component.yml at its root.
│
└── planifest-docs/ ← Project documentation (for humans, not agents)
Architecture notes, research, roadmap.
See getting-started.md for step-by-step setup instructions.
Quick start:
# macOS/Linux
./planifest-framework/setup.sh <tool>
# Windows
.\planifest-framework\setup.ps1 <tool>Where <tool> is claude-code, cursor, codex, antigravity, copilot, or all.
The setup script copies skills into the directory your tool auto-discovers, adds YAML frontmatter, and creates a boot file. See tool-setup-reference.md for details on each tool.
Specification before code. The agent does not write code until the spec is complete. If the spec has gaps, it stops and asks — it does not guess.
Human decides, agent executes. The human chooses the architecture, the stack, the data ownership, and the scope. The agent implements within those constraints.
Decompose big initiatives. Split into features (small enough for one agent session) and phases (sequential Agentic Iteration Loop runs). This is how Planifest manages context at scale.
Everything is traced. Every agent-produced artifact records the skill that produced it, the tool it ran in, and the model that generated it.
The PR gate is the backstop. Regardless of tool or model, a human reviews the output before it ships.
| Folder | Contents | Count |
|---|---|---|
| skills/ | Orchestrator, spec-agent, adr-agent, codegen-agent, validate-agent, security-agent, change-agent, docs-agent | 8 |
| templates/ | Feature brief, execution plan, ADR, scope, risk register, domain glossary, data contract, component manifest, iteration log, change summary, cost model, operational model, recommendations, security report, SLO definitions — each with a guide where applicable | 24 |
| schemas/ | Shared type definitions, domain document envelope | 2 |
| standards/ | Code quality, API design, database, deployment, infrastructure, monorepo, observability, testing, backend & frontend stack evaluations | 10 |
| setup/ | Per-tool boot file templates (antigravity, claude-code, cline, codex, copilot, cursor, windsurf — .sh and .ps1 for each) |
14 |
| hooks/ | Git hooks (pre-commit, pre-push) and CI workflow | 3 |
| workflows/ | Agent workflow definitions: fast-path, feature-pipeline, change-pipeline, retrofit | 4 |
These are non-negotiable, regardless of tool, model, or configuration:
- Requirements must be complete before codegen begins
- No direct schema modification — migration proposal required, human approves
- Destructive schema operations require human approval — no exceptions
- Data is owned by one component — never write to another component's data
- Code and documentation are written together — never one without the other
- Credentials are never in the agent's context — capabilities only
*Planifest Docs contains human documentation — architecture notes, research, and the project roadmap. Agents don't need these; they work from the skills and templates in planifest-framework/. There is a git repository and also a GitHub Pages website for these docs.
We want the Planifest community to build with total confidence. While we considered the MIT license for its simplicity, we chose Apache 2.0 because it offers superior long-term protection for our users and contributors:
-
Explicit Patent Rights: Unlike other permissive licenses, Apache 2.0 grants you an explicit license to any patents covered by the software. This means you can use, modify, and distribute Planifest without worrying about "hidden" patent claims.
-
Contributor Protection: It ensures that every contribution made to the framework comes with the same patent grants. This prevents "patent trolling" within the ecosystem and keeps the code free for everyone, forever.
-
Community Safety (The "Retaliation" Clause): The license includes a defense mechanism: if anyone sues a Planifest user over patent infringement related to this software, they automatically lose their own license to use it. This keeps the community collaborative and legally "polite."
-
Commercial Friendly: It remains a permissive, open-source license. You are free to use Planifest for commercial projects, ship it in proprietary products, and build your business on it with zero royalties.
TL;DR: We chose Apache 2.0 so you can focus on building great things, knowing the legal foundation of your framework is rock-solid and community-first.