Agent Memory

Name: Agent Memory
Author: xChuCx

de xChuCxversión 0.6.1i★ –iSe ejecuta en tu computadora

Nombre en el registroio.github.xChuCx/agent-memory

Instalar

Resumen

Descripción del creador (original en inglés)

Git-native project memory for AI coding agents: Markdown source of truth, reviewable, secret-safe.

Los tres pilares de PopNx MCP

Estos tres nunca se combinan en una sola puntuación: las opiniones, las mediciones y la popularidad son cosas distintas.

Opinión de usuariosiAún no hay reseñasLas reseñas se abrirán junto con las cuentas en una etapa posterior
Nuestras revisiones básicasi1 de 1 superadasRevisado con información pública; el código aún no se ha escaneado
UsoiAún sin medir★ –

Qué puedes hacer con él

Todavía no escribimos un resumen sencillo para este. Abajo están los datos que leímos del registro.

Conexión: Se ejecuta en tu computadora
Transporte: stdio
Categoría: Búsqueda y memoria de IA

Instalación

Elige la app de IA que usas y copia la configuración.

Antes de instalar

Revisiones básicas: 1 de 1 superadas
Se ejecuta en tu computadora con los permisos de tu usuario (archivos, red, apps).
El registro no indica ninguna clave que completar.

Necesitas

npmNode.js instalado (para el comando npx)

¿Qué app usas?

ClaudeClaude CodeCursorVS CodeChatGPT

Elige tu app arriba. La recordamos, así que la próxima vez el botón dirá “Instalar en …”.

Abre Claude Desktop → Settings → Developer → Edit Config y pega esto en claude_desktop_config.json

{
  "mcpServers": {
    "agent-memory": {
      "command": "npx",
      "args": [
        "-y",
        "@xchucx/agent-memory"
      ]
    }
  }
}

Ejecuta esto en tu terminal

claude mcp add agent-memory -- npx -y @xchucx/agent-memory

Abrir en Cursor

O copia la configuración tú

Pégalo en .cursor/mcp.json de tu proyecto, o en ~/.cursor/mcp.json

{
  "mcpServers": {
    "agent-memory": {
      "command": "npx",
      "args": [
        "-y",
        "@xchucx/agent-memory"
      ]
    }
  }
}

Tu navegador te pide permiso para abrir la app; luego la app muestra la configuración y te pide confirmar. Los valores de las claves quedan vacíos para que los completes tú.

Abrir en VS Code

O copia la configuración tú

Pégalo en .vscode/mcp.json de tu proyecto

{
  "servers": {
    "agent-memory": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@xchucx/agent-memory"
      ]
    }
  }
}

Tu navegador te pide permiso para abrir la app; luego la app muestra la configuración y te pide confirmar. Los valores de las claves quedan vacíos para que los completes tú.

Este se ejecuta en tu computadora, y ChatGPT solo puede conectarse a servidores en internet. Elige otra app.

Tu elección se guarda en una cookie en este dispositivo; no necesitas cuenta.

Esta configuración se genera a partir de la ficha del creador en el registro. Si el README dice otra cosa, sigue el README.

Qué puede hacer

Se ejecuta en tu computadora; la lista de herramientas aparece en tu app de IA después de instalarlo.

Revisiones básicasi

Revisamos información que cualquiera puede ver; no hemos leído el código. Las revisiones que no aplican no se cuentan. · Revisado el 6 nov 2026

✓ Superada
El creador coincide con el repo
El nombre en el registro se verificó con la cuenta de GitHub xChuCx, dueña del repo
… Aún sin revisar
Sigue en mantenimiento
Todavía no hemos leído este repo en GitHub
… Aún sin revisar
Tiene licencia
Todavía no hemos leído este repo en GitHub
– No aplica
El endpoint responde
Este se ejecuta en tu computadora; no hay endpoint en internet
– No aplica
Inicio de sesión con OAuth
Se ejecuta en tu computadora y usa ajustes locales en su lugar
… Aún sin revisar
Sin instrucciones ocultas en las descripciones de herramientas
Se ejecuta en tu computadora; solo podemos leer listas de herramientas de endpoints en internet

Comparado con otros en Búsqueda y memoria de IAi

