Memmy Agent - Let every AI remember the same you.
🍙 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.
Replies
What makes someone use Memmy instead of just relying on Claude or ChatGPT's built-in memory?
@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.
@reda_roqai_chaoui I’d add: if you bounce between a few AI tools, built-in memory usually can’t follow you. Memmy’s bet is one shared local memory across them 🙌
@reda_roqai_chaoui +1 to Pema & Grace. The other piece for me: Memmy turns scattered chats into reusable experience, not just saved notes.
What’s your usual stack — Claude + Cursor, or more than that?
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?
@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!
@luke_pioneero pls be welcome to upvote and try~
This could make switching AI tools much less painful. If users can take their accumulated context with them, choosing a new model no longer means losing the relationship they built with the previous one. That’s a meaningful shift.
@luke_pioneero yeeeeah! that is the part we care most about. Models and tools will keep changing, every month even week have different agents and models. but your context shouldn’t reset every time you switch!
@luke_pioneero Thanks Luke! That’s exactly it — switching tools shouldn’t mean starting the relationship from zero again 🙌
@luke_pioneero Love this framing. The goal is: try whatever’s new next month, without losing the “you” you’ve already taught your agents.
What’s the one tool switch you’d make tomorrow if your context came along for free?
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
@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.
@alex_watson2110 Spot on — stale-but-confident memory is way scarier than simple dupes. The hard part is making corrections reviewable, not silently stacking conflicts 👍
@graceren the trap with making them reviewable is review fatigue. if every superseded fact becomes an item, people rubber-stamp the queue and you are back to silent resolution with extra steps.
since Pema mentioned you already keep decision-repair records, you can bound it with that: only surface a correction when the old belief actually fed a decision. nothing downstream, supersede it quietly. something downstream, that is the one a human should see, and you can show them exactly what it changes rather than just flagging a conflict.
@graceren @alex_watson2110 That’s a much better threshold than “review every conflict.” The thing worth surfacing isn’t just that a fact changed — it’s that the old fact actually influenced something downstream.
We already keep the two pieces needed for that: decision-repair records, and provenance for which memories were injected into a turn. What we don’t have yet is the user-facing impact view you’re describing.
Quietly supersede unused beliefs; surface the ones with downstream consequences; show exactly what would change. That’s a much cleaner contract.
Would love you to try the current flow and keep poking at it — and an upvote would mean a lot if the direction resonates.
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.
@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.
@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.
@yunn_chen @carlvert Glad that helped — and thanks for the thoughtful questions! 🫶
@yunn_chen @zhiqi_xu Thanks for sharing the details. The retrieval transparency is a really thoughtful touch. Excited to follow Memmy’s progress! 🙌
@carlvert Quick add: it’s broad recall, then aggressive filtering — not dumping the whole memory pool into the prompt 👍
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?
@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?
@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 ability to recover context from existing agent history is a huge unlock. Starting with what users have already built up is the right approach.
@rydensun We didn’t want Memmy to start as another empty box. Pulling in the context people have already built up makes it useful from day one. Appreciate you calling that out. btw, which agent history would you bring over first?
@rydensun Thanks Ryden! Yeah — if people already have months of agent history, day one should feel like continuing, not starting over 🙌
Re-explaining the same context to every new AI tool is quietly one of the most annoying parts of this whole space, so shared memory across Claude Code and Cursor sounds like a small dream. Open source makes it easier to trust with this kind of data too. If I open my memory up, what does it actually look like, plain files I can edit or something more structured?
@doganakbulut Love this question. Under the hood it’s more structured than a folder of plain notes: memory lives in a local SQLite DB on your machine (~/.memmy), organized into layers (memories, experiences, world model, skills). You can browse/delete from the Memory panel, inspect or search via CLI, and export the DB anytime. Config is plain YAML — but the memories themselves are structured records, not just freeform markdown. Open source + local-first is exactly so you can trust and inspect what’s stored.
@doganakbulut
Totally get that — it’s genuinely annoying. Switching tools and having to re-explain your whole context every time is such a waste.
Memmy’s basically for that: Claude Code, Cursor, and other agents share the same local memory. It’s open source and local-first, so the data stays on your machine by default.
What you open isn’t a pile of loose plain-text files. It’s a memory panel in the desktop app — you can browse, search, open details, and delete anything that looks wrong. Under the hood it’s a structured local memory store, not a black-box cloud. You can also export the local data if you want your own copy.
So more precisely: there’s a GUI to manage it — inspect, delete, keep it local. It’s not the “open a folder and edit a bunch of markdown files” shape.
Memory staying local is pretty key. Great to see it!
@thisiskp_ That was non-negotiable for us. Once memory gets personal, keeping it local just feels right.
@thisiskp_ Local-first is non-negotiable for us 🔐 Thanks so much for saying that!
@thisiskp_ Appreciate that — local memory just feels like the only sane default once it gets personal 🔐
This is really cool! Now I just need to figure out who I am.
@jordangray One problem at a time 😄 Memmy can remember the clues while you figure it out.
@jordangray Haha thanks Jordan — Memmy’s got the memory part, the “who am I” part is still on you 😄
@jordangray 😂 Fair. We’ll handle the memory, and identity is on you. Thanks for stopping by!