Recursive Evolutionary Autonomous Pipeline

REAP

A development pipeline where AI and humans collaborate to evolve an Application across successive Generations. Context persists between sessions, development follows a structured lifecycle, and design docs evolve with your code.

Get Started →GitHub

Why REAP?

AI agents are powerful — but without structure, development becomes chaotic. Context resets every session. Code changes scatter without purpose. Design docs drift from reality. Lessons from past work vanish.

Context loss

CLAUDE.md + Memory automatically restore full project context in every session

Scattered development

Each generation focuses on one objective through a structured lifecycle

Design–code drift

Genome mutations discovered during implementation feed back via backlog

Forgotten lessons

Retrospectives accumulate in Genome. Lineage archives all generations

Collaboration chaos

Genome-first merge workflow reconciles parallel branches — design conflicts before code conflicts

4-Layer Architecture

REAP consists of four interconnected layers: Knowledge provides the basis, Vision drives direction, Generations execute the work, and Civilization is what evolves.

Knowledge

Genome + Environment

Genome (prescriptive — architecture, conventions, constraints) and Environment (descriptive — tech stack, source structure, domain). The basis for each generation's work.

Vision

Goals + Memory

Long-term goals and direction. Vision drives each generation — it determines what goal to pursue next. Memory persists context across sessions.

Generation

Evolution Cycle

Each Generation runs Learning → Planning → Implementation → Validation → Completion. On completion, archived to lineage.

Civilization

Source Code

Everything outside .reap/. What generations evolve. Lessons feed back into Knowledge.

Generation Lifecycle

Each generation progresses through five stages, from goal definition to retrospective and archiving.

Learning→Planning→Implementation⟷Validation→Completion

Stage	What happens	Artifact
Learning	Explore project, build context, review genome and environment	01-learning.md
Planning	Break down tasks, choose approach, map dependencies	02-planning.md
Implementation	Build with AI + human collaboration	03-implementation.md
Validation	Run tests, verify completion criteria	04-validation.md
Completion	Reflect + fitness feedback + adapt genome + archive (4 phases)	05-completion.md

Installation

1. Install globally

bash

npm install -g @c-d-cc/reap   # Global installation required

2. Open your AI agent (Claude Code or OpenCode), initialize and start

bash

claude
> /reap.init          # Set up genome, environment, vision through guided conversation
> /reap.evolve        # Run a full generation lifecycle

/reap.evolve runs the full generation lifecycle — Learning through Completion — autonomously. You can also control stages manually with stage commands.

Key Concepts

Genome Immutability

The Genome is never modified during a normal generation. Issues are logged as genome-change backlog items and applied at Completion's adapt phase. (Embryo generations allow free modification.)

Backlog & Deferral

Items in .reap/life/backlog/ carry a type: genome-change | environment-change | task. Partial completion is normal — deferred tasks carry forward to the next generation.

Vision & Memory

Vision (.reap/vision/) drives each generation's goal. Memory is a 3-tier free-form recording system (longterm/midterm/shortterm) for AI to persist context across sessions.

Lineage

Completed generations are archived in .reap/lineage/. Retrospectives accumulate there. Over time they're compressed (Level 1 → gen-XXX-{hash}.md, Level 2 → epoch.md) to stay manageable.

4-Layer Architecture

Vision (goals + memory), Knowledge (genome + environment), Generation (lifecycle), Civilization (source code).

Distributed Workflow

Multiple developers or agents work in parallel on separate branches. /reap.pull fetches and runs a genome-first merge generation. /reap.push validates state before pushing. No server needed — Git is the transport layer.

Documentation

Introduction

What is REAP, why use it, 4-layer architecture.

→

Quick Start

Install and run your first generation step by step.

→

Core Concepts

Genome, Life Cycle, Backlog & Deferral in depth.

→

Lifecycle

/reap.evolve, stage commands, micro loop, completion phases.