MemophantMemophant
Native macOS App — Memory for any agent

Memory that loads itself into every session.

Memophant exposes every tier of your repo's memory — notes, wiki, design, and a code-symbol index — through a native MCP server (Model Context Protocol, the open standard AI editors use to call external tools). Claude Code, Cursor, Codex, and Gemini all read the same store. No copy-paste, no priming prompt, no editor lock-in.

Bundled MCP server

No separate daemon to babysit. Memophant ships a small MCP server in your repo; each agent launches it per session and reads your memory through it. It exposes a focused toolset — search_memories, search_code, read_memory, write_memory, edit_memory, recent_activity, build_context, and the consent-gated vendor-credential bridge.

Loaded at session start

Your agent reads the managed pointer in CLAUDE.md / AGENTS.md / GEMINI.md and pulls memory through MCP — every session begins caught-up.

Searched, not stuffed

Memories, wiki, design, and a code-symbol index (search_code) are all queryable over MCP and fetched on demand — so the context window isn't bloated with stale text, whatever agent you use.

Every agent in your toolkit

One memory store. Whatever editor you reach for.

MCP is the contract. Each agent gets its conventional pointer file and reads the rest from the bundled MCP server — so you can switch agents (or run several side by side) without re-explaining the repo.

Claude Code

CLAUDE.md + MCP

Reads memory through the MCP server at session start. Memophant maintains a thin managed block in CLAUDE.md as the agent's entry point.

Cursor

.cursor/rules + MCP

Cursor reads the same repo-resident notes through its MCP support and respects the .cursor/rules/memophant.mdc pointer. One source of truth, same workflow.

Codex

AGENTS.md + MCP

OpenAI's AGENTS.md convention is wired the same way as CLAUDE.md — pointer in, MCP for the rest. Codex sessions begin caught-up too.

Gemini

GEMINI.md + MCP

Same pattern: a GEMINI.md pointer plus MCP for the actual memory. The store is shared, only the entry file changes.

Speaks every agent's language — same memory, every session

Run with Claude — in-app, optional

When Memophant itself needs to think, it uses Claude.

These in-app AI actions — Distill, Consolidate, Migrate, and Generate — are separate from whatever agent you use in your editor. Your editor agent reads and writes memory through MCP; these actions are Memophant itself doing structured, multi-step work, and they use the Anthropic API because Claude is currently best at it. Bring your own key; it stays in the Keychain. Support for other providers and local models is on the roadmap.

  • Independent of your editor — Cursor in your IDE + Run with Claude in the app is fine
  • Bring your own Anthropic key — a pass is typically pennies on the default model, and you can cap the token budget
  • Per-item approve, edit, or reject — every proposal reviewable
  • Runs on a fast Claude model by default (Haiku) — plenty for structured proposal work; pick a heavier one in settings
Run with Claude consolidation proposing merges for approval.

Your Anthropic key never leaves the Keychain.

The Anthropic API key Memophant uses for its in-appAI features (Run with Claude, Consolidate, Distill) is stored only in the macOS Keychain — never in app settings, never on a server we operate, never in a log. Browsing, search, MCP, and commits all work without it; the key is only used when you trigger a Memophant AI action. Your code editor (Cursor, Claude Code, Codex, …) handles its own auth — Memophant doesn't touch it.

The patterns

One memory, three pointer conventions, every agent.

Each agent has its own entry-file convention. Memophant maintains all of them — the file changes, the memory underneath doesn't.

CLAUDE.md / AGENTS.md / GEMINI.md

A thin managed block that teaches the agent how to use the system — regenerated by the app, never a dumping ground. Memophant keeps it minimal so it doesn't bloat the context window.

.cursor/rules/memophant.mdc

Cursor reads the same convention. The rule file points at MCP; the memory still lives in your repo. Added for Cursor; the others ignore it.

Any MCP-aware client

The same MCP surface answers any client that speaks it. New agent ships next quarter? It picks up your memory without changing a file.

Give every session a head start.

Whichever agent you use, the next session shouldn't start from zero.