Launching today
Memmy Agent
Let every AI remember the same you.
453 followers
Let every AI remember the same you.
453 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.
Triforce Todos
Been waiting for something like this, honestly.
BTW, does it work well with Claude Code specifically, or is that still early days?
Memmy Agent
@abod_rehman
Yes—Claude Code is one of the key workflows Memmy is designed for. It helps preserve the project context, decisions, and task progress that can otherwise get lost when you start a new Claude Code session, switch projects, or move between tools.
The cross-agent long-term-memory experience is still evolving, but if Claude Code is already part of your daily workflow, Memmy is well worth trying—especially for long-running development work, frequent session switching, or workflows that also involve Codex or Cursor.
Memmy Agent
@abod_rehman Claude Code is a big one for us too, so I’d be really curious to hear how it works on your actual setup. Let us know where the handoff still feels rough.
Memmy Agent
@abod_rehman Thanks — glad it’s landing. Claude Code is a first-class integration (not early days): memmy auto-recalls + captures memory each turn during your chat within Claude.
Love the pitch! How do you handle conflict resolution when a user exhibits different personalities or prompt styles on different tools? (e.g., coding on Cursor vs. creative writing on Claude)?
Memmy Agent
@spark_zhang We don’t treat everything as one flat, global personality profile.
Memmy retrieves memories based on the current task and context, so coding preferences from Cursor and writing preferences from Claude can remain relevant in their own scenarios instead of constantly overriding each other.
For genuinely conflicting memories, we’re still improving the resolution and user-control layer, but the core principle is contextual relevance rather than blindly merging everything into one profile.
Memmy Agent
@spark_zhang Great question! Shared memory doesn’t mean one voice everywhere. Memmy keeps your durable facts shared, while tool-specific styles stay tied to their context — coding habits surface in Cursor, creative tone in Claude. The current task decides what gets recalled.
Are decisions, preferences, project state, and lessons stored as different memory types with separate update rules?
Does the OpenAI-compatible API provide a way to inspect the memories used for each response?
Memmy Agent
@jun_wong2
Yes. Memmy uses a four-layer memory architecture, and each layer has its own write path, evolution pipeline, and retrieval rules:
L1 Trace — Raw conversation turns (requests, replies, tool calls). Captured automatically at turn end, then summarized and embedded asynchronously.
L2 Policy — Experiences distilled from L1 (success patterns, preferences, failure avoidance). Generated automatically by background induction jobs.
L3 World Model — Declarative knowledge about projects, environments, and constraints. Abstracted from L2 via clustering.
Skill — Reusable standard operating procedures. Crystallized from qualified L2 policies.
Mapping to the concepts you mentioned:
Decisions → L1 + decision repair records + L2 decision guidance
Preferences → L2 subtype `preference`
Project state → L3 world models
Lessons → L2 policies, which can further crystallize into Skills
The OpenAI-compatible API response body does not currently return memory IDs or citation details directly.
You can check this in Memmy under Memory Management → Logs by filtering for `memory_search`. There you’ll see the candidate memories for that request, which ones were kept and injected into context, and which ones were filtered out.
Our full stack is open source — feel free to take a look if you’re interested. Thanks for the support!
https://github.com/MemTensor/memmy-agent?ref=producthunt
Memmy Agent
@jun_wong2 The logs are especially useful when you’re tuning retrieval — you can see what was considered, kept, and filtered out instead of guessing what happened behind the scenes.
We’ve also been thinking about exposing more of that trace directly through the API. Curious what would be most useful for you there: memory IDs, relevance scores, or full provenance?
Does commercial use of the GitHub version have any licensing restrictions that companies should know about?
Memmy Agent
@sky_heartfly Memmy is MIT-licensed, so yes, commercial use is allowed. You’re free to use, modify, and distribute it, as long as you keep the original copyright and license notice. No extra commercial restrictions from us.
Memmy Agent
@sky_heartflyMemmy is MIT-licensed, so yes, commercial use is allowed. You’re free to use, modify, and distribute it, as long as you keep the original copyright and license notice. No extra commercial restrictions from us. As usual with open source, third-party dependencies keep their own licenses — worth a quick check if your company has a compliance process. Happy to clarify further!
Memmy Agent
Hey Product Hunters 👋
I'm Zhiqi, one of the makers behind Memmy.
If you bounce between Cursor, Claude Code, Codex, and other AI tools like me, you know the pain: every new chat starts from zero. Prefs, decisions, project context — you HAVE TO re-explain to them again and again.
Finally we get rid of it, and we're excited to introduce Memmy 🍙
Memmy is a local-first memory layer those tools can share. Auth once, and it turns messy chat history into structured memory — prefs, decisions, project context. Switch tools, and Memmy carries what matters with you. No re-explaining anymore. You can search it, control who uses it, or delete anytime. And it stays on your device, never uploaded to a remote server.
Also an agent itself: you can hand it tasks, not just manage memories.
We're open source, free to start, and would love to hear your thought — "What tool should we support next, and what should memory never forget?"
We gonna be here all day to answer questions and would genuinely appreciate your feedback 🫶🏻
Memmy Agent
Thanks for checking us out 🙏
→ https://memmy.bot
For the PH Community, 2M ChatGPT Luna tokens free credit, come get it 😎
@zhiqi_xu GitHub next! Would be great if Memmy could remember what we’ve already tried, so every new agent doesn’t send us down the same dead ends again
Memmy Agent
@zhiqi_xu @luke_pioneero Yes, exactly 😄 The real win is when the next agent says, “We already tried that — don’t go there again.” GitHub sounds like the perfect next test. Keep us posted!
Memmy Agent
@luke_pioneero Love this — and you’re pointing at the core job. Memmy can already connect to GitHub as a tool, but the bigger win is shared failure memory: when an approach dead-ends, we capture that trail and distill avoidance guidance, so the next agent (Cursor, Claude Code, etc.) can skip the same rabbit hole. Exactly the loop we want to keep strengthening. Thanks for the push!
@zhiqi_xu Notion would be a great next integration. A lot of project context and decisions already live there, so connecting that knowledge with AI conversations could be really powerful. Memmy should never forget confirmed decisions, but it should also know when they’ve been replaced by newer ones.
Memmy Agent
@jody_l_wyatt Great suggestion! Memmy can already connect to Notion as an Agent tool, so it can pull project context into conversations today.
On the memory side, we distill experience into four layers and keep evolving them over time: newer, higher-value memories rise, outdated ones decay or get archived. Confirmed decisions stick, but fresher ones can take priority when the context changes.
Turning Notion into a deeper living knowledge source for that loop is a natural next step — appreciate the push!
oh this is a very clever one. AI not remembering anything about me when i switch (even between claude web and claude code, for example,.. same company...) is one of the most frustrating things I've dealt with.
Do you also have any ideas on how to make memory "better", i.e. have it be more comprehensive?
Memmy Agent
@quantumwhisker Totally agree. We don’t think “better memory” simply means storing more conversations.
For us, it comes down to three things: covering more of the tools you already use, turning raw conversations into structured and deduplicated memories, and retrieving the right memory for the current task. New decisions and lessons can also be written back, so the memory keeps improving as you work.
The goal is a useful, evolving memory—not an infinitely growing chat archive.
@yunn_chen very interesting. I'll be sure to follow your product's development!
Memmy Agent
@quantumwhisker reaaaally thks a lot 🙏
Memmy Agent
@yunn_chen @quantumwhisker Thanks so much — really appreciate you following along.
Congrats on the launch. Local-first is why I clicked, most memory layers ship as someone else's cloud. One thing I could not work out from the description: when Cursor and Claude Code both hit the OpenAI-compatible API, does a memory carry any scope with it, per project or per tool, or does every connected agent read from the same pool? I have work repos and personal side projects on the same machine and I would want the second not to bleed into the first.
Memmy Agent
@vollos Thanks for raising this — today, all connected agents read from the same local memory pool. That shared pool is intentional: it’s what allows Cursor, Claude Code, and other agents to build on the same long-term context.
At the moment, memories are not hard-isolated by tool or project. Retrieval is based on the current task and context, but a work repo and a personal side project still belong to the same pool, so we can’t promise zero crossover today.
If strict separation is required, the safest current setup is to use separate Memmy instances or data stores. Your example is a very useful one, and project-level boundaries are clearly an important requirement for this kind of workflow.
@yunn_chen Appreciate you saying that plainly instead of pointing me at a settings page, that is rarer than it should be. Separate instances sounds like the practical answer for now. Out of curiosity, do memories get tagged with where they came from at capture time? A pool that was never tagged seems hard to split later, so I wondered if that groundwork is already in there.
Memmy Agent
@vollos yeah，we do retain provenance at capture time. Memories can carry the originating agent/app, session and conversation, plus project and profile identifiers where available. So the shared pool isn’t an untagged blob.
that metadata is mainly used for tracing, inspection, and contextual retrieval; it isn’t yet enforced as a hard access boundary between projects. So separate instances are still the safest option for strict isolation, but the groundwork for future project- or tool-level scoping is already there.
@yunn_chen Clear, thanks. The split between what that metadata does today and what it could enforce later is the part I was guessing at.