BIMRI: Persistent Memory for AI Agents

Multi-agent memory with local ownership and portability.

BIMRI is an open-source persistent AI memory system. Keep long-term project knowledge on your machine, carry it between your local agents, and let them build on the same decisions and context. Your investment in teaching an agent stays with you when you change tools.

Use Claude Code for one part of a project and OpenAI Codex for another. Run a local agent on a schedule. Start a new session next week. BIMRI makes the knowledge you've recorded available for the work that comes next.

The memory engine is agent-agnostic: any local agent that can follow its instructions and execute its Python commands can integrate with it. Memory is stored in plain files in your project folder, with no hosted memory service, database, account or API key. Free under the MIT license.

Local Ownership and Portable Long-Term Memory

Every project develops knowledge worth keeping: why a decision was made, what a customer needs, which approach failed, what should happen next. Persistent AI memory lets that knowledge accumulate across sessions and remain available as your tools change.

With BIMRI, you control the files that hold it. You can inspect your memory in a text editor, back it up with the project, and move it to another machine. Your next agent inherits the context you've spent months building.

That is the foundation for compounding intelligence: future work can draw on more of what you've learned. BIMRI preserves the decisions, corrections and findings that make this possible; your agents use them in their work.

Multi-Agent Memory for Shared Project Knowledge

Several agents working on one project on your machine share a common memory. A finding recorded by one becomes available to the others when they next load or retrieve it. This supports parallel work, handoffs between coding agents, and continuity across scheduled runs.

Shared memory also needs a way to handle disagreement. BIMRI combines independent updates automatically. When two agents make incompatible concurrent changes to the same subject, it preserves the conflict for you to resolve. A confirmed decision cannot be silently replaced in memory by an agent's inference.

Example: Two Coding Agents, One Project Memory

Suppose you're building a booking app with two agents. One works on the booking flow while another investigates the calendar integration. Later, a third agent takes over the next stage with the project memory already in place. In this fictional project, BIMRI keeps track of:

What happens	What BIMRI keeps for later work
You decide that customers can book without creating an account.	The confirmed decision, available to the next agent working on the app.
An agent discovers that a calendar integration uses UTC.	A saved finding, with its source recorded.
You change the cancellation period from 48 hours to 24 hours.	The current decision, with the previous version retained in history.
Two agents concurrently propose different changes to the same cancellation rule.	A conflict you can resolve, so one change does not silently replace the other.

Install Persistent Memory for Claude Code or Codex

Give your local coding agent access to the project folder and paste: