fractal

**Recursive project management for Claude Code. State a goal — it figures out what to do next.**
Install · How it works · Skills · Full spec · Theory
Fractal Loop is a Claude Code plugin that decomposes goals into verifiable predicates and always works on the riskiest unknown first. You state an objective. The agent picks the piece with the most uncertainty, works on it, then reassesses. When a path fails, it backs up and tries another. Same operation at every scale. Works on any project.
How
You give it a goal. It turns that into a verifiable condition, breaks it down one
piece at a time, and always picks the piece that reduces the most uncertainty.
A few days later:
Session dies, you come back, run /fractal:run. It reads the filesystem
and picks up where it left off. When a piece is done, the parent gets
re-evaluated — maybe it needs another piece, maybe the whole direction
was wrong and it prunes the branch and tries something else.
Install
Requires Claude Code with plugin support.
Start a new session and run /fractal:run in any repo. Override the install path
with INSTALL_DIR=~/your/path before the curl command.
How is this different?
Other tools ask you to decompose upfront. You write a PRD, it becomes a task
list, the agent follows the list. If a task turns out wrong, you fix the list.
Fractal Loop doesn't need a list. You state the goal, it picks the riskiest piece,
works on it, then reassesses. If a path doesn't work out, it backs up and tries
another.
**vs. Task Master (~27k stars):**
PRD becomes a flat task list. No re-evaluation after each task.
**vs. BMAD Method:**
Specialized agents per phase (PM, Architect, Developer). Rich but rigid — six
phases in fixed order.
**vs. CCPM:**
GitHub Issues + worktrees. Sound state management but fixed hierarchy. Doesn't
handle plan invalidation.
**vs. native Claude Code Tasks:**
Good for checklists. Not for goal decomposition.
**What fractal does differently:**
- Conditions, not tasks. "Users can authenticate with Google" vs. "implement auth."
- One recursive primitive at every scale. No fixed hierarchy.
- One child at a time. Re-evaluate the parent after each.
- Pruning is a feature. Failed path → back up → try another.
- The tree is the plan, the log, and the state. Nothing else to maintain.
The operation
One recursive function. Same structure at every scale.
This is fractal's own tree
The project manages itself with the same primitive it gives you.
The pruned node (return-to-parent) was an approach that didn't work. The system
recognized it, backed up, and tried something else. That's the point.
Each satisfied node writes a conclusion.md — what was achieved, key decisions,
deferred items. Any future session reads conclusions instead of loading every
file. The tree is its own documentation.
What it actually does
**Risk-first ordering.** The evaluator scores each candidate by uncertainty,
impact, and return. Highest uncertainty gets worked first — kill the unknown
before optimizing value delivery.
**Session continuity.** Die mid-sprint, come back next week. /fractal:run