Skip to content
rauf

What is Rauf?

Rauf is a "ralph" runner — it iterates over a highly structured backlog, giving each work item its own fresh agent context, then verifies and commits the result. The backlog is almost always authored by the coding agent itself, via skills that ship with rauf.
Get Started Core Concepts

Rauf gives every work item its own fresh agent context — one item, a focused prompt, the backlog as read-only context. That fresh-context-per-iteration discipline is the ralph pattern, and it’s what keeps long autonomous runs from drifting. Rauf is CLI-first (driven by you or by an agent) and optimized for Claude Code, which it spawns by default — but the loop runner is deliberately separated from the agent it spawns, so rauf isn’t wired to a single harness.

Key Concepts

Agent-authored backlog

The backlog is a structured JSON queue of work items — priorities, acceptance criteria, dependencies. You rarely hand-write it: the shipped author-backlog and review-backlog skills let the agent generate and QA well-scoped items from a feature description.

Fresh context per iteration

Each item runs in a brand-new agent session. No state carries between items; the runner — not the agent — verifies and commits the work, keeping history clean and runs recoverable.

Isolated per-feature backlogs

Run a repo-wide queue at <project>/.rauf/, or point --backlog <dir> at a separate directory per feature. Each gets a fully independent loop and state that never collide.

Optional web dashboard

The CLI is the primary surface. An optional local web UI — newer and less battle-tested — lets you view and manage loops in the browser, reading the same on-disk state the CLI does.

How It Works

  1. You (or, more often, the agent) define work items in a backlog — a structured JSON task queue
  2. The loop runner picks the next item, spawns a fresh agent session, and monitors the result
  3. Each iteration reads acceptance criteria, implements changes, runs verification, and signals done
  4. The runner verifies and commits the work, then continues until the backlog is empty or a limit is reached

One rauf iteration: select an item, build the prompt, spawn the agent, parse its signal, verify and commit, then advance to the next item.

Works with feature-forge

Rauf is tightly integrated with — but not dependent on — feature-forge, an agent-agnostic spec-and-backlog pipeline. feature-forge generates a backlog per feature and hands it to a conforming loop runner; rauf is the default and reference implementation. The two work as a pair, but rauf runs perfectly well on a hand-rolled or skill-authored backlog without it.

Quick Install

Terminal window
# Clone and build
git clone https://github.com/garygentry/rauf.git
cd rauf && pnpm install && pnpm build


# Install into a project
rauf install ~/workspace/my-project --yes


# Start the loop
rauf loop run ~/workspace/my-project