Codex project memory

Shared product memory for Codex work.

Use RAAV to give Codex durable product context, task claims, branch/worktree lanes, verification, and founder review across coding sessions.

What RAAV gives agents

  • Codex starts from current product truth and next task guidance
  • Branch/worktree lanes show who is working where
  • Proposal-first changes keep the founder in the approval loop
  • Audit trail records completed work and verification evidence

The problem

Codex can make focused code changes, but repeated sessions still need the same product context, task ownership, and merge readiness rules.

The RAAV layer

RAAV turns Codex into a better product-building agent by giving it a deterministic operating memory before and after each run.

Codex needs a durable product layer around the code change

Codex is strong at taking a scoped engineering task and moving through implementation. RAAV helps make that task safer by giving Codex product context, ownership boundaries, and a structured way to report what happened.

A Codex task should start from product truth, not only files

Code context is necessary, but not enough. The agent needs to know the product promise, the current feature goal, what is out of scope, what the founder has already decided, and what would make the change acceptable.

RAAV packages that context before Codex starts. The result is less drift between a technically valid patch and the product the founder meant to build.

  • Product Handbook for durable intent
  • Context packs for current task and risk state
  • Acceptance criteria before work is claimed

File claims make automated work easier to coordinate

Codex often works in a shared repository where another agent or human may also be editing. Without a coordination layer, overlapping edits become a merge problem and a product management problem at the same time.

RAAV lets Codex claim a task, files, branch, and worktree lane before editing. That creates a visible record of who is working where and gives other agents a chance to avoid conflicts.

  • Claim files before editing
  • Check active conflicts before large changes
  • Keep branch and worktree purpose visible

Submits turn Codex work into project memory

A good code change still needs a durable explanation. What changed? Which files matter? What verification passed? What risk remains? What should the founder review before the next agent continues?

RAAV makes Codex submit those details into the ledger. The next Codex session can read the result instead of reverse-engineering intent from commits and terminal logs.

  • Structured run summaries
  • Verification and risk fields
  • Memory candidates for durable facts

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.

Read

Codex runs `raav context`, `raav product handbook`, and `raav pack work`.

Select

Codex picks an open task or creates a proposal for founder confirmation.

Claim

Codex claims task files and checks conflicts before editing.

Submit

Codex records summary, files, branch, verification, and memory candidates.

Codex install prompt

A founder can ask Codex to install and operate RAAV directly. The important part is to make Codex use RAAV before it chooses work, not only after a patch is complete.

Paste this into your coding agent
Set up RAAV for Codex in this repo. Before editing, read the Product Handbook, show the next task, claim files, and check conflicts. After editing, submit summary, changed files, verification, risks, and memory candidates.

This turns Codex from a one-off code editor into an agent that leaves behind project memory for the next run.

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.

Designed for repo-local operation with no required hosted sync
Agent instruction sync for AGENTS.md and other assistant rule files
Fresh-install smoke verifies packed CLI, proposals, claims, submit, memory queue, lanes, and audit

Codex alone vs Codex operating through RAAV

Task selection
The agent relies on the prompt and recent chat context.
Codex can read current tasks, priorities, requirements, and review gaps.
Repo safety
File overlap is discovered late during merge or review.
Claims and conflict checks happen before editing.
Product changes
Scope shifts can be buried inside the patch.
Codex proposes scope changes for founder confirmation.
Continuity
The next session reconstructs context from git diff and chat.
The next session reads the submit record and durable memory.

FAQ

Codex users usually ask how much ceremony RAAV adds and whether it slows down focused coding work.

Does RAAV slow Codex down?

RAAV adds a short operating loop before and after edits: read context, claim work, check conflicts, submit proof. That small amount of structure reduces rework when multiple sessions or agents touch the same product.

Can Codex create tasks in RAAV?

Codex should propose new tasks or requirement changes rather than writing product truth directly. The founder can confirm, defer, reject, or reopen those proposals.

What does Codex read first?

A good run starts with the Product Handbook, current context pack, open task list, active lanes, and conflict status for the files it may touch.

Is RAAV useful for a single Codex session?

It is most valuable across repeated sessions, but even a single session benefits from explicit acceptance criteria, file claims, and a submit record.