Noureddine RAMDI / Ori-Mnemos: scoped memory management for AI agents in TypeScript

Created Sat, 23 May 2026 20:41:14 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
922 Words
github-stars typescript ai-agents memory-management cli developer-experience

aayoawoyemi/Ori-Mnemos

Ori-Mnemos tackles a problem that often trips up AI agent developers: how to persist and manage the memory of an agent across sessions, projects, and machines efficiently and flexibly. Instead of a one-size-fits-all memory store, it introduces scoped vaults and activation modes to control where and how agent context is saved and accessed. This is crucial when building multi-agent systems or long-running AI workflows where session context continuity matters.

What Ori-Mnemos does and its architecture

At its core, Ori-Mnemos is a TypeScript CLI tool designed to initialize and connect to AI agents with persistent memory support. It abstracts memory management into three install concepts: scope, activation, and vault.

  • Scope determines the persistence boundary: global means one vault shared across the machine, while project confines memory to a single repository or workspace.
  • Activation defines when the memory context is loaded: auto triggers an automatic orientation at session start if the adapter supports it, whereas manual requires explicit invocation, leaving tools available but inactive until called.
  • Vault is the explicit storage location for memory. An explicit vault path or identifier can override the default resolution based on scope and activation.

The repo enforces precedence rules to resolve conflicts:

  • Project installs override global installs.
  • Explicit vault specification wins over inferred vaults.
  • Project activation settings override global activation.

This layered approach provides fine-grained control over memory management, crucial for complex AI agent environments where different projects or sessions require isolated or shared context.

Under the hood, Ori-Mnemos supports lifecycle management of “bridges” — connectors between the agent and its memory vault. Re-running the same ori bridge ... command updates the vault path or activation mode in place, and uninstall commands remove the Ori-managed config cleanly from supported adapters.

The repo also includes automated adapters for Claude Code and Hermes Agent, which hook into their respective environments to auto-orient memory at session start and capture insights at session end. Other clients, like Cursor and Codex, have native support for MCP config, and Ori offers generic bridge commands for MCP clients to integrate memory management.

Technical strengths and design tradeoffs

What distinguishes Ori-Mnemos is its explicit handling of memory scope and activation lifecycle. Many memory tools for AI agents either assume a global or ephemeral state, but Ori-Mnemos makes these parameters configurable and enforces precedence clearly. This is a strong point for developers building multi-agent or multi-project AI systems where memory leakage or overlap can cause subtle bugs.

The codebase is TypeScript-based, likely focusing on developer experience and type safety, which is expected given the complexity of managing multiple scopes and bridging different adapters. The presence of automated lifecycle hooks for popular agents and adapters shows an attention to integration and practical deployment.

The tradeoff here is complexity: managing scopes, activations, and vaults can introduce cognitive overhead and configuration steps. While this is necessary for flexibility, it means Ori-Mnemos might be overkill for lightweight or single-session projects.

Another consideration is that the tool relies on adapters’ support for auto-orientation, which might not be uniformly available, requiring manual activation in some environments.

The repo’s approach to bridge lifecycle commands (ori bridge ...) that allow in-place updates and clean uninstall is a nice developer experience touch, ensuring that memory configuration can evolve without messy manual edits.

Quick start

npm install -g ori-memory
ori init my-agent
cd my-agent

To connect to your agent:

# No direct connect command shown, assuming connection after init and cd

The documentation highlights separate install concepts and precedence rules, which are critical to understand for proper usage:

  • Scope: global vs project
  • Activation: auto vs manual
  • Vault: explicit vs inferred

It also details adapter-specific behaviors, mentioning that Claude Code and Hermes Agent have fully automated adapters with lifecycle hooks, while others may require manual setup.

verdict

Ori-Mnemos is a solid choice for developers building AI agents requiring persistent, scoped memory that can flexibly span projects and environments. Its explicit handling of memory scope, activation mode, and vault precedence is a strength that brings clarity to what is often an opaque problem.

Its TypeScript codebase and CLI tooling make it approachable for JavaScript/TypeScript developers, especially those working with AI agents on platforms like Claude Code and Hermes Agent.

The tradeoff is added complexity and setup overhead compared to simpler ephemeral memory solutions. It fits best in scenarios where memory persistence across sessions and projects is non-negotiable and where multiple adapters or agents coexist.

Overall, Ori-Mnemos fills a niche in AI agent tooling with a pragmatic, configurable approach to memory management. It’s worth exploring if you need fine control over your agents’ memory lifecycle and context persistence.

→ GitHub Repo: aayoawoyemi/Ori-Mnemos ⭐ 305 · TypeScript