In daily use since May 2026 · Kyle Clouthier

Memory for my coding agents.

Neruva is the memory layer I built for Claude Code. Every session on my projects starts by recalling what earlier sessions decided and ends by writing down what it did. Decisions, mistakes and facts carry over, so the next session picks up where the last one stopped instead of starting cold.

An MCP server for Claude Code, backed by a hosted API at api.neruva.io

claude code · a typical session
# 1. start: recall before touching anything
agent_recall("how do I release the game site?")
→ decision: release only through the release script, preview first
→ mistake: skipped the preview once and shipped a broken page

# 2. work: log what matters as it happens
agent_remember("decision: board clicks fly the camera to that nation")

# 3. end: leave a note for the next session
records_ingest(kind="session_end", "fixed board clicks, released, next: watch quit rate")
✓ stored · recalled by the next session, any day, any project
3,458records in my main memory
591sessions closed with a handoff note
4,856subjects in the knowledge graph
79,464API calls in the last 30 days
How I use it

Four steps, every session

A coding agent forgets everything when the session ends. I work on several projects, mostly on weekends, so without memory every session began with me re-explaining where things stood. Now the agent does this on its own.

1

Recall first

The session opens by asking Neruva what earlier sessions decided about the task, including what went wrong last time.

2

Log as it goes

Decisions, mistakes and shipped work are written as typed records the moment they happen. So far: 617 decisions, 146 mistakes, 775 shipped milestones.

3

Keep facts straight

Stable facts go in the knowledge graph: where a project lives, who handles what, which release steps are mandatory. When a fact changes, it is replaced and the old value is kept as history.

4

Hand off

Before closing, the session writes a short note: what was done, which files changed, what comes next. The next session starts from that note.

This runs on every coding session across my projects: SECOND STRIKE, client marketing work, and the small live sites I run.

In production

Inside a live game, too

SECOND STRIKE is a real-time world war on a 3D globe where people and AI models play. Its server has used Neruva as its memory since October 2026, under its own tenant, with one private namespace per player and per agent.

Leaders who remember you

After a war, the game records what happened between the player and each AI leader: a broken pact, a nuclear strike, a pact kept to the end. Next war, those leaders greet the player with it and carry it into their talk.

AI agents with a war diary

Every registered AI League agent gets a diary: who betrayed it, who hit it, who it wiped out, plus notes of its own. Its next war starts with the newest entries and anything about the players it is facing.

Both are best effort by design: a slow or failed memory call never touches a war.

The system

What is under it

The server does storage, search and counting. Reading the results and deciding what they mean stays with the agent. Same stored state and same query give the same answer.

Records store

Typed events (decision, mistake, fact, note, session_end and more), searchable by meaning and keyword together, filterable by kind, tag and time.

Agent recall

One call that searches records and the knowledge graph at once and returns a context block ready to drop into the prompt.

Knowledge graph

Subject, relation, object facts with multi-hop lookups. Replacing a fact keeps the old one as history.

Snapshots

Save a namespace and restore it later, so a past answer can be checked against the memory it came from.

Forget

Delete records by kind, tag or time, or remove every fact about one entity in both directions.

Namespaces

Each project gets its own memory. Every call is metered, so I can see what each project uses.

Also live in the API: a content-addressed context store, vector indexes, a code graph, case memory, causal models, PII redaction and a signed audit log.

Full breakdown, packages and tool list
Working together

Three ways to use it

The API is already multi-tenant: every client gets its own keys, namespaces, rate limits and usage metering.

1

Memory for your coding agents

I set up Neruva for your team's Claude Code sessions, with the same routine I run: recall first, log as you go, hand off at the end.

2

Memory inside your product

Give your AI characters, assistants or agents memory of each user, the way SECOND STRIKE's leaders remember each player.

3

Partner or license

Use the hosted API under your own tenant, or talk to me about licensing it for your platform.

Want to see it running?

I will show it live on my own projects and talk through what it would look like on yours.