mex-memory/mex

Team memory for engineers and their AI agents. Lives in your repo. Shared through Git.

What it solves

MEX provides a shared project memory system for engineering teams and their AI coding agents. It solves the problem of fragmented knowledge—where critical architectural decisions, debugging history, and edge cases are trapped in individual engineers' heads or ephemeral agent sessions—by creating a durable, version-controlled home for this context within the Git repository.

How it works

MEX separates canonical knowledge from local retrieval machinery:

  • Canonical Memory: Knowledge is stored as structured Markdown files (Wiki, Specs, Relays, and Inbox proposals) directly in the repository, allowing it to be shared via standard Git commits and pushes.
  • Local Indexes: Each user maintains their own local SQLite-based indexes (Code Graph and Wiki search) that are rebuildable from the canonical files and source code.
  • Code Graph: Uses Tree-sitter grammars to map symbols and relationships in the code (supporting TypeScript, JavaScript, Python, and Rust) to provide precise evidence for AI agents.
  • Grounding: Wiki claims are linked to specific code symbols. If the code changes, MEX flags "drift," signaling that the documentation needs review.
  • Agent Integration: It provides instructions and skills for agents (like Claude Code or Codex) to retrieve context and draft knowledge proposals or handoffs, which humans must then review and approve before they become canonical.

Who it’s for

It is designed for software engineering teams who use AI coding agents and want to ensure that the context learned by one person or agent is preserved and accessible to the rest of the team.

Highlights

  • Git-based sharing: No hosted service or central database is required; memory travels with the code.
  • Project Hub: A local browser-based interface for exploring the knowledge graph, reviewing proposals, and managing handoffs.
  • Relays: A structured way to hand off work between engineers, capturing progress, blockers, and next steps.
  • Code-linked explanations: Direct grounding between prose and implementation to prevent documentation rot.
  • Multi-agent support: Compatible with various AI tools through instruction anchors and specific skills for Claude Code and Codex.

Related

  • Project
    davekilleen/Dex

    An AI Chief of Staff that organizes priorities, tasks, and meeting notes in a user-owned local vault, integrating with AI apps like Claude Code and Cursor.

  • Project
    akitaonrails/ai-memory

    ai‑memory is a Rust‑based, self‑contained service that gives AI coding assistants a shared, long‑term, markdown‑backed memory. It automatically captures prompts and tool calls via hooks, stores them as git‑versioned markdown pages, and lets any supported agent (Claude Code, Codex, Cursor, Gemini CLI, etc.) retrieve a concise hand‑off on a different machine or after a teammate’s session. By default it works offline with zero LLM calls; optional LLM‑driven “dream” consolidation, vector search, and aging policies are configurable. The project provides native packages, Docker images, and a macOS menu‑bar app, and includes built‑in multi‑user auth, audit logs, and per‑project sharing.

  • Project
    abhigyanpatwari/GitNexus

    GitNexus is a Node‑JS tool that indexes a repository into a knowledge graph (dependencies, call chains, clusters, execution flows) and exposes that graph through 19 MCP tools. The CLI (`gitnexus analyze` / `setup`) builds the graph locally, installs agent skills, and writes configuration so AI coding assistants such as Claude Code, Cursor, Codex, Antigravity, etc., can query the graph for impact analysis, trace, rename, and more. A Web UI (hosted or self‑served) lets you explore the graph in the browser. Deployable on Render/RepoCloud or run locally, it aims to give LLM‑based agents reliable, token‑efficient context for large codebases. License: PolyForm Non‑commercial.

  • Project
    basicmachines-co/basic-memory

    A persistent, two-way memory system for AI assistants that uses shared Markdown files and the Model Context Protocol (MCP) to create a long-term knowledge graph.

  • Project
    mcncarl/agent-memory-vault

    A Python‑based, local‑first system that lets Claude Code, Codex and similar agents store and retrieve shared knowledge in a private Markdown vault. The vault is versioned with Git, indexed with SQLite (and optionally a local embedding vector store), and all writes go through a strict read‑prepare‑authorize‑apply workflow that records immutable receipts. It provides searchable, auditable long‑term memory for AI coding assistants while keeping the data private to the user.