Memmy — Personal AI Agent & Local Memory Hub
Give every AI agent one shared, persistent memory so all AI remember the same you.
Evidence shows local-first architecture, permission management (e.g., scan permissions), token protection (x-memmy-local-token), and configuration references for sensitive data (e.g., API keys), but lacks clear evidence of user confirmation flows. Data flow transparency is limited, dependency security not fully assessed, external effects (e.g., install script) exist but not detailed, rollback mechanisms not explicit, source attribution partial (e.g., acknowledgements).
Self-consistency is good with multiple test files and version sync scripts, but dependency availability unverified, failure messages present in some tests but overall insufficient.
Target audience clear (personal AI agents), scenarios diverse (cross-agent task continuity), but capability boundaries and trigger precision underdescribed, environment fit documented but not comprehensive.
Information architecture clear (README, docs links), install notes detailed, naming stable but changelog missing, known limitations not explicit, license MIT, maintenance responsibility unclear.
Output usability has examples but unverified, marginal value high (cross-agent memory), cost-benefit not assessed.
Claim traceability partial (e.g., README feature descriptions), cross-source corroboration limited, fact-inference separation unclear.
- Static review, no code execution, all conclusions based on file analysis.
- Publisher identity unverified, maintenance responsibility and update path unclear.
- Dependency security not fully assessed, need to check for vulnerabilities.
- Evidence for user confirmation and least privilege insufficient, further review needed.
What does this agent do, and when should you use it?
Memmy is a personal AI agent and local memory hub that gives all AI agents a shared, fully controlled persistent memory and context. It supports Claude Code, Codex, OpenClaw, Hermes Agent, and others, enabling seamless cross-agent task continuity. The project ships as a desktop app, a CLI/TUI (`memmy`), and a separate `memmy-memory` CLI, with an OpenAI-compatible gateway that exposes port 18990. The local memory service binds to 127.0.0.1:18960 and can be run via systemd user services on Linux. It supports BYOK (bring-your-own-key) so you can plug in your own model APIs, and includes an interactive onboarding wizard (`memmy onboard`). The README emphasizes data privacy, an extensible architecture with MCP support, and a roadmap toward capturing memory from browsers and documents.
Memmy runs a local memory service that ingests collaboration history from AI tools, converts it into structured memory, and serves it back to any connected agent. The memmy CLI provides a TUI, memmy onboard for configuration, memmy agent --message "..." for one-shot tasks, and memmy serve to start an OpenAI-compatible API. The memmy-memory CLI allows adding, retrieving, and searching memories (add, get, search). It installs a Memory Skill and hooks/plugins for agent ecosystems like Claude Code and Codex via memmy-memory init. The Linux installer creates memmy-memory.service and memmy-gateway.service systemd user services that automatically restart on login. The desktop app offers a visual interface for scanning and reporting on memories. The gateway reloads environment variables and provider credentials on each start, and the configuration lives in ~/.memmy/config.yaml.
- A developer who switches between Claude Code and Codex on the same project wants to keep context like coding standards and progress without re-stating them.
- A technical writer uses Cursor and ChatGPT to draft documentation and wants both tools to remember their style guide and preferred tone.
- A privacy-conscious user prefers a local-only memory service that never sends conversation history to a cloud backend.
- A power user runs the CLI on a headless Linux machine to automate memory queries via
memmy-memory search. - A team experiments with Agent-to-Agent collaboration in a late 2025 roadmap feature to share knowledge under privacy controls.
- A developer building a custom AI tooling pipeline wants an OpenAI-compatible local API to inject memory into their own scripts.
What are this agent's strengths and limitations?
- Cross-agent continuity: unified memory for Claude Code, Codex, Cursor, and more; carry context, preferences, and progress across tools.
- Local-first privacy: memory service runs on localhost as a systemd user service; data remains on your machine and is not sent to a cloud backend.
- Model-agnostic: BYOK mode lets you plug in any OpenAI-compatible provider, avoiding lock-in.
- Multi-surface access: desktop app, CLI, TUI,
memmy-memorycommands, and an OpenAI-compatible API for scripted access. - Active development with a public roadmap toward broader memory sources (browser activity, documents) and team collaboration.
- Requires Node.js 22 and a systemd user session for the recommended Linux CLI; Windows support not officially covered.
- Early-stage project: maturity and battle-testing are limited, and compatibility with every agent must be verified individually.
- Free trial tokens are finite; ongoing use either requires a paid subscription or bringing your own API keys, which incur provider costs.
- Configuration complexity: editing YAML and managing API keys may deter non-technical users.
- Cross-agent memory retrieval may depend on agent-specific hooks that might change with agent updates.
How do you install or deploy this agent?
Option 1: Desktop App
Download the installer from the [official website](https://memmy.bot/) or [GitHub Releases](https://github.com/MemTensor/memmy-agent/releases).
Option 2: Linux CLI (Recommended)
Prerequisites: Linux x64/arm64, Node.js 22 or newer, systemd user session available.
Run:
curl -fsSL https://raw.githubusercontent.com/MemTensor/memmy-agent/main/scripts/install.sh | bash
export OPENAI_API_KEY="sk-..." # or use another provider
memmy onboard --defaults
memmyThe first memmy run initializes configuration and starts the memory service and gateway.
Option 3: Build from Source
git clone https://github.com/MemTensor/memmy-agent.git
cd memmy-agent
cp .env.example .env
npm install
npm run build
bash scripts/dev-start.shAll installation paths require at least one model API key (e.g., OpenAI). The desktop app offers free trial tokens on sign-up, after which you can switch to BYOK mode.
How do you use this agent?
After installation, the first memmy command opens a configuration wizard if no defaults are set. Inside the TUI, you can interact via natural language. To run a single-turn task, use memmy agent --message "Introduce the current workspace". To explicitly enable memory integration for detected agents, run memmy-memory init, optionally with --agent <agent>.
Common commands:
- memmy status —show config and model status.
- memmy-memory search "memory policies in this project" —search memories.
- memmy-memory add "a piece of knowledge worth saving" —add a memory.
- memmy serve —start OpenAI-compatible API on port 18990.
The systemd services run automatically after login; check with systemctl --user status memmy-memory.service memmy-gateway.service. Edit ~/.memmy/config.yaml to change the default model or provider credentials.
FAQ
Does Memmy cost money?
Which AI agents are supported?
memmy-memory init. It is advisable to test each agent individually.How is my memory data stored and protected?
memmy-memory.service), which starts on login and runs only under your user session. The README does not mention any cloud sync; local-first design is emphasized.What if I want to use a model not on the default list?
~/.memmy/config.yaml to set the provider's baseURL and apiKey. Use memmy onboard to guide you through the setup.