RAAV Logo

MCP agent memory

MCP agent memory your founder can actually see.

RAAV exposes product memory through MCP so agents read and update the same repo-local truth — while founders review proposals, watch swimlanes, and supervise via audit.

Join waitlistView install prompt

What RAAV gives agents

  • Give your agent a memory it can operate through over MCP
  • The same context reads through CLI and MCP without re-explaining the product
  • Founders review proposals before they become shared truth
  • Swimlanes and audit make MCP-driven work watchable and supervisable

The problem

MCP lets an agent pull context from tools, but that context is invisible to the founder. Nobody can review what the agent believed, watch what it changed, or supervise whether it was verified.

The RAAV layer

RAAV serves product memory over MCP and CLI. Memory is table stakes — a flat CLAUDE.md is also memory. RAAV's difference is the founder-agent loop is visible: swimlanes to watch, a review queue to review, an audit trail to supervise.

MCP moves context — RAAV makes that context reviewable

The Model Context Protocol is a clean way for an agent to read and write structured context. But a protocol alone does not tell the founder what is confirmed, what changed, or what still needs sign-off. RAAV is the memory those MCP calls operate through.

A protocol is plumbing; memory is the product

MCP standardizes how an agent fetches context and calls tools. What it fetches still needs to be durable, reviewable product truth rather than an ephemeral blob assembled per session.

RAAV provides that durable memory. The agent reads the Product Handbook, task state, claims, and lanes over MCP, and writes proposals and submits back through the same interface.

  • Structured context packs available over MCP and CLI
  • Proposal-first writes so MCP tools cannot silently rewrite truth
  • Memory candidates queued for founder review

Pillar A: memory you can review

When an agent updates context over MCP, the founder should be able to see it as a proposal, not a fait accompli. RAAV separates confirmed facts from inferred assumptions.

Give your agent a memory it can operate through, and give the founder a queue they can review.

  • Confirmed vs inferred memory is explicit
  • Proposals wait for founder confirmation
  • Durable memory candidates before facts become permanent

Pillar B and Pillar C: watch and supervise MCP work

Watch: claims and swimlanes make MCP-driven edits visible before they collide. Supervise: every submit records verification and risk into an audit trail the founder can read.

The protocol carries the bytes; RAAV makes the collaboration legible.

  • Claims and lanes over the same MCP surface
  • Verification recorded on submit
  • Audit export for founder review and handoff

How the agent loop works

RAAV does not replace your coding agent. It gives the agent a durable operating system for product truth, task ownership, and proof.

Connect

Point your MCP client at RAAV so the agent reads repo-local product memory.

Read

The agent pulls a context pack, active tasks, claims, and lanes over MCP.

Write

The agent proposes changes and submits verification instead of rewriting truth.

Review

The founder confirms proposals and supervises via the audit trail.

Wire RAAV into your MCP client

Ask your coding agent to install RAAV and expose its memory over MCP. The agent then starts each session from the ledger instead of a cold prompt.

Paste this into your coding agent
Install RAAV in this repo and expose it over MCP. Read the Product Handbook and next task through MCP before editing, claim files, then submit verification and memory candidates when done.

RAAV is local-first and zero-LLM by default. It is not a coding agent — it is the reviewable memory your MCP agent operates through.

Why this is different

Most tools either write code or track human tickets. RAAV sits between the founder and the coding agents as shared product memory, coordination, and audit.

Works through both CLI and MCP-style workflows
Zero-LLM by default: RAAV stores state, your agent supplies reasoning
Local tier is free; hosted Solo and Team plans are on the waitlist, not for sale yet

Raw MCP context vs MCP memory you can supervise

Durability
Context is assembled per session and disappears afterward.
Product truth persists in a repo-local ledger the agent reads over MCP.
Review
MCP writes can change context with no founder visibility.
Writes become proposals and memory candidates for review.
Supervise
No record of what was verified after an MCP-driven run.
Submits record verification and risk into an audit trail.

FAQ

MCP users usually ask how RAAV fits alongside the protocol and whether it adds another model.

Does RAAV replace MCP?

No. MCP is the transport; RAAV is the durable, reviewable memory the agent reads and writes over MCP. They are complementary.

Does RAAV run its own model?

No. RAAV is zero-LLM by default. Your MCP agent supplies the reasoning; RAAV supplies the product state and the review, watch, and supervise surfaces.

Is RAAV a coding agent?

No. RAAV is the memory and audit layer around coding agents, exposed over CLI and MCP.

What does it cost?

The local tier is free. Hosted Solo and Team plans are on the waitlist and not for sale yet.

Related RAAV workflows

Product memory for coding agentsClaude Code memoryCodex project memory