fractal

Ariadne

Ariadne gives Claude Code a thread through complex work: start from a vague goal, recursively expand a predicate tree, and follow evidence to the next frontier.

简体中文

Install · How it works · Skills · Full spec · Theory

The metaphor

Ariadne comes from Ariadne's thread: a way through the labyrinth that does not depend on memory alone, but leaves a path you can follow back.

Complex projects are labyrinths too. Requirements shift, plans expire, hidden risks appear during execution, and an agent's chat context can disappear. Ariadne turns goals into verifiable predicates and writes each decision, evidence trail, and conclusion into a repo-local work graph. When the path gets lost, follow the thread back to the last proven point; when work resumes, continue from the frontier that the evidence points to.

The problem

Claude Code is good at clear tasks, but complex work rarely begins as a complete checklist:

• Goals start vague and need to become verifiable conditions.
• The highest-risk unknowns should be probed before blindly executing a task list.
• Each execution slice can change the next plan, so the graph must be reassessed continuously.
• Long-running work must survive session loss without relying on chat history.
• Completion cannot rest on an agent saying "done"; it needs a proof path, children, blockers, and evidence.

Ariadne's core loop is:

unknown -> predicate -> evidence -> reassess -> recursive frontier

Ariadne is not a standalone agent framework. It is a Claude Code plugin / skills / agents / scripts substrate that maintains a lazy-expanded, proof-gated work graph inside the existing repository.

Relationship to Fractal Loop

Ariadne is a respectful continuation of rmolines/fractal-loop. The original project introduced a clear recursive predicate primitive and implemented it as a Claude Code plugin; Ariadne builds on that foundation.

Because the upstream project appears no longer actively maintained, Ariadne preserves its most valuable ideas — filesystem-as-state, predicate decomposition, human gates, and evidence-driven reassessment — while strengthening proof gates, risk-first selection, durable evidence receipts, and Ariadne's own product expression.

During the migration, some commands, file names, and docs still use fractal / Fractal Loop naming.

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.

$ /fractal:init I want to build an open-source Granola — local meeting
  recorder that transcribes and feeds context into Claude Code via MCP

> Before I write the root predicate: are you capturing system audio
> (the call), microphone (your voice), or both?

Both. I want the full conversation, locally, no cloud.

> Predicate: "Users run a local MCP server that captures meeting audio,
> transcribes it, and exposes structured notes to Claude Code —
> no data leaves the machine."
> Create the tree?

Yes.

> Biggest risk: whether macOS even allows capturing system audio
> programmatically without a kernel extension. If it doesn't, the
> entire approach changes. Starting with a spike on ScreenCaptureKit.

A few days later:

$ /fractal:run

> Reading tree... 8 nodes. 3 satisfied, 5 pending.
> "screencapturekit-spike" satisfied — system audio capture works
> without kernel extension on macOS 13+.
> Re-evaluating parent... next risk: chunking live audio into
> segments the transcription model can handle. Starting there.

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.

curl -fsSL https://raw.githubusercontent.com/rmolines/fractal-loop/master/install.sh | bash

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.