Kimetsu logo
100% localNo cloud, no telemetryMIT / Apache-2.0

Memory for your coding agent that gets sharper every run

Kimetsu is a single Rust binary that runs next to your agent over MCP. It remembers what matters, learns which memories actually helped, and lets that knowledge compound across sessions. Proactive memory for AI coding agents.

$ npm install -g kimetsu-ai
73.3%BEAM 100K memory benchmatches the prior public SOTA, with no model in the pipeline
66.0%BEAM 1M memory benchahead of mem0's self-reported 62% at the same bucket
83.0%LongMemEvalthe public long-term-memory benchmark
13×cheaper per solved task$0.19 vs $2.47 on a 16-task Terminal-Bench slice
~1Mmemories in ~3 GB RAMsub-2s retrieval, one SQLite file
$0API cost to rememberthe memory pipeline calls no model
Under the hood

The parts worth a closer look

Most memory tools are a bucket you read and write. Kimetsu is a cycle: every session feeds the next one, and the knowledge that proves useful is the knowledge that survives.

  1. 1

    Work

    The agent solves a task and earns a lesson worth keeping.

  2. 2

    Capture

    It lands in the brain as a memory. No model, no cloud, no cost.

  3. 3

    Recall

    Next run it comes back by meaning, before the work even starts.

  4. 4

    Cite

    The agent marks the memories that actually moved the task.

  5. 5

    Learn

    Cited memories rise in rank; stale, unused ones decay and prune.

feeds the next session
Free is half the story

Most memory waits to be asked. Kimetsu speaks first.

A vector store sits idle until you query it. Kimetsu is proactive: it reads the moment, decides what the agent needs, and puts it on the table before the first turn, so knowledge shows up when it changes the outcome, not after.

Passive memory

you ask it fetches

Nothing happens until a query arrives. If the agent does not know to ask, the memory never surfaces.

Proactive memory

it anticipates then delivers

The brain surfaces the right context on its own, at session start and ahead of each task, before the agent can repeat a solved mistake.

Session-start digest

Open a new session and the brain has already handed the agent the conventions, gotchas, and decisions that matter here.

Episodic resume

It picks up where you left off: what you were doing last time and the state you left it in, without you re-explaining.

Context before the ask

Before a non-trivial task, the relevant lesson is surfaced automatically, so the agent avoids the mistake instead of repeating it.

Remembers what matters

Project conventions, failure patterns, the exact command that regenerates your schema. Captured once, retrieved by meaning.

Learns what helps

Memories the model cites before it solves a problem get promoted. Stale advice and silent passengers decay and get pruned.

Never explores twice

A session-start digest and an episodic resume mean the first turn already knows the repo and what you were doing last time.

Answers, not just injects

kimetsu ask composes a grounded, cited answer from memory using a local model. Zero frontier tokens, works offline.

Model-free retrieval

FTS5, local embeddings, and a local cross-encoder reranker. Nothing in storage or retrieval calls an LLM.

Yours on your machine

One SQLite file per project. No external vector database, no cloud, no telemetry. Back it up with cp.

Brains are portable

Export, merge, and swap brains freely

A brain is a file, not a hostage. Pack up what your agent has learned, hand it to a teammate, install one from a URL, or swap whole brains in and out. Onboard a new machine or a new hire with one import.

Export

One command turns your brain into a shareable pack: gzip-compressed and security-scrubbed, so credentials and PII never leave your machine.

Merge

Import a teammate’s pack additively. It dedups against what you already know, and re-importing is always safe.

Swap

Replace your current memories with a pack’s, reversibly. Old memories are superseded, never deleted, so you can always swap back.

$ kimetsu brain export team.json.gz --name rust-conventions # scrubbed pack
$ kimetsu brain import team.json.gz # merge + dedup
$ kimetsu brain import https://example.com/pack.json.gz # from a URL
$ kimetsu brain import other.json.gz --mode replace --yes # swap, reversible

Set it up in two commands

$ npm install -g kimetsu-ai
$ kimetsu setup --host claude-code