Peon Mem

Name: Peon Mem
Author: VineetV2

by VineetV2version 1.0.9i★ –iRuns on your computer

Registry nameio.github.VineetV2/peon-mem

Install

Overview

Description from the maker (original English)

Local-first memory brain for AI coding agents: hooks capture sessions, beliefs injected per prompt.

PopNx MCP’s three pillars

These three are never merged into one score: opinions, measurements and popularity are different things.

User voiceiNo reviews yetReviews open together with accounts in a later step
Our basic checksi1 of 1 passedChecked from public information; code not scanned yet
UsageiNot measured yet★ –

What you can do with it

We have not written a plain-language summary for this one yet. Below are the facts we read from the registry.

Connection: Runs on your computer
Transport: stdio
Category: Search & AI memory

Install

Pick the AI app you use, then copy the settings.

Before you install

Basic checks: 1 of 1 passed
Runs on your computer with your user’s permissions (files, network, apps).
You fill in yourself: PEON_DAEMON_URL

You need

npmNode.js installed (for the npx command)

Which app do you use?

ClaudeClaude CodeCursorVS CodeChatGPT

Pick your app above. We remember it, so next time the button says “Install in …”.

Open Claude Desktop → Settings → Developer → Edit Config, and paste this into claude_desktop_config.json

{
  "mcpServers": {
    "peon-mem": {
      "command": "npx",
      "args": [
        "-y",
        "peon-mem"
      ],
      "env": {
        "PEON_DAEMON_URL": "your-value"
      }
    }
  }
}

Run this in your terminal

claude mcp add peon-mem --env PEON_DAEMON_URL=your-value -- npx -y peon-mem

Fill in the empty values before running it.

Open in Cursor

Or copy the settings yourself

Paste into .cursor/mcp.json in your project, or ~/.cursor/mcp.json

