The only AI memory
built for dev teams
AI agents today lose everything between sessions. MemNexus is a centralized memory system that works across Claude Code, Codex, Copilot, Cursor, and Windsurf — via MCP, CLI, API, or SDK. Knowledge from every agent and every session compounds over time instead of being lost.
No credit card required · Invite-only preview
Have an invite? Sign in →
{ "mcpServers": { "memnexus": { "command": "mx", "args": ["mcp", "serve"] } } }
Migrating auth from REST to gRPC — schema finalized in PR #47, client stubs left to generate
gRPC schema uses proto3 · buf lint enforced · no streaming RPCs yet
Team uses Zod validation + strict TypeScript, ESLint enforced
See the Difference
Same task. Completely different experience.
Back-and-forth to establish context every session
Instant context from your coding history
Without memory, your investment in agents doesn't accrue
“Knowledge doesn’t travel.”
Your agent in one project has no idea what your agent in another project learned yesterday. Same tool, different folder — completely isolated. Different tools? Even worse. The knowledge exists, but it’s trapped.
“Your agents produce code. The reasoning behind it disappears.”
Every interaction with an agent generates valuable knowledge — the decisions made, the approaches tried and rejected, the conventions established. The code ships. Everything else is lost.
“Your developers improve over time. Your agents don’t.”
A senior engineer retains what they learn — across projects, across years. They get better. Your agents start every project at the same level they started the last one. Without a memory system, your investment in agents doesn’t accrue.
“You’re building on a system that can’t learn.”
You’re scaling your development with dozens or hundreds of agents. But none of them can learn from what the others did, apply conventions from a different project, or avoid a mistake that was already solved elsewhere.
Built specifically for how dev teams work
Not simple key-value storage — a knowledge graph with automatic extraction, semantic retrieval, and team-scoped access controls
Searchable Decision History
Why you chose PostgreSQL over MongoDB. Which auth library you rejected and why. The debugging session that traced a race condition to your caching layer. Every technical decision is extracted, indexed, and retrievable by meaning — not just keywords.
Learns Your Team's Conventions
Your strict TypeScript config. Your Zod validation patterns. Your preference for async/await over .then() chains. MemNexus extracts these from your conversations and applies them automatically — so your agent stops suggesting approaches your team already rejected.
Git-Aware Memory (CommitContext)
Every git commit captures what changed — MemNexus captures why. The architectural reasoning, the tradeoffs considered, the bugs discovered. Six months from now, git blame tells you who changed a line. MemNexus tells you the full story.
Access memory however your workflow requires
Why Not Just Use Built-In Memory?
Claude Memory, Copilot memory, Codex memory — these are simple, single-tool, single-user stores. Development teams need centralized memory with a knowledge graph, enterprise-grade encryption, and team-scoped access controls. Learn the architectural difference.
Cross-Tool
Built-in memory
Locked to one tool. ChatGPT memory only works in ChatGPT. Cursor context only works in Cursor.
MemNexus
Works across Claude Code, Codex, Copilot, Cursor, and any tool that supports MCP or REST APIs. Switch tools without losing context.
Persistent
Built-in memory
Memory resets between sessions, disappears when you switch machines, and gets wiped by tool updates.
MemNexus
Survives session resets, tool switches, and machine changes. Your knowledge graph lives in the cloud, accessible from anywhere.
Learns Over Time
Built-in memory
A flat list of facts with no relationships. Can't connect that your Redis caching decision relates to your scaling strategy.
MemNexus
Builds a knowledge graph that links decisions, patterns, and context. Understands relationships between your memories, not just individual facts.
See how MemNexus compares
How It Works
From install to persistent memory in under 5 minutes
Install and Connect
npm install the CLI, run mx setup, and it auto-detects your tools — Claude Code, Codex, Copilot, Cursor. One command writes the MCP config. Your workflow doesn't change.
Code With Your Agent
Discuss architecture, debug a failing test, choose between libraries. MemNexus extracts the decisions and reasoning from your conversations — why you chose Zod over io-ts, what caused that flaky integration test, which caching strategy you ruled out.
Context Carries Forward
Next session, your agent already knows your stack, your conventions, and what you tried last week. It retrieves relevant context before you type your first message — across tools, projects, and team members.
Setup guides: Claude Code · Cursor · Full walkthrough →
Common questions
Everything you need to know before getting started.
Simple, transparent pricing
Full learning capabilities in Free tier
Pro
Unlimited for power users
- 500 memories/month
- Forever retention
- Advanced search
Your team's memory layer — set up in 5 minutes
Sign up, install the CLI, and run mx setup. Works with Claude Code, Codex, Copilot, and Cursor.
Already have an account? Sign in →