Más estrellas que el 0% de los otros 7240 servidores de esta categoría
Publicado en el registro más recientemente que el 47% de los otros 7240 servidores de esta categoría
Revisiones básicas iguales o mejores que el 100% de los otros 7240 servidores de esta categoría

Comparado con todos los servidores activos de esta categoría en el registro. Las estrellas solo cuentan cuando quien lo publica es dueño del repo.

Preguntas frecuentes

¿Es seguro Agent Memory?

Superó 1 de 1 revisiones básicas aplicables. No hemos leído el código. Antes de agregar una clave o un token, revisa qué acceso pide el servidor y usa una clave que tenga solo los permisos que necesitas.

¿Qué claves o códigos necesita?

El registro no indica ninguna clave obligatoria, aunque algunos servidores te piden iniciar sesión la primera vez que los usas.

¿Se ejecuta en mi computadora o en la nube?

Se ejecuta en tu computadora. Tu app de IA lo inicia cuando hace falta, y los datos no pasan por los servidores del creador (a menos que el propio servidor llame a un servicio en línea).

¿Sigue en mantenimiento?

El repo de GitHub cambió por última vez –, y la última versión (0.6.1) llegó al registro hace 44 días.

¿Qué apps pueden usarlo?

Las apps compatibles con MCP, como Claude Desktop, Claude Code, Cursor y VS Code. También necesitas Node.js en tu computadora.

¿Qué puedo usar en su lugar?

En la misma categoría: Context7, Codebase Memory, Exa

Alternativas

Servidores de la misma categoría hechos por otros creadores, ordenados por estrellas.

Cómo leer una tarjeta:★ Estrellas de GitHubiTres pilares: reseñas · revisiones · usoiActualizado = fecha en que se publicó la última versión en el registroi

Context7

de upstash

Up-to-date docs for AI agents

Computadora o nube★ 64.224MITActualizado hace 3 días

Instalar

Codebase Memory

de DeusData

Codebase knowledge graph for AI agents — 162 languages, sub-ms queries, 99% fewer tokens.

Se ejecuta en tu computadora★ 48.148MITActualizado hace 20 días

Instalar

Exa

de exa-labs

Connect AI agents to Exa for web search, content fetching, and multi-step research.

Se ejecuta en la nube★ 5213MITActualizado hace 44 días

Instalar

README del creador

Abrir el README

Copiado tal cual del repo del creador. PopNx MCP no lo ha revisado ni lo respalda. Se quitaron HTML, imágenes y scripts. Los enlaces llevan fuera de este sitio.

agent-memory

Local, git-native project memory for AI coding agents. One MCP call in, structured memory updates out — current task state, decisions, conventions, pitfalls, per-module facts. Branch-aware. Secret-safe. Byte-preserving. No cloud, no vector DB — Markdown is the source of truth and git is the sync. Three MCP tools + a full CLI.

Why it's different: memory is plain Markdown committed to your repo, so you can read and git diff it; durable changes stage for human review (review --diff → apply) instead of landing silently; and secrets/PII are scanned out before anything is written. See ROADMAP.md for where this is headed (system-level / multi-repo memory).

Demo

An agent records a durable decision; it stages for review; you see the exact diff, apply it, and a later `fetch` surfaces it — local, git-native, reviewable, secret-safe. The clip is reproducible: docs/demo/demo.sh is the runnable flow and docs/demo/demo.tape renders the gif with vhs — see docs/demo/.

How it compares

Capability	AGENTS.md / CLAUDE.md	Vendor memory (e.g. Claude)	Vector / DB memory (mem0, Zep)	agent-memory
Plain-text, git-versioned source of truth	✓ flat file	✗ vendor-managed	✗ DB / cloud	✓ Markdown in your repo
Structured, section-level updates	✗	✗	~	✓
Human review gate (see the diff first)	✗ free edit	✗	✗	✓ stage → `review --diff` → apply
Vendor-neutral (MCP — any agent)	~ broad convention	✗ one vendor	~ varies	✓ Claude · Cursor · Codex · Gemini
Secret / PII scan on write	✗	✗	~ varies	✓
Team merge for concurrent edits	✗ text conflicts	✗	✗	✓ section merge driver
Runs fully local (no cloud)	✓	✗	~ varies	✓
Verifiable Task Protocol (VTP-1) & Machine Receipts	✗	✗	✗	✓ 5-phase cryptographic lifecycle + Clause B disjoint seat