{
  "mcpServers": {
    "peon-mem": {
      "command": "npx",
      "args": [
        "-y",
        "peon-mem"
      ],
      "env": {
        "PEON_DAEMON_URL": "your-value"
      }
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

Open in VS Code

Or copy the settings yourself

Paste into .vscode/mcp.json in your project

{
  "servers": {
    "peon-mem": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "peon-mem"
      ],
      "env": {
        "PEON_DAEMON_URL": "your-value"
      }
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

This one runs on your computer, and ChatGPT can only connect to servers on the internet. Pick another app.

Your choice stays on this device in a cookie; no account needed.

Values you fill in

PEON_DAEMON_URL env
Peon daemon address

These settings are generated from the maker’s registry entry. If the README says otherwise, follow the README.

What it can do

Runs on your computer; the tool list appears in your AI app after you install it.

Basic checksi

We check information anyone can see; we have not read the code. Checks that do not apply are left out of the count. · Checked Nov 7, 2026

✓ Pass
Maker matches the repo
The registry name was verified with the GitHub account VineetV2, which owns the repo
… Not checked yet
Still maintained
We have not read this repo from GitHub yet
… Not checked yet
Has a licence
We have not read this repo from GitHub yet
– Not applicable
Endpoint responds
This one runs on your computer; there is no internet endpoint
– Not applicable
Sign-in with OAuth
Runs on your computer and uses local settings instead
… Not checked yet
No hidden instructions in tool descriptions
Runs on your computer; we can only read tool lists from internet endpoints

Compared with others in Search & AI memoryi

More stars than 0% of the other 7286 servers in this category
Published to the registry more recently than 40% of the other 7286 servers in this category
Basic checks equal to or better than 100% of the other 7286 servers in this category

Compared with every active server in this category in the registry. Stars count only when the publisher owns the repo.

Common questions

Is Peon Mem safe?

It passed 1 of 1 applicable basic checks. We have not read the code. Before adding a key or token, see what access the server asks for and use a key with only the permissions you need.

What keys or codes does it need?

The registry does not list a required key, though some servers ask you to sign in on first use.

Does it run on my computer or in the cloud?

It runs on your computer. Your AI app starts it when needed, and data does not pass through the maker’s servers (unless it calls an online service itself).

Is it still maintained?

The GitHub repo last changed –, and the latest version (1.0.9) reached the registry 2 months ago.

Which apps can use it?

Apps that support MCP, such as Claude Desktop, Claude Code, Cursor and VS Code. You also need Node.js on your computer.

What can I use instead?

In the same category: Context7, Codebase Memory, Exa

Alternatives

Servers in the same category from other makers, sorted by stars.

Reading a card:★ GitHub starsiThree pillars: reviews · checks · usageiUpdated = latest version published to the registryi

Context7

by upstash

Feeds AI the latest docs for libraries and frameworks before it answers, so code it writes does not use outdated, removed functions.

Computer or cloud★ 64,224MITUpdated yesterday

Install

Codebase Memory

by DeusData

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

Runs on your computer★ 48,148MITUpdated 21 days ago

Install

Exa

by exa-labs

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

Runs in the cloud★ 5,213MITUpdated last month

Install

README from the maker

Open the README

Copied from the maker’s repo as written. PopNx MCP has not reviewed or endorsed it. HTML, images and scripts are removed. Links lead off this site.

🧠 Peon — a memory brain for your AI coding agents

Local-first, hierarchical, self-improving memory for Claude Code, Codex, and any MCP client.

Your AI forgets everything between sessions. Peon doesn't. It records your sessions, uses an LLM to consolidate them into typed *beliefs*, and injects the relevant ones back into every prompt. It runs as a daemon on your machine, and nothing leaves it.

        PEON GLOBAL BRAIN            ← user-level facts & preferences, inherited everywhere

/ | \ project A project B project C ← rooted child brains (.peon/ in each project)

Why Peon

Hierarchical brains. One global parent brain holds who you are, your rules, and your tools. Each project gets an isolated child brain. Every injection carries both.
Two memory layers, honestly measured. Consolidated *beliefs* (decisions, preferences, facts, artifacts) give you the gist. An *episodic* verbatim layer recovers the exact details that lossy summaries drop. In my own LongMemEval run, raw-episodic recall scored 61% where belief-only scored 17% — self-measured, not an independent benchmark; reproduce it with npm run eval.
Automatic capture and injection. Claude Code hooks record messages and events, then inject a query-ranked memory block (with an ⚠ MOST RELEVANT headline) into every prompt. You never have to remember to save anything.
Cost-gated consolidation. An LLM distills sessions into beliefs only once enough new memory accumulates. It can supersede, merge, and flag conflicts. Nothing is destructively deleted.
Hybrid retrieval. Lexical and semantic RRF fusion, MMR diversity, reinforcement, and recency. Query embeddings are cached to disk, so repeat prompts cost nothing.
The Neural Universe. A live monitor at localhost:3737/monitor renders every belief as a star. Projects are galaxies, search makes matches flare, and autonomous curation pulses.
A daily self-audit (STL). Peon checks itself every day: what it recorded, what it injected, what failed, what consolidation did. Then it files a report with a verdict.
Eval-gated development. A committed results ledger (git SHA, qrels, and brain fingerprint per row) means retrieval changes are proven, not asserted. Negative results stay documented.
Local-first and locked down. Plain JSONL you can read, a loopback-only daemon with DNS-rebinding protection, secret redaction at the injection boundary, and path-traversal guards.

*The live monitor: 18k real beliefs rendered as stars. Type to make matching beliefs flare; click one to inspect it.*

*Ask the field: typing "wulver cluster" makes 400+ matching beliefs flare while the rest dim, and the camera flies to them.*

Why "Peon"?

The name comes from Indian offices. Every office had a peon, the person who walked desk to desk all day: collect a file from this table, note who needs what, carry it to the next table, remember where everything is. He wasn't the boss or the star, but the whole office quietly ran on him. Nothing moved without him, and he never forgot where anything was.

That's this framework, with AI. Peon walks between your sessions and your projects. It collects what happened at one desk (a session), files it in the right cabinet (a project brain), carries the relevant papers to the next desk before you ask (injection), and keeps the master ledger upstairs (the global brain). Quiet clerk. Perfect memory. The office runs on him.

How Peon differs from existing memory tools

	Peon	mem0	Letta/MemGPT	Zep/Graphiti	flat memory files (MEMORY.md)
Runs	100% local daemon	cloud or self-host	server	cloud/server	local
Storage	human-readable JSONL you can `cat`	vector DB	DB	graph DB	markdown
Memory model	beliefs + verbatim episodic layer	extracted facts	self-edited blocks	temporal knowledge graph	prose
Hierarchy	global parent brain → per-project child brains, inherited on every prompt	user/agent/session scopes	per-agent	per-user	per-project file
Capture	automatic via hooks (zero effort)	SDK calls you write	agent-managed	SDK calls	agent must remember to write
Conflict handling	supersede/merge, recoverable — never hard-deletes	LLM may DELETE	self-edit	invalidation	overwrite
Exact recall	episodic layer regression-tested (61% vs 17% belief-only on LongMemEval, self-measured)	gist only	gist only	graph facts	whatever was written
Observability	live Neural Universe monitor + daily self-audit (STL) + serve telemetry	dashboard	—	—	—
Verification	committed eval ledger; negative results kept	vendor benchmarks	—	vendor benchmarks	—

The short version: mem0 and Zep are memory platforms for products you build. Peon is memory for the coding agents you already use. It plugs into Claude Code or Codex in about five minutes, and you can watch it think and audit every number it claims.

Your agents share one brain

If you run more than one coding agent — Claude Code and Codex, say — they usually each live in their own bubble. Whatever you work out with one is gone when you switch to the other.

Point them at the same project and Peon dissolves that wall. Both agents resolve to the same .peon/ brain (Peon canonicalizes the project path, so the hook, a direct MCP call, and Codex all land on one store). So the memory flows between them:

Codex works out how your build pipeline runs and records it. Next time you open Claude Code in that repo, it's already in the injected context.
Claude Code hits a gotcha and files it. Codex sees it the moment it calls get_context or search_memory.
The global brain sits above both, so your preferences and rules follow you into every agent, in every project.

They aren't chatting in real time. It's a shared notebook both write in and both read from, so a decision made in one agent shows up in the other without you re-explaining it. One project, one memory, however many agents.

Quickstart

Requirements: Node 20+, macOS or Linux. An OpenRouter API key is recommended (consolidation + semantic embeddings); without one Peon still works lexical-only.

One line:

npm install -g peon-mem && peon-mem install

(no Node? curl -fsSL https://raw.githubusercontent.com/VineetV2/peon-mem/main/install.sh | bash)

The guided setup asks four things:

Where your global brain lives (default: ~/Library/Application Support/Peon)
Which LLM: OpenRouter (one key, any model) · OpenAI · Anthropic · Ollama (100% local & free) · or skip
Installs the daemon as an auto-start service (launchd on macOS, systemd user unit on Linux)
Detects your AI apps and wires the MCP server (plus hooks for Claude Code) into the ones you pick. Auto-configured: Claude Code, Claude Desktop, Codex, Gemini CLI, Cursor, Windsurf, Cline, VS Code (Copilot MCP), Zed, LM Studio. Detected with in-app instructions: ChatGPT Desktop, Perplexity Desktop. Every touched config gets a .peon-backup.

That builds the package, starts the daemon as a service, wires your Claude Code hooks + MCP server (with a backup of your settings), and writes a config template. Then add your key to ~/Library/Application Support/Peon/.env and open the monitor. peon-mem install --dry-run shows every action first; peon-mem uninstall reverses it (memory data is never touched).

Or manually:

git clone https://github.com/VineetV2/peon-mem && cd peon-mem

npm install && npm run build node bin/peon-mem.mjs install --dry-run # inspect, then run without --dry-run

Create .env in the repo root:

OPENROUTER_API_KEY=sk-or-...

PEON_PROCESSING_MODEL=google/gemini-2.5-flash-lite # cheap + good enough (measured) PEON_EMBEDDING_MODEL=openai/text-embedding-3-small

Start the daemon (the installer prints a launchd/systemd recipe, or just):

node dist/daemon-cli.js              # serves 127.0.0.1:3737

Then wire your agent (the installer prints these filled in for your paths):

Claude Code: add the hook to ~/.claude/settings.json (SessionStart / UserPromptSubmit / SessionEnd → scripts/claude-peon-hook.mjs) and the MCP server (dist/index.js).
Codex / any MCP client: register dist/index.js as a stdio MCP server; 16 tools (start_session, get_context, search_memory, record_message, process_memory, …).

Open http://127.0.0.1:3737/monitor and watch your brain grow.

How it works

Record. Hooks stream messages, events, and tool calls into /.peon/raw/ (append-only).
Consolidate. Past a size gate, an LLM turns the session delta into typed belief records in .peon/brain/memories.jsonl (importance/confidence scores, entities, provenance pointers), reconciling against existing beliefs: supersede, merge, conflict-flag. Recoverable, never deleted.
Retrieve + inject. On every prompt, beliefs are ranked (RRF lexical+semantic, MMR, reinforcement) and injected alongside episodic verbatim matches and inherited global beliefs.
Self-curate. A background brain pass reinforces recalled beliefs, compresses stale clusters, and resolves duplicates. Every action is logged and undoable.
Self-audit (STL). A daily job reports what was recorded, what was injected, what went wrong, and whether consolidation behaved, with serve-latency telemetry and a health verdict.

Full install (copy-paste)

1. Daemon (always-on, macOS launchd)

node scripts/install-peon.mjs           # prints everything below filled in for YOUR paths

Or manually — ~/Library/LaunchAgents/com.peon.daemon.plist:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">

Label com.peon.daemon ProgramArguments /opt/homebrew/bin/node /ABSOLUTE/PATH/TO/peon/dist/daemon-cli.js

RunAtLoad KeepAlive

launchctl load ~/Library/LaunchAgents/com.peon.daemon.plist

curl http://127.0.0.1:3737/health # → {"ok":true}

Linux: the installer writes ~/.config/systemd/user/peon-mem.service and enables it. Manual equivalent: systemctl --user enable --now peon-mem.service, plus loginctl enable-linger $USER so it survives logout. (Linux support is young — issue #1 tracks real-machine reports.)

2. Claude Code — hooks (auto capture + injection)

Merge into ~/.claude/settings.json (replace the path):

"hooks": { "SessionStart": [{ "hooks": [{ "type": "command", "command": "node /ABSOLUTE/PATH/TO/peon/scripts/claude-peon-hook.mjs" }] }], "UserPromptSubmit": [{ "hooks": [{ "type": "command", "command": "node /ABSOLUTE/PATH/TO/peon/scripts/claude-peon-hook.mjs" }] }], "SessionEnd": [{ "hooks": [

Only the beginning is shown; read the rest in the repo

Peon Mem

Overview

PopNx MCP’s three pillars

What you can do with it

Install

Before you install

Values you fill in

What it can do

Basic checksi

Maker matches the repo

Still maintained

Has a licence

Endpoint responds

Sign-in with OAuth

No hidden instructions in tool descriptions

Compared with others in Search & AI memoryi

Common questions

Alternatives

Context7

Codebase Memory

Exa

README from the maker

🧠 Peon — a memory brain for your AI coding agents

Why Peon

Why "Peon"?

How Peon differs from existing memory tools

Your agents share one brain

Quickstart

How it works

Full install (copy-paste)

1. Daemon (always-on, macOS launchd)

2. Claude Code — hooks (auto capture + injection)