New in 0.4Team memory, part of Mnemolith
What one person teaches their AI, the whole team’s AI knows.
Share a memory and it becomes a small file in your repo. Your team reviews it in a pull request like any other change, and from the next pull, everyone’s Claude Code, Cursor and Codex know it. When the code it depends on changes, it’s flagged for everyone, not just the person who changed it.
In a repo, with Mnemolith installed:
mnemolith team init
---mnemolith: 1status: activeauthor: Priya Shahfiles: - shop/catalog.py@3f2a9c1b04de---Never cache prices: they change during sales, and acache served stale prices in March. Batch with get_prices.
Mnemolith wrote the file. You commit it. Your team reviews it.
What changes with team memory
-
Without it
Every AI learns it again
You told your AI that prices are never cached. Your teammate’s AI doesn’t know, so it adds a cache on Monday.
-
You share it
Reviewed like code
The memory becomes a file in a pull request. A teammate approves it, or asks a question, before it reaches anyone.
-
After the merge
Everyone’s AI knows
Each teammate’s AI gets it in its next session, first in recall, labelled as the team’s.
See it in 70 seconds.
What Mnemolith does, and what team memory adds: a memory shared in a pull request, flagged for everyone when the code changes, and caught in review before the merge.
How a memory reaches your team.
No server and no account: team memory travels with your code, through git. Each person still keeps their own memories, and decides what to share.
Teammates without Mnemolith aren’t left out: mnemolith.md
at the top of the repo lists every team memory in one line. Setup offers
to point CLAUDE.md and AGENTS.md at it, so their
AI tools read it too.
Plain files, so your team stays in charge.
Team knowledge is too important to live in a black box. Keeping it in the repo means it works with everything your team already does.
Reviewed like code
Every new memory, edit and retirement is a change in a pull request. Nobody’s AI learns something the team didn’t see.
History for free
Git keeps every version and who wrote it. Retired memories keep their file, so “why did we stop caching prices?” still has an answer.
Follows your branches
A memory added on a branch exists only there until it merges, so knowledge is reviewed with the code it describes.
Access is repo access
Whoever can see the repo can see its team memory. No accounts, no separate permissions to manage.
No merge conflicts from sharing
One file per memory, so two people sharing on different branches merge cleanly. If two people edit the same memory, Mnemolith shows both versions and keeps it out of recall until it’s settled.
Flags only what matters
A memory can follow one function, setting or section instead of a whole file, so it’s flagged when that part changes, not on every edit. Renamed files are followed.
Caught in review
mnemolith team action adds a GitHub workflow that comments on pull requests that change something a team memory depends on. It keeps one comment per pull request up to date as you push. New, and lightly tested.
Works across tools
Claude Code, Cursor, Codex and Claude Desktop read the same team memory, whatever each teammate prefers.
Careful about what it shares.
A memory in the repo is visible to everyone who can see the repo, so sharing is always a choice, and these checks run in code, not in a model. How team memory keeps secrets out.
Secrets are refused
Every memory is scanned before it’s written. Keys, tokens, passwords (written as DB_PASSWORD= or in plain words), card numbers and addresses with a password in them never reach the repo. Something that only might be a secret is left for you to decide.
A heads-up before sharing
“This memory will be visible to everyone with access to this repo.” You can turn the question off once you’re used to it, and back on in Settings.
Each person opts in
Cloning a repo doesn’t feed its team memory to your AI. You choose with mnemolith team init, and mnemolith team remove undoes it for you alone.
Your AI shares only if you allow it
AI tools can share when you ask, once you’ve said they may. Until then, they tell you how to do it yourself.
It never commits
Mnemolith writes files. Committing, pushing and opening the pull request stay with you.
Nothing leaves your machine
No server and no telemetry. Team memory moves only when you push and your teammates pull.
We tested it with two teammates.
Teammate A told their AI something and asked for the team to know it. Teammate B, in their own clone and a fresh session, then got a task that needed it. An automatic check graded every run.
| Setup | Tasks done right | What happened |
|---|---|---|
| No memory | 2 of 4 | Pointed staging at the production database and skipped refund approval. |
| Mnemolith, personal only | 2 of 4 | A’s AI remembered, but only for A. B’s AI never heard it. |
| A shared CLAUDE.md | 3 of 4 | Missed the staging database, which came up in conversation and never made it into the file. |
| Mnemolith, team memory | 4 of 4 | A’s AI shared each fact as a team memory, and B’s AI used it. |
One run per task, so read it as a direction, not a final score. In three more tasks the code changed after sharing, and every setup handled it: in a small repo, Claude reads the code and notices. A team memory session cost about $0.15, a little more than a notes file ($0.12–0.14). The full write-up includes what we changed in the evaluation along the way.
Set it up in a minute.
Team memory comes with Mnemolith 0.4. It’s free, and needs:
- Your project in a git repo your team shares
- Mnemolith on each teammate’s computer who wants their AI to use it (install). Everyone else can read
mnemolith.md
Start it in your repo
mnemolith team init
It offers to bring in the notes your repo already has in CLAUDE.md or AGENTS.md, and to have Claude Code or Cursor read the repo and draft up to 30 starter memories, so your team doesn’t start from nothing. Anything that looks like a secret is left out.
Share what your team should know
mnemolith promote m42
Or use Share with team in the dashboard. After mnemolith team ai on, you can just ask your AI to share something.
Commit, then teammates join
mnemolith team init
Review what was written, then commit .mnemolith/team/, mnemolith.md and .gitattributes like any change. Each teammate runs the same command in their copy to start using it.
Common questions
Short answers about what’s shared, who sees it, and what it costs.
Are my own memories shared?
No. They stay on your computer. Only a memory you choose to share goes into the repo, and it moves to the team instead of being copied, so nobody sees the same fact twice.
Who can see team memories?
Everyone who can see the repo. For a public repo, that’s anyone on the internet, so Mnemolith refuses anything that looks like a key or password, and asks before every share unless you turned that off.
Does it need a server or an account?
No. Team memories are files in your repo, and they move when you push and pull. It works with GitHub, GitLab, Bitbucket or any other git host.
What if a team memory goes out of date?
Each one remembers the versions of the files it depends on. When one
changes, every teammate’s AI sees it flagged as possibly
outdated and checks the code first. Someone confirms it
(mnemolith team confirm), rewords it
(mnemolith team edit) or retires it, and commits that.
The file records who did, and when. With
Mender on, the fix is usually drafted
already: approve it in the dashboard.
Does a new team memory start empty?
It doesn’t have to. When you start one, Mnemolith offers to bring
in the notes your repo already has, and to have your AI tool read the
repo and draft up to 30 starter memories (Claude Code or Cursor;
Codex experimentally): how to build and test it, its conventions, what not to
change. It runs once, under your own plan with that tool, kept to
reading files and adding team memories. You review everything before
committing. mnemolith team draft does it later.
How do I know what my teammates added?
After a pull, mnemolith team and the dashboard mark the
memories that arrived since you last looked. Your AI gets them in its
next session either way.
What if two people change the same memory?
Git can’t merge them, so Mnemolith shows both versions side by
side and keeps that memory away from AI tools until it’s settled.
Choose Keep yours or Keep theirs in the
dashboard (or mnemolith team keep <name> mine), or
combine them by hand, then commit.
Can I take a memory back after sharing it?
Yes: mnemolith team unshare <name> makes it one of your
own again and retires the team’s copy. Its file stays, so the
history does too. Commit the change so teammates’ AI tools stop
using it.
Can I edit a team memory by hand?
Yes. Use Reword in the dashboard or
mnemolith team edit, or open the file: it’s short
plain text. After a hand edit, run mnemolith team sync to
update mnemolith.md.
What about teammates who don’t use Mnemolith?
They can read mnemolith.md, a one-line-per-memory list at
the top of the repo. AI tools don’t read that file on their own,
so setup offers to add one line to CLAUDE.md and
AGENTS.md pointing at it. Their own setup doesn’t
change.
Does it cost anything?
No. Team memory is part of Mnemolith, which is free and open source.