Launching today
Memmy Agent
Let every AI remember the same you.
481 followers
Let every AI remember the same you.
481 followers
🍙 Memmy Agent is a personal memory hub and local AI agent for all AI Agent and tools like Claude Code, Codex, OpenClaw and Hermes. Gives every AI one shared, full-controlled memory — they all remember the same you. Memmy turns chats, decisions, prefs, progresses, and experiences into long-term memory, brings the right context into matching task, also can take on work directly. Local-first by default. Your memory stay under your control: manage them anytime. Free start with 2M ChatGPT tokens.
Shared memory across agents sounds powerful, especially with per-tool control. Can I create separate memory spaces for work, personal projects, and clients—and decide exactly which agent can access each one?
Memmy Agent
@blink_66 Not yet. Right now, all connected agents share one memory pool.
Separate memory spaces and per-agent access control are on our roadmap though — especially for people juggling work, personal, etc.
For now, separate Memmy instances are the cleanest workaround.
@yunn_chen Got it, thanks for clarifying!
@yunn_chen Separate Memmy instances sound like a practical workaround for now. I’m glad granular memory spaces and per-agent access controls are on the roadmap—those would make managing client and personal data much safer and more flexible. Looking forward to it!
For me, the interesting challenge isn’t whether an AI can remember more, but whether it can remember the right things. How does Memmy distinguish a durable preference from a one-time instruction?
Memmy Agent
@orman_canida That’s the hard part. Memmy doesn’t treat every instruction as a permanent preference.
A one-off “use X for this task” stays with that task. Clear signals like “I prefer X,” “next time do Y,” or “use X instead of Y” can become preference memory, and repeated patterns across different tasks add stronger evidence over time.
So it’s a mix of what you explicitly say and what keeps showing up—not just remembering every command forever.
@yunn_chen That makes sense. The repeated-pattern signal is especially interesting. How does Memmy handle it when preferences change over time—can users see and correct what it has inferred?
Memmy Agent
@orman_canida Hi, Canida. Preferences aren’t locked forever. As your behavior changes, newer patterns gain weight and older ones decay or get archived. You can also open the Memory panel to review what Memmy has inferred and delete anything that no longer fits. You’re always in control.
the write-back is the interesting half. dedup handles the same fact twice, but the thing that actually bites is a memory that still sounds confidently true and just is not true anymore, and nothing in the chat history tells you which one that is
Memmy Agent
@alex_watson2110 yeah, stale-but-confident memory is the much harder problem.
When Memmy catches an explicit correction, it can create a decision-repair record and update the guidance built from that memory, rather than just storing two conflicting versions side by side. We still keep the original trace for provenance.
The part we’re improving now is making those conflicts easier to spot and review, instead of resolving everything silently in the background.
What makes someone use Memmy instead of just relying on Claude or ChatGPT's built-in memory?
Memmy Agent
@reda_roqai_chaoui Fair question. If you mostly use one assistant, its built-in memory is probably enough.
The problem starts when your work is split across Claude Code, Cursor, Codex, and a few other tools. They all know different pieces of the story. Memmy gives them one shared memory, stored locally, so you’re not rebuilding context every time you switch.
That’s really the main difference: built-in memory stays inside one product, while Memmy follows you across agents.
Interesting idea, you have my upvote. What are the current limitations?
Memmy Agent
@martin_yochev1 Thanks for the upvote! A few honest limitations right now:
Desktop is macOS / Windows — Linux desktop isn’t there yet (CLI/from source can still work on Node).
Local-first — memory lives on your machine by default; multi-device sync isn’t a built-in cloud product yet.
Free trial tokens are limited — great for getting started; heavier daily use usually means switching to BYOK.
If you hit a specific workflow limit, tell us — that’s the best way we prioritize.
Really interesting direction. How does Memmy handle outdated or conflicting memories—for example, when a project decision changes later? Does the newer context automatically override the old one, or can users review the conflict?
Memmy Agent
@luke_pioneero It doesn’t simply overwrite the old memory. When a decision changes, Memmy keeps the original context as an L1 trace and can create a decision-repair record that feeds into updated L2 guidance. So the history is preserved, while later retrieval can work from the revised decision instead of treating both versions as equally valid.
You can also inspect and delete memories yourself. What we don’t have yet is a polished side-by-side conflict review flow — that part is still being improved.
@yunn_chen Got it, that makes sense. Keeping the history without treating both versions as equally valid sounds like a solid approach. Thanks for clarifying!
KnowU
Does Memmy retrieve only the most relevant memories for each task, or inject a larger context block? I’d be interested to see how you balance recall quality, latency, and token usage.
Memmy Agent
@carlvert Memmy doesn’t dump the whole memory store into the prompt.
It searches across vector, full-text, pattern, and structural signals in parallel, merges the candidates, then applies relevance thresholds, dedup, and MMR to avoid near-duplicates. A final LLM filter trims the set again — up to 8 memories by default.
Each injected snippet is capped too, and Skills go in as short summaries unless full mode is needed. So the idea is broad recall first, then keep the actual context block small. You can also inspect what was considered, kept, and injected in the retrieval logs.
KnowU
@yunn_chen Thanks, Pema! this is exactly the level of detail I was curious about. Broad recall followed by aggressive filtering, dedup, and MMR sounds like a thoughtful way to keep the injected context focused. The retrieval logs are a great touch too. Do they also break down latency and token usage by retrieval stage? That would make tuning the quality–cost tradeoff especially useful.
Memmy Agent
@yunn_chen @carlvert Glad that helped — and thanks for the thoughtful questions! 🫶