I build apps, voice agents and automations with Claude Code and Codex. Every day. For my own products and for clients.
Both can remember things about me. The trouble was that they remembered different things.
Tell Claude something useful, and I'd still have to tell Codex. Learn a lesson in one project, and I'd have to carry it into the next. I was the office messenger for my own engineers.
Two AIs, two versions of me
Instructions, project notes, things the agents had learned about how I work. Useful pieces, scattered across tools and projects.
Handoffs were on me too. One agent would finish an API, and I'd copy its notes into another chat so the next agent could use it.
I wanted one place to inspect what they knew, correct it and decide what was worth keeping. Somewhere that would still be useful if I switched tools.
So I built Mana.
One memory, everywhere
Mana keeps my working memory in plain notes on a server at home. Claude Code and Codex reach it through MCP, a standard way for AI tools to connect to other systems. Another tool can use the same memory if it supports MCP and I connect it.
I can open the notes, read them, fix them and take them anywhere. If I switch tools tomorrow, I keep everything.
Every connected agent is instructed to start the same way:
- Read a one-page brief on how to work with me.
- Ask Mana for what's relevant to this project and this conversation.
- Check this project's inbox.
Step 2 matters. Mana doesn't dump my whole life into every chat. The agent gets a short brief plus the few memories that fit what we're doing.
The notes live on my server. The relevant context still goes to whichever AI tool I'm using.
Remembering everything made it worse
My profile turned into a 479-line diary that contradicted itself. My patterns folder grew to 77 files of near-duplicates. More memory meant more old assumptions for an agent to trip over.
I also tried asking permission for every save. I started clicking yes without reading, which is the same as having no rule.
Now Mana has a few rules for what gets kept and what comes back.
Useful work facts can be saved without asking. How a server is set up. What a system needs. The lesson from a nasty bug. Non-sensitive facts that will save a future session from working something out again. The agent tells me what it kept.
Personal memories wait for my OK. My preferences, my decisions, my habits. The agent proposes, I approve, then it's written.
New facts are checked against old ones. A repeat confirms what Mana already knows. A correction can replace an older fact while keeping its history. Dates help distinguish what used to be true from what is true now. A newer message isn't, by itself, proof that an older one was wrong.
Memory needs maintenance. A nightly pass drafts possible memories from the conversations made available to it; those drafts wait for approval. A weekly pass checks recent facts, merges duplicates and flags stale facts or unclear conflicts. Old versions stay in the history. Keeping the brief useful still takes editing.
Sometimes the right answer is no memory. Mana searches by meaning and by keywords. If nothing matches strongly enough, it returns no additional memory. That doesn't make the agent infallible. It gives it fewer weak guesses to work from.
Every project has a mailbox
My favourite part.
When an agent finishes something another project needs, it can leave a message addressed to that project. The next agent checks the inbox when it starts. Tomorrow or next month. Claude or Codex.
One recent message in Mana's inbox was a report from a completed writing run. It listed the drafts it kept, the ones it rejected and why. The run had finished, but its reasoning was still there for the next session to read.
That's what I want from a handoff: what happened, what matters next, and enough evidence to check it.
A live conversation is a walkie-talkie. Mana gives each project a mailbox. The letter waits.
Mana also keeps a directory of my projects: where each one lives, what it's built with and what it's for. Say "fix the form on the website" and the agent can look it up instead of guessing which copy to open.
A text file gets you most of the way there. The useful part is making it a habit for every agent to consult it.
The brief every agent reads first
The least complicated part has made a big difference: one page about how to work with me.
- Anything that needs me goes first. If nothing does, say so in the first line.
- One question max. Only for a real decision.
- Talk product, not code. What changed for the user, why, and is it live or only on my machine.
- Pull me back from tangents. If I'm bikeshedding, say it. One sentence. I asked for this one. I need it.
Plus a glossary, because I dictate everything and the transcriber has opinions. "Comics" means Convex. "Mercel" means Vercel. "Brocum" means "bro, c'mon". No, it's not a product.
What this doesn't solve
The agent still has to ask for context and read what comes back. Mana can't see conversations I haven't connected or made available to it. It can miss a useful memory, and an old note can still be wrong.
I still need to decide what to build and check whether it works. The benefit is less time reconstructing what we already know.
Mana is also the app I open on my laptop and phone for my goals, groceries, notes and this blog. And it has a pixel owl that falls asleep when I leave it alone. Not essential. Very fun.
Start with the cheap parts
You don't need to build Mana to try this.
1. Write one brief for your tools. For a project, put the shared instructions in AGENTS.md, which Codex reads. Claude Code can read it too; a CLAUDE.md beside it containing @AGENTS.md is an explicit way to share the same file. Say what you're building, how you want answers and what needs your approval. Steal my rules above.
2. Add a glossary. If you dictate, list the words that get mangled. Otherwise, list your shorthand: project nicknames, client abbreviations.
3. Keep shared notes in one folder. Give each tool access, directly or through an MCP filesystem connector. Tell agents where the notes are and when to read them. A shared folder gives you a common record; selective search, approval controls and automatic cleanup are extra machinery.
4. Decide what may be saved without asking. Useful, non-sensitive work facts are a starting point. Personal details and sensitive information need a clearer boundary. Keep only what a future session will need.
5. Weed it. Read the notes occasionally. Correct what's wrong, combine repeats and retire stale facts. You can do this by hand before you automate any of it.
6. More than one project? Add a mailbox and a directory. One inbox note per project, plus a list of where each project lives. Tell agents to read their inbox when they start and leave a handoff when another project needs it.
Start with the brief and the glossary. See how far those take you before building anything bigger.
Claude drafted this post from a conversation we had. Codex edited it, and ChatGPT drew the pictures through Mana.