One shared memory layer for every agent working in your codebase.

Memkith keeps decisions, failed attempts, review outcomes, and constraints attached to the code they affect, then serves the relevant context to any MCP-connected coding agent before it plans or edits.

Create account Install locally

Works with

CursorCursor
Claude CodeClaude Code
CodexCodex
ZedZed
and other MCP-compatible agents

Every agent can read the code. None inherit what your team learned.

The reasoning behind a codebase is scattered across past sessions, review threads, instruction files, and people. Memkith turns durable lessons into shared, code-scoped memory instead of making every tool start cold.

One codebase · one team memory · any connected agent

Engraving of four different drafting pens converging on one shared inkwell

Every lesson follows the same lifecycle as your code.

The reasoning behind your codebase stops living in people's heads and scattered instruction files. It is versioned, reviewed, and inherited like the code itself.

Engraving of an open card-catalog drawer with one index card lifted, mid-filing

Capture

A decision, team rule, or failed attempt is written down once, scoped to the exact lines it came from.

Engraving of a rubber stamp beside an index card carrying an approval seal

Govern

It rides the branch and ships through the same review as the code, so memory merges only when the work does.

Engraving of drafting tools on a technical drawing with an index card propped for reference

Use

Every connected agent recalls it before the first edit, so no tool starts from a blank slate.

Every memory has an address in the codebase.

Decisions, failed attempts, review outcomes, and rules stay scoped to the repository, branch, file, and lines they came from. Any connected agent gets the relevant context before it edits.

Repoacme/apiBranchfeat/retry-budget

Memkith connected

Code-scoped memories

src/lib/retry.ts

1export async function withRetry(fn, opts) {2◆  const budget = opts.budget ?? DEFAULT_BUDGET;3◆  while (budget.take()) {4    try {5      return await fn();6    } catch (err) {7      if (!isRetryable(err)) throw err;8      await backoff(budget.attempt);9    }10  }11}

◆ Attached · lines 2-3 · PR #142

Memory follows code visibility.

Locally, git is the boundary: drafts stay local, branch memory merges with the code, and every record keeps its commit, author, and file scope. The hosted control plane extends that model to connected repositories and team access.

Engraving of a flat-file cabinet with a single open drawer revealing drafted sheets

Connect Memkith once. Keep your agents interchangeable.

The CLI handles setup. Agents read and write shared memory through MCP.

Create account

01
Install the CLI
brew tap memkith/memkith && brew install memkith
Install the CLI and MCP server.
02
Log in
memkith login
Create the repo-local Memkith workspace and connect your account.
03
Connect your agents
memkith integrate --all
Print the native MCP setup for Claude Code, Cursor, Codex, and Zed.

Give every agent what your team already knows.

Create your Memkith account, connect the CLI, and keep code-scoped memory independent of any single agent.

Create account

memkith

One shared memory layer for every agent working in your codebase.

Works with

CursorCursor
Claude CodeClaude Code
CodexCodex
ZedZed
and other MCP-compatible agents

export async function withRetry(fn, opts) { const budget = opts.budget ?? DEFAULT_BUDGET; while (budget.take()) { try { return await fn(); } catch (err) { if (!isRetryable(err)) throw err; await backoff(budget.attempt); } }}

One shared memory layer for every agent working in your codebase.

Every agent can read the code. None inherit what your team learned.

Every lesson follows the same lifecycle as your code.

Capture

Govern

Use

Every memory has an address in the codebase.

Memory follows code visibility.

Connect Memkith once. Keep your agents interchangeable.

Install the CLI

Log in

Connect your agents

Give every agent what your team already knows.

memkith

One shared memory layer for every agent working in your codebase.

Every agent can read the code. None inherit what your team learned.

Every lesson follows the same lifecycle as your code.

Capture

Govern

Use

Every memory has an address in the codebase.

Memory follows code visibility.

Connect Memkith once. Keep your agents interchangeable.

Install the CLI

Log in

Connect your agents

Give every agent what your team already knows.