These are general characterizations and the tools evolve fast — see something inaccurate? Open an issue and I'll fix the row. agent-memory is complementary to instruction files like AGENTS.md/CLAUDE.md (it even installs one): those say *how to behave*; agent-memory is the *durable, searchable, reviewed knowledge* behind it.

Status

Release 0.6.1 — the Swarm Audit Hardening & Metamorphic Rebase release: bridges durable memory with verifiable autonomous execution and strict fail-closed security invariants:

Astra Pro Audit Hardening (AM-001..AM-008) — Category-enforced approval routing (DecideRoutingWithCategory), whole-file pre-state CAS (proposal.PreHashes), polarity/negation qualifier preservation in Jaccard dedup (criticalQualifiers), idempotent pure read-only fetch_context, and canonical 3-way merge deletion semantics.
Metamorphic Rebase & Drift Detection (`internal/memory/rebase.go`) — Detects whole-file pre-hash drift during rebase, preventing silent clobber when adjacent sections are concurrently edited, verified by metamorphic composition tests.
Control-Plane Manifest Isolation — Enforces fail-closed protection of .agent-memory/meta/manifest.yaml against direct modification, symlink bypass, or path traversal attacks.
RFC 8785 (JCS) Determinism (`internal/vtp`) — Strict JSON Canonicalization Scheme compliance passing all 26 official RFC 8785 Appendix B test vectors, ECMAScript float formatting (1e+21), lone surrogate rejection, and recursive UTF-8 validation.
Fail-Closed Cross-Process SQLite NonceStore (`internal/memory/nonce.go`) — Persistent repo-scoped store using the withDB pattern to eliminate Windows file descriptor locks, providing zero-drift atomic validation and auto-sweeping expired nonces.
Two-Phase Staging & Compound Rollback (`internal/memory/staging.go`) — Strict path traversal sanitization (ValidateStagingID, agentfs.ValidateMemoryPath), symlink containment, and atomic multi-file rollback reporting RollbackIncomplete compound errors on partial failure.
VTP-1 Strict Assertion Identification & Dual-Oracle Settlement (`internal/vtp`) — Mandatory identifiable AssertionResults matching declared assertion IDs, verifier key binding validation, and Workpool/0 Clause B disjoint seat enforcement.

It builds on 0.6.0 (anti-ornamental SAR-008 grounding nonces, SAR-007 byte preservation), 0.5.4 (VTP-1 initial protocol engine), 0.5.0 (federation, referenced landscape stores), and 0.4 (section merge driver).

See CHANGELOG.md for the full changelist.

Document	Purpose
ROADMAP.md	Where the project is going, principles, and non-goals.
CHANGELOG.md	Per-release feature list and known limitations.
Design Doc v0.4.1	Canonical design this binary implements.
Implementation Plan	Historical MVP build log (M0–M8); see ROADMAP for what's next.
Retrieval eval	Offline recall/MRR/nDCG benchmark of `fetch` (method + numbers).
Patterns	Reusable design patterns documented per subsystem.
Spikes	Pre-M1 spike outcomes (byte-preserving engine, MCP SDK, flock, FTS5).

Quick start

Install — download a prebuilt binary (recommended): grab the archive for your OS/arch from the latest release, extract it, and put agent-memory on your PATH. No toolchain needed.

# npx (no Go, no manual download): fetches the verified release binary on

first run and caches it — also usable straight from an MCP client config.

npx -y @xchucx/agent-memory --help

Go toolchain alternative (Go 1.25+)

go install github.com/xChuCx/agent-memory/cmd/agent-memory@latest

from source

go build -o agent-memory ./cmd/agent-memory

Homebrew, Scoop, and winget packages are planned. agent-memory is also listed on the MCP Registry.

Then, inside the repo you want to give a memory:

# Scaffold .agent-memory/ in a repo

agent-memory init --name my-project

Install the Claude Code skill + register the project MCP server

(writes .claude/skills/agent-memory/SKILL.md and merges .mcp.json)

agent-memory install claude

Verify (prints the release tag, the go-install version, or dev+vcs locally)

agent-memory version

Read context

agent-memory fetch # bootstrap pack agent-memory fetch "auth" # FTS query

