Skip to Content Skip to main content

Persistent memory for coding agents

Keep the path between sessions.

Waykeep records the decisions, pitfalls, and corrections your next coding-agent session needs, local by default, shared with your team when you choose.

Install free See Waykeep Team

Local-first Claude Code + Codex

Illustrative flow

Session 01

[decision] Keep migrations idempotent.

Compaction

… context compacted …

Session 02

[waykeep briefing] Decision restored.

Teammate · Waykeep Team

[shared decision] Keep migrations idempotent.

The interruption

Context windows close. The work behind the work shouldn't.

  1. 01

    Decisions disappear.

    The reason behind a migration or boundary is gone when the next session begins.

  2. 02

    Corrections repeat.

    A fixed approach returns because the lesson lived only in the conversation that ended.

  3. 03

    Agents become islands.

    Claude Code and Codex solve the same problem separately instead of carrying the lesson forward.

Free core · local-first

Memory stays with the work.

Agent hooks record useful context in local Waykeep memory. The next session receives a briefing or warning before it repeats the same mistake.

Read how it works
Local continuity loop
  1. Agent hooksRecord decisions, corrections, and pitfalls.
  2. Local Waykeep memoryThe free core keeps records on your machine.
  3. Next briefing or warningRelevant context returns when it can help.
[pitfall] The editor hook target moved.
[waykeep warning] Confirm the current target before inheriting.

Ambient · Claude Code

You can watch the memory working.

Most memory tools are invisible until you ask them something, so you never quite know whether anything is happening. Waykeep puts its own state in your status bar and keeps it there: what it can recall from where you are standing, how much room the session has left, and where the current plan has got to.

It updates every turn. Nothing to open, nothing to query.

See how it is wired
The bar, reading a real store
Waykeep: normal | 54% free | step 4/5 | 658 mem 1 rem
normal
Context mode. It shifts to compact, minimal and critical as the window fills, and Waykeep trims what it returns to match.
54% free
Room left before the session auto-compacts, with the buffer already subtracted.
step 4/5
Progress through the active plan for this project.
658 mem
Memories reachable from here: this project plus the ones you marked global. Other projects are excluded, which is why the number is smaller than your total.
1 rem
Reminders armed and waiting for their trigger.

And when it cannot read something, it says which thing.

A status bar that fails into a shrug is worse than none, because you cannot tell a quiet system from a broken one. Every degraded state names itself and points at one fix.

Waykeep: normal | 54% free | no store
Waykeep: normal | 54% free | store unreadable
Waykeep: normal | 54% free | no project

Across agents

One memory. Claude Code and Codex.

Recorded knowledge stays useful when the agent changes, not only when a session restarts.

Claude Code

$ npm test
ERROR: migration ran twice
[correction] Make migrations idempotent.

Codex

[waykeep warning]
Make migrations idempotent.
$ npm test
PASS

Claude Code records the correction. Local Waykeep memory carries it to Codex before the same work resumes.

Recorded with a type

Memory you can inspect.

Named records keep the useful part concrete: what changed, why it matters, and when it should return.

Decision

Keep migrations idempotent.

Re-running an upgrade must leave the same schema state.

Pitfall

The editor hook target moved.

Confirm the current target before inheriting it.

Correction

Use the copied theme model.

Theme records are website-scoped after apply.

Plan

Audit both color modes.

Accessibility sign-off covers light and dark.

Fact

Team sync is entitlement-gated.

The local core continues without paid sync.

Pattern

Evidence before adjectives.

Show the recorded state and its retrieval path.

Waykeep Team · paid shared path

Your team already learned this lesson.

Waykeep Team syncs shared memory through a server when a project joins the team path. Sync is entitlement-gated, supports encryption tiers, and keeps repo-committable memory explicit.

$15 / seat / month

Start 14-day trial
Local memories remain local until Team sync is chosen.
  1. Alex · localA retained project lesson.
  2. Waykeep TeamEntitlement-gated shared sync.
  3. Sam · localThe shared lesson reaches Sam's agent.

The boundary, plainly

Local by default. Shared when you choose.

Free core

Your machine, your project memory.

Scope
Local-first memory for your work.
Agents
Claude Code and Codex use the same retained context.
Price
Free.
Inspect the source

Waykeep Team

A deliberate shared route.

Scope
Team memory syncs only for joined projects.
Controls
Entitlement gating and encryption tiers define the shared path.
Price
$15 per seat each month after 14 days free.
Read the boundary

For individual work

Start local for free.

Install the core, keep memory on your machine, and carry useful context across Claude Code and Codex.

Install free

For shared work

Share the trail.

$15 / seat / month after a 14-day free trial. Add entitlement-gated sync when the team is ready.

See Waykeep Team
Waykeep marker

Next checkpoint

Give the next session somewhere to start.

npm install -g waykeep

Read the docs