Project memory for AI coding teamsOpen-source CLI live · Hosted early access

Project memoryfor your team’sAI coding agents

mex makes AI multiplayer. What one engineer's agent learns, every agent on the team can use. The memory lives in your repo, right next to the code.

25,000+developers trust mex globally

Open-source CLI: npx mex-agent@0.8.3 setup Try it on GitHub · Join the Discord

Install the CLI · What project memory is · OSS vs hosted · Hosted mex · CLAUDE.md vs memory

The problem

On a team, AI memory quietly falls out of sync.

On a team, each engineer's agent learns the codebase alone. Memory fragments across machines, drifts from the real code, and nobody can see what the agents think is true.

01 / Fragments

Every agent knows something different

Each developer's agent learns the codebase on its own, so no two share the same memory. Two agents solve the same problem different ways, and the conflict only surfaces in review, after it's already in the PR.

02 / Goes stale

Memory drifts from the code

The codebase changes every day; the per-developer memory does not. Agents keep enforcing rules that no longer match what's shipped, and nothing flags the gap.

03 / Ungoverned

No one can see what agents know

There's no shared source of truth and no way for a lead to review, correct, or govern the memory every agent is working from. The team's standards end up living in tools leadership can't see into.

The Solution

Git-native today. Hosted when you want it governed.

Open source, today

Canonical memory lives in the repository as readable Markdown and travels with Git. Each teammate keeps local indexes and a local Hub on their machine. Agents read and help maintain that memory through project instructions and the CLI. Works with Claude Code, Codex, Cursor, and other tools the team already uses.

Hosted early access

For teams that want one shared deployment and an admin surface to govern what gets promoted, request early access. That product is not a rename of the CLI.

mex team memory modelHosted early access (waitlist): an admin dashboard governs one shared deployment. Four developers each push to and pull from that collective context, which works with every AI coding agent. This diagram is not the open-source CLI.

Admin dashboard

governs sync, drift, access, and policy

Collective context

Hosted early access

backend services
frontend app
platform & infra
mobile client
PushPull
PushPull
PushPull
PushPull
Works with every agent your team uses
Cursor
Claude Code
Codex
OpenCode
+ any agentic tool

Hosted early access (waitlist)

The dashboard

Hosted early access: govern shared memory from one place.

See drift, review what gets promoted into shared memory, and keep team context honest. This surface is the waitlist product.

  • Aggregate drift scores across every developer and repo
  • Review and approve what gets promoted into shared memory
  • Catch stale context in coverage gaps before it spreads
Hosted early access dashboard for governing shared team memory
Who it's for

Built for teams who ship with AI.

mex is not locked to one coding agent. Memory lives with the project.

ENGINEERING TEAMS

  • One project memory instead of conflicting rules files
  • Agents start from the same decisions and conventions
  • New hires inherit context that already lives in the repo
Two developers converging on shared memoryTwo developer figures angled inward with flow lines converging on a single shared peach memory block centered between them.

TEAM LEADS & ADMINS

  • Hosted early access: see and govern what gets promoted
  • Catch drift before two conventions ship in the same week
  • Keep memory tied to the code, not trapped in one person’s agent
Team lead overseeing agent promotionA lead figure at top with sightline threads fanning down to three agent units. The centre agent promotes a peach memory block upward.

SCALING ORGANIZATIONS

  • Memory that survives people leaving and tools changing
  • Same project memory across harnesses (Claude Code, Codex, Cursor)
  • Hosted path when you outgrow git-native sharing
Team unit replicating at scaleThree team-units arranged on a receding diagonal. The front unit has a peach memory block; the two behind fade in opacity and use ink-outline-only blocks. A continuous thread links all three.
Updates & insights

Shipping in the open.

mex is open source and moving fast. Here's what's new in the CLI, and how we think about memory for AI coding teams.

Latest releases
v0.8.3Latest· September 2026

Graph refresh reuses unchanged files, grounding survives fresh clones and small renames, and FastAPI, Flask and NestJS routes join the graph. npx mex-agent@0.8.3 setup

v0.8.2· September 2026

Set up in the Hub

Setup starts in the local browser Hub. Terminal setup remains available.

Writing
BlogBenchmarksmex

When memory goes stale: benchmarking mex against nine tools

After 367 commits of real code changes, memory tools with no link to code served 90 to 100% of outdated facts as current in their no-LLM modes. mex served 20%, and we measured what its warnings cost.

Read more
LinkedInAgent memoryArchit Dhamija

Agent Beliefs Need a Compile Step

There is a kind of sentence that sounds like knowledge but does not point at anything, and a name can survive the thing it named.

Read on LinkedIn
LinkedInAgent memoryAkshat Dhamija

Extended mind, badly

Thoughts on agent memory. Clark and Chalmers’ Extended Mind Thesis holds up for this space as well.

Read on LinkedIn
BlogBenchmarksmex

90% less noise, up to 70% fewer tokens: the numbers behind mex

On a set of retrieval tasks, mex returned answers that were 10x more compact than a grep-based baseline, while still finding everything it needed to find.

Read more
LinkedInContextmex

A million-token context window is not a million-token brain

Every few months, a new model arrives with a larger context window. But being present is not the same as being used.

Read on LinkedIn
XAgent memoryDaksh Jaitly

Your AI Agent Has Amnesia. Here's the Fix.

Why every session starts cold, and the case for persistent, structured memory over giant context files.

Read on X
Why we built mex

We kept watching our agents drift apart.

We started like most teams: every developer keeping their own rules file. Agents drifted apart within weeks. Corrections piled up, context went stale, and nobody had a clear view of what the tools actually knew.

So we built mex: project memory that lives with the code. The open-source CLI is that memory in your repo, today. The hosted product on this waitlist is for teams that want it governed in one place.

From single-player agents to multiplayer AI: one shared source of truth.

Diagram showing fragmented agent memory converging into project memory that lives with the code