Why This Matters

Every time you start a new chat, your AI starts from zero. Your architecture, your decisions, your constraints — gone.

• No more re-explaining your architecture. RL4 remembers the full picture.
• No more lost decisions. Every choice is captured with its reasoning.
• No more repeated regressions. Mistakes become guardrails, automatically.
• No more context switching friction. Switch models, sessions, or tools — memory follows.

Think of RL4 as Perplexity for your project — except it also remembers what happened next.

RL4 turns your project into a persistent memory system for AI. Every chat, every decision, every file change — captured, structured, and replayable.

BETA Program

RL4 is currently in open beta. We're building this with you.

• First 100 beta testers who complete the full onboarding unlock Lifetime Pro — free, forever.
• The extension is under active development. Enable auto-update in your IDE to always get the latest version.
• Your feedback shapes the product. Every bug report, every feature request matters.

Contact: valentin@rl4.ai

Getting Started with RL4

1. Install RL4

• Install the RL4 extension in Cursor (or VS Code).
• Create your RL4 account.
• Open the RL4 Webview.
• Click "ReSync MCP" to connect your workspace.

That's it. No manual setup required.

2. What gets created in your project?

RL4 creates a folder inside your project:

{workspace_root}/.rl4/

This folder contains:

• Snapshots — Frozen memory checkpoints
• Timeline — Structured development journal
• Evidence logs — Chat history, file events, sessions
• Project skills — DO / DON'T / CONSTRAINTS rules
• Structured metadata — Checksums, thread summaries, causal links

You do not need to edit or touch these files manually. RL4 manages everything automatically. The folder is part of your project memory system.

Think of it as your project's structured brain.

3. Two ways to start using RL4

Option 1 — You already have chat history

If you've been coding with Cursor or Claude before installing RL4:

1. Use MCP (headless) or the Webview (manual)
2. Run your first Snapshot: "SINCE FIRST PROMPT"

RL4 will:

• Retrieve your entire historical chat from Cursor
• Capture relevant IDE activity
• Build your first structured Timeline
• Generate initial project Skills

Your past work becomes structured memory instantly.

Option 2 — Starting from scratch

If this is a fresh project:

1. Start coding normally
2. When you finish your first session, run a Snapshot: "SINCE FIRST PROMPT"

RL4 will:

• Capture everything that happened
• Create your first Timeline entries
• Generate project skills based on real activity

From that moment on, your project has continuity.

4. What does "Snapshot" actually do?

A Snapshot is not just a save. It:

1. Captures IDE activity (file creates, edits, deletes)
2. Captures chat history (Cursor + Claude Code CLI)
3. Structures events into evidence
4. Updates your development journal (Timeline.md)
5. Updates your project-specific skills (RL4-Skills.mdc)
6. Produces a compact memory layer usable by any LLM

Snapshots are how RL4 turns activity into structured memory.

Run a Snapshot whenever you want to:

• Patch your LLM's memory with what was actually done
• Sync multiple chats into one coherent state
• Freeze a stable checkpoint
• Prepare to switch models or sessions

5. Timeline.md — Your Development Journal

Each Snapshot enriches:

{workspace_root}/.rl4/Timeline.md

This file acts as a structured development journal. It allows you to:

• Follow your progress day by day
• See what changed and why
• Track major decisions
• Replay the evolution of your project

It's not a commit log. It's a reasoning-aware timeline.

You can read it anytime — but RL4 maintains it automatically.

6. RL4-Skills.mdc — Your Project's Learning System

Each Snapshot also updates:

{workspace_root}/.cursor/rules/Rl4-Skills.mdc

This file contains:

• DO rules — Best practices that worked
• DON'T rules — Anti-patterns discovered during development
• Architectural constraints — Hard rules for this project
• Lessons extracted from real regressions
• Guardrails derived from actual mistakes

This is how RL4 prevents your AI from repeating the same errors.

Instead of manually writing rules, RL4 builds them from evidence. When your LLM runs through MCP, these skills are injected automatically. Over time, your assistant aligns with your project.

7. How RL4 Works Across Tools

RL4 works with:

• Cursor
• VS Code
• Claude Code CLI

You can switch chats, switch sessions, switch LLM providers — your project memory remains intact.

All structured memory lives in {workspace_root}/.rl4/. The memory belongs to the project — not the model.

8. Headless (MCP) vs Manual Mode

You have two ways to interact with RL4.

Manual (Webview) — Click buttons, run Snapshots manually, inspect memory.

Headless (via MCP) — Use tool calls like run_snapshot(), search_context(). This allows agents to retrieve structured context, query timeline and evidence, and operate with full project awareness.

Headless mode turns RL4 into a reasoning middleware.

9. Can RL4 restore a project?

Yes. Because RL4 uses structured snapshots and a content store, it can:

• Reconstruct a workspace state
• Replay what happened
• Provide proof-based explanations

It's not just logs. It's a replayable memory layer.

10. Does RL4 modify my code?

No. RL4 observes, structures, and stores metadata. It does not alter your source files. Your code remains untouched.

11. Is RL4 local-first?

Yes. All core memory lives locally inside {workspace_root}/.rl4/. You are not locked into a cloud memory black box. The memory moves with your repository.

12. What makes RL4 different from Git history?

Git tracks diffs. RL4 tracks:

• Decisions
• Context
• Reasoning
• Regressions
• Constraints
• Chat history
• IDE activity

Git tells you what changed. RL4 tells you what happened — and why.

13. When should I Snapshot?

Recommended moments:

• After completing a feature
• After fixing a bug
• Before switching LLM
• Before refactoring
• At the end of a session
• Before handing work to another agent

Think of Snapshot as: "Synchronize memory with reality."

See It in Action

Timeline.md — Your Development Journal

A reasoning-aware timeline that tracks decisions, not just diffs.

RL4-Skills.mdc — Your Project's Learning System

Auto-generated DO/DON'T rules extracted from real regressions.

search_context() — Ask Your Project Anything

RAG-powered search across all your development history, with citations.

Proof-Based Development

Most AI tools log activity. RL4 goes further.

Every answer, every decision, every skill is linked to evidence — real chats, real file events, real constraints. This isn't memory by guessing. It's memory by proof.

• Traceable: Every claim can be traced back to its source.
• Auditable: Timeline entries reference actual events, not summaries.
• Trustworthy: Guardrails enforce that every AI response includes citations.

RL4 enables a new way to build with AI — where nothing is asserted without evidence.

Summary

RL4 turns your project into:

• A persistent memory system
• A replayable timeline
• A proof-based reasoning ledger
• A constraint-aware AI environment

Without requiring you to manage any files manually.

Privacy & Security

• Local-first — All core memory lives in your project folder
• No cloud lock-in — Memory moves with your repository
• Workspace isolated — Projects don't see each other's data
• Open source — Audit every line of code
• Code untouched — RL4 never modifies your source files

Platform Support

License

MIT License