Over the past few months, Agents have quietly crossed a threshold β from conversation tools into actual work partners: reading codebases, calling tools, running tasks end-to-end, and plugging into increasingly complex workflows through Skills, MCP, and sub-agents.
But most Agents today still don't know you. Not really. They have no access to the knowledge and preferences you've built up over months β no continuity with your past projects. Switch agents, and you're rebuilding from scratch: task context, key decisions, working habits β all of it, gone.
And as the number of agents you use keeps growing, your project context, personal preferences, hard-won decisions, and accumulated experience get scattered across more and more tools and sessions β with no single thread connecting any of it.
Today, we're officially launching Memmy.
Memmy is your personal memory hub β and a local-first Agent that continuously learns to understand you. It distills your knowledge, preferences, and project experience into long-term memory, so Cursor, Claude Code, Codex, OpenCode, OpenClaw, WorkBuddy, and every other Agent you use can collaborate from the same shared context. It also ships with a desktop app, CLI, API, Skills, and MCP support β ready to plug directly into your daily workflow and get things done.
Accumulate once. Use everywhere.
Let every AI remember the same you.
(Create your Memmy account now. 2M tokens for free trial, zero setup, no API key needed.)
I. Not just a memory layer. Not just another Agent.
Memmy integrates 3 capabilities into a single local runtime:
Personal Memory Hub Knowledge, preferences, project context, and hard-won experience β scattered across agents and past sessions β consolidated into long-term memory that's retrievable, updatable, and reusable.
Local Agent Runtime Model inference, task orchestration, tool calling, Skills, and MCP support β built in. Analyze files, structure plans, query information, and execute multi-step tasks, directly.
External Agent Connectivity Memmy is natively compatible with any Agent. Cursor, Codex, Claude Code, OpenCode, OpenClaw, WorkBuddy β and anything beyond β can read from existing memory. Any Agent that can call the right interface can pull the context it needs for the current task, and write new decisions and experience back when the task is done.
II. How Personal Memory Keeps Growing
Memmy gives memory a complete lifecycle: recover what's been built up, make sense of it, surface what's needed, and keep updating as new work happens.
2.1 Scan: Recover the context you've already accumulated
With your authorization, Memmy reads existing Agent history directly from your machine. No manual copying, no re-organizing past conversations β your accumulated project context is already there. Choose which sources to import, and pause, resume, or stop at any time.
2.2 Organize: Distill what actually matters from your chat history
After installation, Memmy generates a personalized "First Impressions Report" from your imported content β a fast read on the project experience and personal preferences that have already formed.
And Memmy doesn't just dump your chat history into an ever-growing flat file.
Powered by MemOS, it understands, deduplicates, classifies, and structures your history β transforming key decisions, personal preferences, project progress, and hard-won lessons into long-term memory that can be retrieved, updated, and reused.
What gets retained: the decisions you made, the preferences you formed, where each task stands, and which lessons should carry into the next session.
2.3 Retrieve: Surface exactly what the current task needs
Flooding a model with your entire history doesn't just eat context β it lets irrelevant information pollute the signal.
Memmy matches the current task against long-term memory and surfaces only the relevant project context, key decisions, and prior experience β delivering just what the active Agent needs, nothing more.
For example, say you've already established in Cursor:
- Backend: Fastify
- Storage: local SQLite
- No cloud database in this phase
A few days later, you switch to Claude Code to build a data export feature.
Claude Code doesn't need to re-read every past conversation. Memmy surfaces the relevant architecture and storage decisions β letting it continue along the existing plan, without re-confirming choices that were already made or accidentally reversing them.
2.4 Write-back: Let new experience flow back into personal memory
Importing history is just the starting point.
If new decisions and lessons from external Agents stay siloed in their own sessions, personal memory fragments all over again β fast.
That's why Memmy supports installing a memory Skill for external Agents. Via the memmy-memory CLI and memory Skill, external Agents can both retrieve existing memory and write new experience back to Memmy as work happens.
# Initialize the memory service and install the memory Skill for an external Agent
memmy-memory init --agent
# Retrieve existing memory
memmy-memory search "database decisions in this project"
# Write a new lesson
memmy-memory add "batch exports need concurrency limits to avoid memory exhaustion"
III. One Agent Runtime. Every Way You Work.
Memmy is a local Agent Runtime β and every surface shares the same Agent, memory, model config, and tool capabilities. Desktop app, floating desktop launcher, CLI/TUI, and OpenAI-compatible API. Start a task from one entry point. Pick it up from another.
3.1 Desktop Launcher: From understanding to execution, end-to-end
The desktop app is Memmy's most complete interface β task management, message threads, file attachments, voice input, slash commands, memory management, and tool connections, all in one place.
Use it to:
- Analyze codebases or business plans
- Organize documents and extract what actually matters
- Chain multiple tool calls across consecutive steps
- Resume long-running tasks mid-flight
- Manage memory sources, model config, and tool connections
For anyone pushing complex tasks forward continuously β the desktop workbench is a personal AI command center that manages tasks, memory, and tools simultaneously.
3.2 Memmy Pet on Desktop: Delegate on the fly, without breaking flow
Writing code, reading docs, or mid-meeting β you shouldn't have to open a full window.
Memmy lives on your desktop as a lightweight persistent launcher. Click it to expand an input field and fire off a task via text or voice. Double-click to open the full launcher.
3.3 TUI, CLI & API: The same Agent Runtime, straight from the terminal
For the devs who live in the terminal, Memmy offers three interfaces: TUI, CLI, and an OpenAI-compatible API.
Type memmy directly in your terminal to launch the TUI.
Or drive the Memmy Agent Runtime straight from the CLI:
memmy onboard
memmy status
memmy agent --message "Oi, give me an overview of the current workspace"
Spin up the local OpenAI-compatible API:
memmy serve
Via Skills, MCP, and custom tools, Memmy also extends into file processing, shell execution, web access, image generation, and task automation β with native connections to GitHub, Gmail, Notion, Slack, Jira, and more.
IV. Memory Stays Local. Access Is Yours to Control.
The more personal preferences, project context, and working experience accumulates, the more valuable long-term memory becomes. That's why Memmy is local-first by design: memory lives on your machine by default, and you decide how it's managed and who can access it.
Out of the box:
- Memory is stored in local SQLite
- Config file lives at
~/.memmy/config.yaml - Workspace lives at
~/.memmy/workspace - Local API and Memory Service support token-based auth
- API keys can be referenced via environment variables β no hardcoding in config files
You choose which Agents can access your memory. You can view, update, or delete anything at any time. Connecting more tools doesn't automatically open your memory to all of them.
On the model side, Memmy offers two modes:
Account Mode
Use the platform's free credit allocation out of the box β no API key required. Full Memory and Agent Runtime, zero config.
BYOK Mode
Bring your own model service. Choose your model, manage your own credits and API keys. Note: how your data is handled during model inference depends on the privacy policy of the model provider you connect.
Config example:
agents:
defaults:
model: openai/gpt-4.1
provider: openai
timezone: Asia/Shanghai
providers:
openai:
apiKey: ${OPENAI_API_KEY}
V. Benchmarked: Agents That Execute More Accurately
Under internal evaluation and corresponding test configurations, Memmy demonstrates consistent long-term memory capability β and leads across Agent reasoning, code execution, and cost efficiency.
LoCoMo: #1 in Single-hop and Temporal Memory
On the LoCoMo long-term conversational memory benchmark, Memmy scores 78.34 overall β taking the top position in both Single-hop and Temporal task categories.
Memmy doesn't just store more. It retrieves the right memory from a large history with precision, and correctly reasons about the temporal relationships between events.
EvoAgentBench: #1 Accuracy Across All 5 Task Categories
Across all 5 Agent task categories in EvoAgentBench, Memmy ranks first in accuracy β and achieves the lowest cost in Reasoning, Code, and InfoRetr.
Memory isn't just about looking back. It directly lifts task execution quality. From long-term memory to real-world execution, Memmy helps Agents do more than remember β it helps them perform more accurately and efficiently, grounded in prior experience.
Download Memmy and get started today.
Available via the Memmy website or GitHub.
Sign up and get 2,000,000 free tokens trial β no API key required. Full Memory and Agent Runtime, ready out of the box. Usage and remaining credits are visible directly inside the app.
Once your credits run out, switch to BYOK mode at any time and keep going with your own model API.
Official Website: https://memmy.bot
Top comments (0)