I Hooked My Agent Into an Open-Source “AI Memory Butler” — It Feels Like Giving AI Access to My Sixth Sense

Here’s the thing — a few days ago, after my computer restarted, I thought I’d lost all my projects.

I opened Warp, and the terminal was completely clean. I thought to myself, every time I restart on the CLI, I can’t see my progress anywhere — it’s like my projects just vanished.

So I pulled up Memmy, which I’d recently spotted on the Product Hunt leaderboard, and asked it to help me find the status of my projects.

You have 210 project directories, all still in /Users/andyhu/ — nothing was lost. Key projects include 3d-billiards, GemmaClient, Ice; game projects include ai-monopoly-game, cashflow-game; AI/ML projects include ChatTTS, novel-agent-system…… — Memmy’s answer

All the projects were still there. I just couldn’t find them at first.

But this got me thinking about another problem.

Out of those 210 projects, which AI tool actually “knows” them?

Memmy could scan them because it read the directories from the terminal.

But switch to Claude Code, Codex, or Cursor — do they know which projects exist? Which Skills are available to call? Do the pitfalls I’ve hit before still count?

Every time you switch tools, those 210 projects look brand new to the new tool.

So I ran a test: I asked Memmy to find a project without giving it any clues.

Find a local global intelligence and design monitoring project — what is it?

No project name, no path, no directory structure, no keywords.

A normal AI would probably ask back: Which project do you mean? Do you have any keywords? Which directory is it likely in?

Memmy gave me the answer directly.

It said it was OSIRIS / GEOSIGHT, also called “地瞰” (Earth View), located at /Users/andyhu/Downloads/Company/ locally. It then distinguished the purpose of the two subdirectories: osiris-upstream is a full GitHub clone, and osiris-replica is a single-file local reproduction.

It even ruled out open-design in the same directory, noting that one is an AI design tool, not an intelligence monitoring project.

I opened it manually, and the GEOSIGHT interface was right there.

Throughout this entire exchange, I never explained any background context.

That’s Memmy — an open-source AI memory tool that hit #3 on Product Hunt’s daily leaderboard with 436 points.

The tagline on their site is pretty blunt: Let every AI remember the same you. Sign-up gives you 2 million tokens free — enough to get Memory + Agent Runtime working before worrying about anything else.

When I first read that line, I thought it meant remembering your preferences — like preferring Chinese answers, preferring a concise format. Most AI tools are doing that kind of thing.

After running it for a while, I don’t think that’s what it means.

The “remember” it’s talking about isn’t about remembering what you like — it’s about remembering your workspace.

It’s like a general manager for AI memory modules — letting multiple agents and modules handle things with full context. It genuinely feels refreshing.

This is an underrated difference.

Most people understand AI memory like this: AI remembers you said “I do software development”, so it asks fewer dumb questions next time. Useful, sure. But that’s not what actually annoys people.

The real annoyance is having to re-introduce yourself every time you switch AI tools.

Project context you’ve explained in Claude Code, you have to explain again in Codex.

Pitfalls you’ve hit in Cursor, another agent acts like they never happened. The Skills, toolchains, file paths, naming conventions you spent time building — they all end up locked inside each tool, with no connection between them.

AI tools don’t force you to repeat yourself because they’re dumb. It’s because every tool is an island.

What Memmy wants to be is the bridge.

Open the Workbench, Get the Flow Running First

After registering and opening the desktop app, there are a few entries on the left: New Task, Search Tasks, Connections & Tools, Memory Management, Join Community.

Two details told me the design direction was right.

First, it doesn’t push you to configure a model, API key, embeddings, or a local service upfront. It just lets you use the 2 million free tokens to get the flow working, and worry about the rest later.

Second, the first screen puts “Connections & Tools” and “Memory Management” right out front — not a chat box. That shows it’s not trying to be another chat interface; it’s a workbench.

For me, after configuring my own API key, I could directly and visually manage token consumption and evaluate cost spend.

I do like this design — having all the consumption details viewable in one place is pretty nice.

A Question With No Clues Found a Real Project

This is the hands-on test from the beginning.

It found it — right path, correct version distinction, correct exclusions.

It made several layers of judgment: mapped the vague description “global intelligence and design monitoring project” to OSIRIS / GEOSIGHT, located the local path, distinguished the different purposes of the upstream and replica subdirectories, and ruled out open-design, which sounds related by name but serves a different purpose.

That’s not like ordinary chat memory.

Ordinary memory remembers “you mentioned the word OSIRIS.” This is more like knowing what that word points to in your workspace — knowing which directory is the full clone, which is the single-file reproduction, and knowing that open-design sitting next to it isn’t the answer to this question.

It’s like telling a new coworker “find that client proposal from last time.” A new hire would ask: which client? where’s the file? which version is final? A veteran wouldn’t ask — because they already know.

I kept pushing, asking it to launch osiris-replica.

It returned http://localhost:8780/index.html. I opened it manually, and the GEOSIGHT interface was running.

Vague description → recall project → find path → distinguish versions → launch replica → get local address → see real interface

That’s what “actually being useful to you” looks like.

Skills Discovery: Not Just Remembering What You Said, But Knowing What You Can Do

