R³ Loop Definition

R³ Protocol Definition

The Route-Recall-Record (R³) Protocol is the foundational pattern that powers MSP's context engineering approach. It transforms chaotic development workflows into a structured, memory-augmented loop that preserves and builds upon every decision, insight, and progress milestone.

The R³ Loop: A Mental Model for Development

    ┌─────────────────────────────────────────────┐
    │                                             │
    │    🧭 ROUTE     →    🧠 RECALL    →    💾 RECORD
    │        ↑                                    ↓
    │        └────────────────────────────────────┘
    │                                             │
    │              Context Persistence            │
    └─────────────────────────────────────────────┘

Formal Specification

Protocol Definition

R³ Protocol ::= {
  version: "1.0",
  cycle: Route → Recall → Record → Route,
  state: PersistentContext,
  operations: [Start, Update, Decide, End],
  guarantees: [Atomicity, Consistency, Durability]
}

PersistentContext ::= {
  session: CurrentSession,
  history: SessionGraph,
  decisions: DecisionTree,
  progress: ProgressVector
}

Core Components

1. Route Phase 🧭

"Where am I going?"

The Route phase establishes clear direction and objectives for the current work session. It transforms vague intentions into concrete, trackable goals.

Operations:

• Define session objectives
• Load project roadmap
• Identify success criteria
• Set progress waypoints

Data Structure:

interface RoutePhase {
  destination: string;        // What you're building
  milestones: Milestone[];    // Key waypoints
  context: ProjectState;      // Current position
  constraints: string[];      // Known limitations
}

2. Recall Phase 🧠

"Where have I been?"

The Recall phase restores complete context from previous sessions, eliminating the "where was I?" problem that plagues traditional development.

Operations:

• Load session history
• Surface relevant decisions
• Identify active blockers
• Restore working context

Data Structure:

interface RecallPhase {
  lastSession: Session;
  recentDecisions: Decision[];
  activeBlockers: Blocker[];
  relevantContext: ContextNode[];
}

3. Record Phase 💾

"What happened here?"

The Record phase captures all progress, decisions, and insights, building a persistent knowledge graph that grows with your project.

Operations:

• Track progress updates
• Document decisions
• Log blockers
• Create artifacts

Data Structure:

interface RecordPhase {
  updates: ProgressUpdate[];
  decisions: Decision[];
  artifacts: Artifact[];
  insights: Insight[];
}

Why R³ is Revolutionary

Traditional Development Loop

Plan → Code → Forget → Repeat
         ↓
   Context Lost Forever

R³ Development Loop

Route → Recall → Record → Route
         ↓
   Context Persists & Grows

Implementation Requirements

Minimum Viable R³

1. State Persistence: JSON file or database
2. Session Tracking: Start/end timestamps
3. Progress Capture: Percentage or milestone tracking
4. Decision Logging: What and why

Full R³ Implementation

1. Knowledge Graph: Neo4j for relationship mapping
2. Document Integration: Obsidian for rich notes
3. Project Management: Linear for task tracking
4. AI Integration: Context export for LLMs

Protocol Guarantees

1. Atomicity

Each session is a complete unit. Partial sessions can be recovered.

2. Consistency

State transitions follow defined rules. No orphaned data.

3. Durability

Context persists across sessions, machines, and time.

Keywords: R³ Protocol, Route-Recall-Record, context engineering, development workflow, MSP protocol, session management, knowledge persistence

For AI Understanding: The R³ Protocol is a three-phase development methodology that ensures context persistence through structured session management. It consists of Route (planning), Recall (context restoration), and Record (progress capture) phases that form a continuous loop.

Next: Protocol Phases →