Memmy Agent - Let every AI remember the same you.

Thanks for checking us out 🙏

→ https://memmy.bot

For the PH Community, 2M ChatGPT Luna tokens free credit, come get it 😎

@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.

@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.

@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.

@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.

@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.

@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.

@jun_wong2 

Are different memory types stored with separate update rules?

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
  

Does the OpenAI-compatible API let you inspect which memories were used for each response?

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

@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?

@sandy_liusy Thanks so much, Sandy! You nailed the exact problem we’re solving — repeating the same preferences and project context across tools is such a drag. We built Memmy as that shared memory layer so every AI you use can remember the same you.
Appreciate the kind words, and congrats energy right back — would love to hear how it feels once you try it!

@sandy_liusy Yep, once you notice the context-reset problem, it’s hard to unsee... What tools are you switching between most?

@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.

@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.

@brattyaiguy  @danielwayne thanks bro 👊