01
Remember as it happens
Whenever an agent hits something worth keeping — a decision, a failed approach, a constraint — its memkith directives say: write it down. Mid-session, the moment it happens.
memkith_learn → draft · local only
memkith
The shared brain for your team and their agents.
memkith serves the episodes behind your code — decisions, reviews, failed attempts — to Claude, Cursor, and Copilot.
memkith_recall
Context your agents can trust.
When an agent asks why, memkith answers with the episode behind the code — the decision, the failed attempt, the rule — and the provenance to back it up.
Answers carry sources
Every memory cites the commit, branch, author, and date it came from — provenance the agent can quote.
Agent work becomes team memory
What one session learns, every MCP-connected agent — Claude Code, Cursor, Copilot — can recall.
Reviewed before it's committed
Memory ships through the same git review as your code. Immutable once written; superseded, never edited in place.
agent session — your-repo
❯ memkith_recall("payments retry")
3 episodes · scoped to src/payments/
[1] retry with exponential backoff — failed
hard 5s callback timeout in the gateway
main · a1b3f2c · 2025-11-04 · maya
[2] payment tests require --isolation=forked
supersedes v1 · main · 9c0d411 · arun
[3] postmortem: shared state needs a mutex
feature/payments-retry · not yet on main
agent: citing [1] — skipping the retry approach
Terminal demo. The agent calls memkith_recall with the query “payments retry” and receives three episodes scoped to src/payments: a failed retry-with-exponential-backoff attempt caused by a hard 5 second callback timeout, committed on main at a1b3f2c by maya on 2025-11-04; a rule that payment tests require isolation equals forked, which supersedes version 1, committed on main at 9c0d411 by arun; and a postmortem noting shared state needs a mutex, committed on feature/payments-retry and not yet on main. The agent cites the first episode and skips the retry approach.
The problem
AI coding starts from zero.
Cursor, Copilot, Claude Code make one developer faster. They never see the architect's intent, the reviewer's pushback, or last quarter's postmortem.
Every session opens blind. New hires spend weeks decoding decisions; agents re-ask what shipped and why. Each retell burns engineer hours and tokens — paying again for context the team already owns.
What Cursor discovers never reaches Claude, CI, or the next teammate. The reasoning behind every rollback and edge case lives in one head — until that person leaves and the next agent re-learns it the expensive way.
how it works
Remember. Review. Recall.
memkith's directives run in every agent session: save what's worth remembering the moment it happens, and check team memory before re-deriving it. A memory reflex — like yours, but for agents.
──▶
│
▼
02
Reviewed in git
Memories ship with your branch through the review you already trust. Merge to main makes them the team's. No new approval queue — just git.
committed on feature/x → merged to main
──▶
│
▼
03
Recall before guessing
When any agent needs context — why is this here, what was already tried — it asks team memory first instead of starting cold.
memkith_recall → episode + provenance
git visibility
Memory follows git visibility.
An agent recalls exactly what its checkout can see — no more, no less. A branch inherits all of main, then adds its own.
Visibility nests by checkout. The main checkout sees three memories, visible to every clone. A feature branch checkout sees those same three plus two branch-only memories — five in total — until it merges, at which point all five land on main for everyone. An uncommitted draft sits outside every checkout, local only.
◌Retry jitter ideadraft · in no checkout yet
feature/payments-retry checkoutsees 5
main checkoutsees 3 · every clone
- Charge endpoint stays idempotent
- Payment tests need --isolation=forked
- Gateway must call back within 5s
git merge
branch-only · until merge
- Postmortem: payment state mutex
- Retry v2: queue with dead-letter
on merge → the branch's 2 join main's 3. Every clone now sees all 5.
with memkith
Stop teaching every agent from scratch.
One recall, and the agent ships the fix on the first try — citing what the team already learned instead of re-explaining it.
agent session — with memkith
❯ fix the flaky payment retry test
agent: memkith_recall("payment retry")
[1] retry with backoff failed — 5s limit
main · a1b3f2c · 2025-11-04 · maya
[2] payment tests require --isolation=forked
main · 9c0d411 · 2026-01-12 · arun
agent: citing [1] — retries will not work here.
agent: running forked, adding the mutex.
✓ passes on the first attempt, with sources
Terminal demo. The agent is asked to fix the flaky payment retry test. It calls memkith_recall with the query “payment retry” and gets two memories: retry with backoff already failed against a hard 5 second limit, committed on main at a1b3f2c by maya on 2025-11-04; and payment tests require isolation equals forked, committed on main at 9c0d411 by arun on 2026-01-12. Citing the first, the agent skips retries, runs forked, adds the mutex, and passes on the first attempt with sources.
- ~45 min saved
- Skips rediscovering what the team already learned.
- Fewer tokens
- No re-explaining the same context every session.
- First attempt
- The fix lands with cited sources, not trial and error.
comparison
Why not just a rules file?
CLAUDE.md and wikis hold instructions. memkith holds episodes — scoped to the code, versioned in git, citable by any agent.
memkith
rules files
wikis & docs
Scoped to files & branches
memkith
●per file, per branch
rules files
—one global file
wikis & docs
—detached from code
Survives merges & rebases
memkith
●travels with git history
rules files
○conflicts on one file
wikis & docs
—drifts from the code
Records failed attempts & postmortems
memkith
●episodes with provenance
rules files
—instructions only
wikis & docs
○if someone writes it up
Versioned, never silently edited
memkith
●immutable, superseded
rules files
—edited in place
wikis & docs
—history nobody reads
Works with every agent
memkith
●MCP — Claude, Cursor, Copilot
rules files
○per-tool formats
wikis & docs
—humans only
Provenance you can cite
memkith
●commit · branch · author · date
rules files
—no trail
wikis & docs
○page history, off to the side
● yes · ○ partial · — no
quickstart
Five minutes to first recall.
Local-first by design. Memory lives in a git-tracked file store inside your repo — no server required, no account needed.
- 01
$ brew tap memkith/memkith && brew install memkithSelf-contained binary. No Python, no runtime to manage.
- 02
$ cd your-repo && memkith initWrites .memkith/config.json and wires the MCP server into .mcp.json.
- 03
$ memkith loginOptional. The memory path is a local git-tracked store — it works without an account.
- 04
$ memkith import CLAUDE.mdSeed team memory from the rules files you already maintain.
Works in Claude Code, Cursor, and Copilot via MCP
Stop re-explaining your codebase.
For teams
One shared memory for every engineer and every agent. Free for teams up to 5. No credit card required.
Start freeFor your own agent
Local git-tracked store. No server, no account — your agent stops starting from zero today.
Run it locally