MITOpen source — read every line on GitHub

Your coding agents forget.LoreKit makes them learn.

When your agent hits a wall and works its way out, it writes down what it learned — and the next agent to hit that wall gets the lesson with the error, on any machine, in any tool. What keeps recurring becomes a rule. What nobody uses gets archived.

npx @lorekit/cli install
  • HostedSign in for a free token and paste it when the installer asks.Get a token
  • OfflineNo account: skip the token, then switch the store to local mode.Offline guide
  • Free · 5,000 memories
  • Claude Code · Cursor · any MCP client
  • Local, hosted, or self-hosted

live demo

Session A writes. Session B already knows.

Two sessions, one store, no re-explaining.

LoreKit Memory — zsh
session A

memory store

local remote

— none yet —

Memories survive session ends · Shared across Claude Code, Cursor & any MCP client

01 / why not just a CLAUDE.md?

Your CLAUDE.md is frozen. Your lore keeps learning.

A rules file holds what you knew to write down before anything broke. LoreKit captures what your agents find out the hard way — and keeps sorting it: what recurs becomes a rule, what nobody uses gets archived.

a month in the life of one lesson

  1. day 1 · your laptop

    Learns

    4tries

    Fixed on the fourth try — and written down by the agent. Nobody asked it to.

  2. day 4 · a teammate’s laptop

    Recalls

    1try

    The lesson arrived with the error, on a machine that had never seen it.

  3. day 9 · CI

    Promotes

    0tries

    Three hits in three places earned it a permanent rule. Now it’s applied before the run.

  4. day 90 · nightly sweep

    Prunes

    −1from context

    Lore nobody opens stops riding along in every session. Archived, never deleted.

A rules file compared with LoreKit
AspectCLAUDE.md / AGENTS.mdLoreKit
Written byYou, when you remember to.Your agents, the moment they hit friction.
KnowsWhat you predicted would matter.What actually broke — and the fix that worked.
Shows upAll of it, every session.What matches: at session start, on each prompt, on the failing call.
Over timeGrows until someone prunes it.Promotes what recurs. Archives what nobody uses.

Keep your CLAUDE.md. LoreKit is how you find out what has earned a place in it.

Error-matched recall runs on Claude Code’s hooks; Cursor reads lessons through its rule and an end-of-turn hook.

02 / how it works

Wire it once. The whole team learns.

The teammate on day 4 got the lesson because of three things: every agent is connected, every lesson knows which repo it belongs to, and the team shares one store.

  1. Connect each agent

    One command wires the MCP server, the skills and the hooks into Claude Code, and picks up your repo’s scope from its git remote. Cursor is three copied files.

  2. Lessons stay with their repo

    Every lesson lands under a scope: a branch, a repo, a project, or everywhere. Agents read narrowest first, so one repo’s lore never crowds another’s.

  3. One shared set for the team

    Bind repo::acme/* to your org and every teammate’s agent reads and writes the same lessons — one copy, updated for everyone at once. CI reads with a read-only token; anything unbound stays personal.

03 / what you get

Memory that earns its place in your context.

A store that learns from the work you already do, and tells you when a lesson has stopped paying for itself.

Memory isn’t free, so we measure it

Every lesson delivered into a session costs tokens whether the agent uses it or not. LoreKit tracks how often each lesson is actually chosen versus merely delivered, estimates what your store costs you a month, and shows you the lore that is earning nothing.

Learns from your code reviews

Point a GitHub webhook at a repo and review comments become candidate lessons. Noise is filtered out, and a candidate expires unless it proves useful.

Every lesson in plain sight

Browse, search and filter everything your agents have learned in the dashboard — who wrote it, where it applies — and edit or archive it in place. Local lore is plain markdown you can grep.

Groomed, never hard-deleted

Retention policies find the lore nobody has opened in months and archive it — previewed first, then reviewed by you or swept nightly. Anything archived comes back with one command.

04 / where your lore lives

Your lore, your call.

The same memory tools run against any of the three.

  • Fully offline

    Local

    No account, no network.

    Markdown files under ~/.lorekit and <repo>/.lorekit — greppable, diffable, and yours. Commit them to share via git, or gitignore them to keep them private.

  • Hosted

    Shared across machines and teammates.

    Every memory is personal by default; org sharing is opt-in. The free plan holds 5,000 active memories at 120 requests a minute.

  • Self-hosted

    Your own infrastructure.

    The whole stack — MCP server, dashboard, database — deploys to your own Supabase and Vercel projects. MIT licensed.

Start local and move up later — lorekit migrate previews the whole plan before it changes anything.

05 / the fine print, up front

What LoreKit doesn’t do

Better you read it here than find it on day one.

  • It doesn’t read your codebase. It stores what your agent writes to it, and nothing else.
  • It doesn’t make an agent smarter on its own. If nothing writes a lesson, there is nothing to read — which is why the plugins wire lifecycle hooks instead of leaving it to the agent’s discretion.
  • It can surface a lesson you didn’t need. Scopes narrow what an agent sees, grooming prunes what has stopped earning its place, and every memory is visible to you in the dashboard.
  • Codex support is experimental. Claude Code and Cursor are the supported paths; anything speaking MCP works too.
  • There is no paid tier yet. If the free limits ever change, your lore exports to plain markdown files you own.

get started

Give your agents a memory.

Free · Open source · No card, because there is nothing to charge for yet

  1. Run one command

    npx @lorekit/cli install
  2. Paste a token, or go offline

    Sign in for a free token to share lessons across machines, teammates and CI. Or skip it and switch to local mode — lessons stay on this machine as markdown you can read and commit.

  3. Check it’s wired

    npx @lorekit/cli doctor confirms the connection, the token and the scopes. With hooks on, every session after starts with the lessons that apply to it.

Shared memory for your coding agents