Product memory for coding agents

Product memory your coding agents can operate through.

A saved prompt holds instructions. RAAV also records current work, ownership, decisions, verification, and history in the repository.

Join waitlist See Product OS

What RAAV gives agents

Agents receive current work and decisions, not only repository instructions
Founders review product changes before they become shared truth
Work is watchable in swimlanes instead of buried in chat scrollback
Every submit records files, verification, and risks for supervision

The problem

A coding agent can ship a feature and forget why it exists by the next session. Product truth, decisions, and verification end up scattered across chat logs the founder cannot easily see.

The RAAV layer

A rules file tells an agent how to work. RAAV also records what is being built, who owns it, what the founder decided, and which checks passed. Both the agent and the founder read the same project state.

Saved instructions are not the same as a current product record

Every coding agent already has some memory: a CLAUDE.md, an AGENTS.md, or a long chat thread. That is necessary but not sufficient. The founder still cannot see what changed, what was verified, and what still needs sign-off. RAAV makes the collaboration visible.

A rules file is memory the founder cannot review

A flat CLAUDE.md or AGENTS.md stores instructions, but it does not separate confirmed facts from assumptions, does not show who is editing what, and does not record whether the last fix actually passed verification.

RAAV keeps the repository memory the agent reads. The founder sees the same state through the review queue, swimlanes, and audit.

Confirmed product truth separated from inferred assumptions
Review queue so proposed changes wait for founder sign-off
Audit trail that reconstructs what changed and why

Product changes wait for a founder

The founder needs one place to read what the product is, what is in scope, and what the agent recently proposed to change. Inferred facts become proposals and memory candidates before they become durable truth.

The agent gets a current project record. The founder gets a clear queue of proposed changes.

Product Handbook for goals, scope, and open questions
Proposal-first writes for material product changes
Confirm, defer, reject, or reopen proposals later

The work remains visible after the chat ends

Swimlanes and claims show the agent, files, and branch attached to current work. When the run ends, its checks and remaining risk stay in the project history.

That is the difference between a saved prompt and product memory a founder can trust.

Swimlanes and claims to watch active agent work
Verification recorded on every submit
Audit export for handoff and founder review

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.

Plan

The agent reads a context pack with brief, goals, open requirements, and the next safe task.

Claim

Before editing, the agent claims a task, files, and branch lane so work is watchable.

Submit

After work, the agent records summary, files, verification, and risks for review.

Supervise

The founder reviews proposals and reads the audit trail instead of the whole chat.

Start a shared project record

The fastest way to adopt RAAV is to ask your coding agent to install and operate it from inside the repository. The agent sets up local memory; the founder gets review, swimlanes, and audit.

Paste this into your coding agent

Set up RAAV in this repository as product memory for coding agents. Initialize local memory, create the Product Handbook, list assumptions separately from confirmed facts, and show me the next safe task before editing.

The project record stays in the repository. Your existing coding agent continues to handle the reasoning and implementation.

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.

Project state lives with the repository and costs no model tokens to maintain

Codex, Claude Code, or Cursor still writes the code

The €10 weekly Trial is published; access currently comes through a founder testing cohort

A flat rules file vs product memory you can supervise

Review

A CLAUDE.md changes silently; the founder never sees the diff.

Proposed changes wait in a review queue for founder sign-off.

Watch

Parallel edits are discovered when diffs collide.

Swimlanes and claims show who owns which files before work overlaps.

Supervise

Done means the agent stopped or opened a PR.

Done means summary, verification, risks, and audit are recorded.

FAQ

These are the questions founders ask when they realize a saved prompt is not the same as product memory they can supervise.

Is this just a fancier CLAUDE.md?

A CLAUDE.md or AGENTS.md is useful for stable instructions. RAAV adds the state those files do not track: open work, active ownership, proposed decisions, and verification from the last run.

Is RAAV a coding agent?

No. RAAV is the product memory layer around coding agents. Codex, Claude Code, Cursor, or another agent does the reasoning and coding. RAAV is zero-LLM by default and keeps the product state reviewable.

What does it cost?

The €10/week Trial includes the full local-first CLI and hosted console. Solo and Team add hosted capacity and collaboration. Checkout remains gated during controlled founder testing.

Who is it for first?

The first ICP is the solo or lightly technical founder running many coding-agent sessions who needs to see what was built, verified, and still needs sign-off.

Related RAAV workflows

MCP agent memory Claude Code memory AI agent project management