After the project lookup, I wanted to test something else: does it know how I work?

In this screenshot, it surfaced a batch of Skills from my computer: SEO, growth, data analysis, Feishu integration, Cloudflare, audio/voice, TDD workflow……

These aren’t preferences — they’re working methods.

Knowing “you prefer Chinese” is a preference.

Knowing “you have a Skill called berryxia-writer, used to transform source material into Hook-driven Chinese science articles, typically delivered as Markdown + HTML” — that’s capability. Preferences affect how you talk; capabilities determine what you can do next.

There’s a real comparison here. Earlier, I asked Codex to write an article using berryxia-writer. It couldn’t find it directly — it had to write a draft from a normal brief first, and only re-read the Skill after I gave it the path.

In Memmy, I just asked “Can I use the berryxia-writer skill to write content?” and it recognized the Skill was installed, explaining its functionality, supported content types, and output format.

The logic underneath is simple: the working capabilities you’ve already refined shouldn’t be locked inside one Agent, disappearing when you switch tools.

Hooking My Own Business Agent In Too

If the previous two examples were just “it remembers my stuff,” this next one goes further.

I have a local business Agent. Friends who know me well know my core work is in Apple business — this tool is called SalesScout, built for Apple dealer sales scenarios. It understands workflows like opportunity inspection, client visits, proposal writing, and client follow-up.

Hooking it into Memmy is more convincing than hooking into Cursor or Claude Code, because behind it is a real business context, not a chat tool.

The interface shows schools, products, match scores, budgets, deadlines, sources, and follow-up actions. For example, a procurement bid from Jinan University for Apple MacBook Air 15-inch M5 scored 85 points, with buyer, region, entry time, and next actions displayed beside it. This is real data, not a demo shell.

Every time an Agent inside SalesScout searches, reads pages, or compiles results, it leaves execution records.

These records are critical for Memmy, because they’re not ordinary chat logs — they’re process assets showing “how a business Agent completes a type of task.”

I asked:

Find education procurement opportunities with a match score above 60 in the last 7 days.

It started working — read salesscout-mcp-verification.jsonl, grepped for mcp_salesscout_, called Find files, listed .memmy.

It didn’t stop at “remembers you mentioned SalesScout.” Instead it thought: this task needs to look up opportunities — where do I find tools with that capability, where are the MCP integration records?

It hit a small snag along the way: an initial find /Users/andyhu … with too broad a scope timed out after 10 seconds.

It didn’t get stuck — it switched approaches, using ls and mdfind to locate /Users/andyhu/Desktop/SalesScout/server/ directly, then read mcp_server.py.

It found search_leads, and read that the tool supports the min_score and days parameters — exactly matching the requirements: last 7 days, match score above 60.

Result: 50 opportunities, organized by score distribution, with top 5 presented in a table.

The OSIRIS test proved it can find projects. The SalesScout test proved it can find tools around a project, read configurations, understand parameters, and actually run the tools.

Ordinary memory is like a sticky note, reminding you that SalesScout was mentioned. Memmy is more like a business filing cabinet — it knows SalesScout represents a real sales capability, and knows which entry point to call next time an opportunity-finding task comes up.

The Underlying Idea: Memory, Skills, and Tools, Separated Into Layers

The model configuration page separates a few things out.

It doesn’t treat memory as a black box.

Memory is the foundation, tools are the hands and feet, Skills are the methodology, the model is the engine, and MCP is the socket for connecting external capabilities. The SalesScout test strung all of this into one complete pipeline.

Cross-Agent Access: This Is Where the Real Imagination Lies

If a memory can only be used inside Memmy itself, it’s just a chat tool with a different shell.

What’s genuinely valuable is this: different Agents can plug into the same context. I love that about it!

Cursor can know project context when writing code. Claude Code can know how a bug was fixed last time when debugging. Codex can know local paths and constraints when running tasks. SalesScout can know which opportunities have already been followed up.

Before, every Agent was like a temp worker doing their own thing — you had to explain the company business to each one. Now it’s more like having a shared project archive: new Agents review the archive first, then start working.

If this pans out, what users save isn’t the time of one particular prompt — it’s the long-term time spent repeatedly explaining themselves.

I Hope the Next Step Is More Proactive

The best feeling right now is that someone is finally helping me manage these fragments.

But I want it to go a step further: not just answering when I ask, but when I open it, being able to see the working assets I’ve cultivated together with AI.

A bit like a pet-raising game, but not for cuteness. The more it’s used, the more it understands your projects and knows what tools you have — gradually shifting from “I’m using an AI tool” to “I’m collaborating with an AI work system.”

Back to the question at the start.

Memmy’s answer was right: all 210 projects are still there — nothing was lost.

But what it didn’t say is that those 210 projects will still look unfamiliar to the next AI tool. The files are there, the paths are there — but no tool remembers what you did here, what pitfalls you hit, what methods you used, which path you took.

Projects won’t be lost. What disappears is AI’s understanding of your workspace.

Every time you switch tools, that understanding resets to zero.

That’s what Memmy is trying to solve.

• Website: https://memmy.bot/

• GitHub: https://github.com/MemTensor/memmy-agent

• Product Hunt: https://www.producthunt.com/products/memmy