Skip to main content
Live on Scaleway fr-par · Phases 0–7 complete

Persistent project memory for AI coding agents

Erold captures every decision, bug fix, and deploy your agent makes — so the next session picks up exactly where the last one stopped. No more re-explaining context every time you open Claude Code.

Get started — free Read the quickstart

EU-resident · End-to-end redaction · Open-source backend

The problem: every new agent session starts from zero

Claude Code forgets everything between sessions. You repeat context, re-explain decisions, watch the agent re-discover bugs it already fixed. The more projects you run, the worse it gets.

Erold solves this with a three-piece system: 9 passive hooks that write to a local JSONL outbox, a background flush daemon that ships events to the backend while the agent works, and a structured API that assembles the full project state in one serializable read. The agent calls get_context() at session start and has everything.

How it works

Three blocks, one pipeline.

Step 1

Hooks → Outbox

9 hook types fire silently on Claude Code events. Each writes one JSON line to ~/.erold/outbox/events.jsonl in <60 ms. No network call, never blocks the agent.

  • PreToolUse(Bash)
  • PostToolUse(Edit|Write|Bash)
  • UserPromptSubmit
  • SessionStart · SessionEnd
  • SubagentStop · PreCompact
Step 2

Outbox → Backend

A background daemon flushes the JSONL to /v1/events/batch with idempotency keys + dedup_hash. At-least-once delivery. Dead-letter on 4xx.

  • FastAPI + asyncpg
  • Postgres 17 + pgvector HNSW
  • Smart-Strip compression
  • Embedding worker (async)
  • RLS per tenant
Step 3 — Next session

get_context() returns the full project state

open_tasks

Tasks with status, priority, provenance

open_bugs

Symptom + severity

resolved_bugs

root_cause + fix_narrative — never truncated

decisions

All decisions ever made — never compressed

deploy_history

Last 5 per env, outcome + notes

credential_refs

Names + store — values never stored

what_to_do_next

Ranked: open high-pri tasks + open bugs

recent_fragments

Top-20 semantically relevant fragments

How Erold builds memory

Three interlocking mechanisms. Together they give any new agent a complete picture of every project it joins, from the first session to the latest.

Passive capture

Nine hooks fire silently on every file edit, Bash command, user prompt, subagent start/stop, compaction checkpoint, and session lifecycle event. Each returns in <60 ms and writes one JSON line to a local outbox — no network call, never blocks the agent.

Explicit logging

Four things hooks cannot infer: architectural decisions, bug fix narratives, deploy outcomes, and credential references. The agent logs these via MCP tools. If it forgets, the next get_context() call returns a gaps[] array.

Cross-session continuity

Every new session calls get_context() and receives a structured packet: open tasks, open + resolved bugs with fix narratives, every decision ever made, recent deploys, and credential references — assembled in one serializable Postgres read.

Up and running in three steps

Requires Claude Code, Node 22+, jq, and the secret Keychain wrapper. An Erold account or private deployment.

  1. 1

    Store credentials in Keychain

    zsh
    secret set erold.api-key # paste API key, hit enter secret set erold.tenant # paste tenant ID, hit enter

    Values never touch disk outside Keychain. Not in .env, not in .mcp.json, not in shell history.

  2. 2

    Install the plugin

    zsh
    claude plugin install erold-dev/claude-plugin --scope user # Verify: claude mcp list # erold-pm: ✓ Connected

    The plugin ships an MCP launcher that reads credentials from Keychain at startup — no claude mcp add needed.

  3. 3

    Link a project

    zsh
    /erold:init

    Creates .erold.json at the project root with only a projectId — safe to commit. From here, just work.

Full setup guide with troubleshooting

Built to be trustworthy by default

Security and privacy are not opt-in features — they are the baseline.

EU-resident

Backend runs on Scaleway fr-par. Data does not cross EU borders. No US hyperscaler involved.

End-to-end redaction

Two layers before any event leaves your machine: a path denylist drops .env/.ssh/.pem events entirely; a pattern blocklist redacts AWS/Scaleway/GitHub/Anthropic keys, JWTs, and PEM blocks.

RLS per tenant

Row-Level Security at the Postgres layer. App layer is a second check; DB is the backstop. Cross-tenant queries return 0 rows even with direct DB access.

Open source

erold-backend is MIT licensed. Audit the code, run your own instance, or contribute. No black-box backend.

Give your next agent session a full memory

Free tier coming. Self-host today via the open-source backend.

Get started free Self-host on GitHub