Local-first memory for coding agents

Your agent
remembers the work.

Memorix keeps the decisions, code context, and unfinished threads that should survive the session - ready for the next task, the next window, or the next agent.

Install Memorix View on GitHub

$npm install -g memorix

Open source. Runs on your machine. Works with the agents you already use.

PROJECT MEMORY / READY

MCP + CLI + HOOKS

memorix / workbenchlocal

Context is assembled when the task needs it.

CONTINUITYNext session, same project.Relevant memory, not a transcript dump.

STORAGESQLite + local searchSemantic providers stay optional.

One memory layer. Many ways to work.

Claude CodeCodexCursorOpenCodeGemini CLIPiCopilot

The problem

A new session should not be a reset button.

Coding agents are powerful in the moment. The expensive part is making them rediscover the project every time the context disappears.

Memorix turns the work itself into a durable, searchable project layer.

01
Work normally
Your agent reads, edits, tests, and makes decisions in the project.
02
Keep what matters
Useful observations, code state, handoffs, and reviewed knowledge stay available.
03
Continue without ceremony
The next task gets a small, relevant brief. Details are available when needed.

The memory layer

Three jobs. One quiet system.

Memorix is designed around the way coding work actually changes: context moves, code evolves, and memory needs boundaries.

Remember the decisions

Capture fixes, gotchas, session handoffs, and the reasoning behind a change. The useful part of yesterday's work becomes available without replaying yesterday's chat.

Task-shaped context, kept within a budget
Reviewed long-term memory for durable facts and procedures
Natural-language retrieval through MCP or CLI

A task brief can start here

$ memorix context "finish the release checks" --brief-json

selected: current facts + verification + next steps

Understand the code

Code memory connects project facts to files, symbols, and source-backed relations. It helps an agent move from 'what happened?' to 'where does this change belong?'

Versioned code state and freshness checks
TypeScript and JavaScript symbol relationships
Honest Lite fallback when deeper indexing is unavailable

Requestprepare()

Headersnormalize

Testsrequest.test

source-backed edges, not a decorative graph

Keep memory under control

Local-first does not mean 'store everything forever.' Memorix separates observations from reviewed knowledge, keeps retrieval bounded, and gives you a dashboard and CLI to inspect what is there.

SQLite is the canonical local store
Full-text search works without model keys
Retention, resolution, export, and diagnostics stay explicit

MEMORY CONTROLLIVE

observationssearchable

durable knowledgereviewed

old contextbounded

provider keysoptional

One layer, different entrances

Use the surface your agent supports.

MCP

Let a compatible agent discover a compact memory surface and call it naturally during work.

Connect an agent

CLI

When MCP is missing or unstable, the same memory is available through dependable terminal commands.

Read the API reference

Dashboard

Inspect project memory, sessions, CodeGraph state, retention, and diagnostics when you need the wider view.

See setup options

Start with one command

Give the agent a memory layer. Keep your workflow.

Install once, connect the agent you use today, and keep the same project memory when the tool changes tomorrow.

Read setup docs View on npm

installmemorix

# install the layer

$ npm install -g memorix

# connect your agent

$ memorix setup --agent claude --global

MCP, guidance, and capture are ready.

Questions worth answering

Simple on the outside. Deliberate underneath.

Does Memorix need an LLM key?

No. Local full-text retrieval works without a model key. Embeddings, formation, and compression are optional provider-backed layers.

Is it only for Claude Code?

No. Memorix is a shared local layer with MCP, CLI, hooks, plugin, and package integrations for the coding agents that expose those surfaces.

Will it paste my entire old conversation into every task?

No. Normal context is task-shaped and bounded. Explicit continuation can include a small handoff and durable anchors, with details available on demand.

Is the CodeGraph a complete replacement for every language parser?

No. Memorix gives source-backed TypeScript and JavaScript relations and an honest Lite fallback for other cases. It reports what it knows instead of pretending every graph is complete.

Where does my memory live?

By default, in Memorix's local data directory with SQLite as the canonical store. Remote services are opt-in configuration, not a requirement for the normal local workflow.

Keep building

The next session starts
where the work left off.

Install Memorix Star the project

Your agentremembers the work.