Start MCP server (your agent spawns this automatically once configured)

agent-memory mcp

install claude registers the MCP server for you: it merges a project-scoped .mcp.json at the repo root that runs agent-memory mcp --root ${CLAUDE_PROJECT_DIR:-.}. Claude Code expands CLAUDE_PROJECT_DIR to the repo at spawn, so the server always serves this repo — the config is portable across clones and (by Claude Code's scope precedence, local > project > user) overrides any stray user-scoped server. Commit .mcp.json so your team shares it.

⚠️ Do not register a single user-scoped server with a hardcoded root

(claude mcp add -s user agent-memory -- agent-memory mcp --root /some/repo):

it serves *every* project from that one repo, so memory you write in project B

silently lands in project A. Per-project registration (what install writes)

is the correct model; agent-memory doctor flags a mis-rooted registration.

The server resolves its repo from --root, then $CLAUDE_PROJECT_DIR, then the working directory. Other runtimes (Cursor, Gemini CLI, anything reading AGENTS.md) use the same server — install their adapter (see below).

Adopt on an existing project

init scaffolds empty memory. To seed it from a real codebase, let your coding agent do the analysis — that's the whole point. After init + install + registering the MCP server (above), restart the agent so the memory.* tools load, then paste the prompt below.

What happens: the agent reads the repo and calls memory.propose_update. Working notes and pitfalls apply immediately; durable categories (conventions, decisions, modules) stage for your review — inspect each with agent-memory review --diff and land it with agent-memory apply (or reject). Nothing durable is written without your approval.

You now have agent-memory MCP tools (memory.fetch_context,

memory.propose_update, memory.status) backed by this repository's .agent-memory/ store. Bootstrap the project's memory from the codebase.

Call memory.fetch_context with an empty query to see the current (mostly empty) state and the conventions/decisions/pitfalls/modules layout.

Analyze THIS repository — read the build files, CI config, entry points, and the main packages/modules. Identify:

build / test / run / lint commands and the toolchain;
conventions: code style, branching, commit rules, review practices;
architecture: the major modules/components and what each is for;
durable decisions: notable choices and WHY (only ones that are real and stable — not speculation);
pitfalls: footguns, sharp edges, "don't do X because Y" you can infer from the code, tests, or docs.

Persist what you found via memory.propose_update, choosing the intent per kind:

update_conventions → conventions.md (build/test/style/workflow)
refresh_module → modules/ .md (one per major component)
record_decision → decisions.md (Date / Status / Confidence + sources; type ∈ file|test|user, NOT external)
add_pitfall → pitfalls.md
update_shared → local/current.shared.md (a short "current state / where things stand" summary)

Rules:

Cite provenance: pass sources as file references you actually read (e.g. {"type":"file","ref":"internal/auth/session.go"}). Use confidence=confirmed for facts from code, inferred for deductions.
Every section needs a unique " " anchor; keep entries concise — this is working knowledge, not a wiki. Decisions need Date, Status (active|superseded|deprecated|proposed), and Confidence fields.
NEVER put secrets, tokens, or credentials in memory (the server will reject them anyway).
Work in a few focused passes (conventions + architecture first, then modules, then decisions/pitfalls). Report what you proposed and what staged for review.

No MCP s

Solo se muestra el principio; lee el resto en el repo

Agent Memory

Resumen

Los tres pilares de PopNx MCP

Qué puedes hacer con él

Instalación

Antes de instalar

Qué puede hacer

Revisiones básicasi

El creador coincide con el repo

Sigue en mantenimiento

Tiene licencia

El endpoint responde

Inicio de sesión con OAuth

Sin instrucciones ocultas en las descripciones de herramientas

Comparado con otros en Búsqueda y memoria de IAi

Preguntas frecuentes

Alternativas

Context7

Codebase Memory

Exa

README del creador

agent-memory

Demo

How it compares

Status

Quick start

first run and caches it — also usable straight from an MCP client config.

Go toolchain alternative (Go 1.25+)

from source

Install the Claude Code skill + register the project MCP server

(writes .claude/skills/agent-memory/SKILL.md and merges .mcp.json)

Verify (prints the release tag, the go-install version, or dev+vcs locally)

Read context

Start MCP server (your agent spawns this automatically once configured)

Adopt on an existing project