Monomind

An open-source MCP server that extends Claude Code with a codebase knowledge graph, persistent memory, and multi-agent coordination.
MIT licensed · Fully local · No data leaves your machine

🏢 Orgs  ·  🚀 Quickstart  ·  ⚡ Mastermind  ·  📋 Commands  ·  🏗️ Architecture

---

What is Monomind?

Monomind is an open-source CLI and MCP server that plugs into Claude Code via the standard Model Context Protocol. It adds capabilities that Claude Code doesn't ship with out of the box:

• Codebase knowledge graph — tree-sitter parses your code into a SQLite-backed graph of files, functions, classes, and their relationships. Query imports, callers, and blast radius before making changes.
• Persistent memory — a JSON pattern store with episodic recall that survives across sessions. Agents and orgs share context without re-prompting.
• Multi-agent coordination — in-session, spawn ad-hoc agent teams via Claude Code's Task tool; for persistent background work, monomind org run starts a real SDK-backed daemon with policy-gated role agents and a live dashboard.
• Reusable slash commands — 30+ development workflows (build, review, debug, TDD, architecture) available as /mastermind:* commands inside Claude Code.

npm install -g monomind        # MIT licensed, 0 external API calls
cd your-project && monomind init
claude mcp add monomind npx monomind mcp start

Trust & Security

Concern	Answer
License	MIT — use it however you want
Data privacy	Everything runs locally. No telemetry, no phone-home, no external API calls from Monomind itself. Your code stays on your machine.
Dependencies	Standard npm packages (tree-sitter, sql.js, zod). No native binaries. No post-install scripts that download code.
Permissions	Registers as an MCP server — Claude Code controls what tools are available and prompts you before executing anything sensitive.
Source	Fully open. Read every line at github.com/monoes/monomind.
Maintenance	Active development, regular releases on npm.

---

🏢 Autonomous Organizations

This is the headline feature. monomind org run starts a persistent, SDK-backed daemon that runs an autonomous agent organization — roles, hierarchy, policy-gated tool access, a live dashboard — until you stop it.

The idea

Every business function needs a team. Define the org once as a JSON file — goal, roles, who reports to whom, per-role tool/file/budget policy — then run it as a real background daemon backed by the Claude Agent SDK. It persists across sessions, serves a live WebSocket dashboard, and can discover and message other Monomind orgs running on the same machine.

flowchart TD
    U(["You"])
    DEF["org.json\nGoal + roles + policy"]
    RUN["monomind org run\nStart SDK daemon"]
    BOSS["Boss Agent\nAgent SDK session"]
    W["Writer"]
    S["SEO Specialist"]
    R["Reviewer"]
    DASH[("Live Dashboard\n:4243")]
    XORG[("Other orgs\ncross-process")]

    U --> DEF --> RUN --> BOSS
    BOSS -->|spawns| W
    BOSS -->|spawns| S
    BOSS -->|spawns| R
    RUN <-->|serves| DASH
    RUN <-.->|--cross-process| XORG

    style BOSS fill:#00D2AA22,stroke:#00D2AA
    style DASH fill:#F59E0B22,stroke:#F59E0B
    style XORG fill:#8B5CF622,stroke:#8B5CF6

Run one

# .monomind/orgs/<name>.json defines the org: goal, roles, policy.
# See .monomind/orgs/sample-team.json in a fresh `monomind init` for a working example.

monomind org run content-team --task "Build and publish 3 blog posts per week"

# ✓ Live dashboard: http://localhost:4243
# ✓ Boss agent (Claude Agent SDK session) spawns, reads the org goal,
#   assigns work to role agents, coordinates until the task completes
#   or you stop it.

monomind org status content-team    # runtime state
monomind org stop content-team      # request a graceful stop
monomind org list                   # every org + status

What runs under the hood

What	How
OrgDaemon	Hosts one or more orgs in a single process; real Claude Agent SDK sessions per role, not simulated
PolicyEngine	Per-role gates on tool access, file read/write scope, web access, token budget — enforced, with a full audit trail
Live dashboard	WebSocket-served at :4243 by default (--port to change, --serve=false to disable)
Cross-process comms	--cross-process (default on) lets orgs on different monomind processes/projects discover and message each other
Scheduling	monomind org serve hosts orgs whose definition has a schedule field, running them on interval

Org management commands

monomind org run <name> [--task "..."] [--port N] [--cross-process]  # start a daemon
monomind org stop <name>            # request a running org to stop
monomind org status [name]          # runtime state for one or all orgs
monomind org list                   # list every org + status
monomind org serve [--port N]       # host-only mode, runs scheduled orgs
monomind org delete <name>          # remove an org

Note: the older /mastermind:createorg + /mastermind:runorg prompt-orchestrated flow is deprecated — it has no delivery guarantees or ground-truth event stream. It still runs for orgs not yet migrated, but new orgs should use monomind org run directly against a hand-authored .monomind/orgs/<name>.json.

---

⚡ The Autonomous Build Loop

For code, /mastermind:autodev is the equivalent of Orgs — a loop that researches, builds, and reviews your codebase without stopping.

flowchart LR
    R["Research\nParallel scan:\ngit log, files\nTODOs, graph\nmemory"] --> S
    S["Select\nFeasibility x\nblast-radius x\nfocus"] --> B
    B["Build\nArchitect\nCoder\nTester\nReviewer"] --> V
    V["Review Loop\nCode + Security\n+ Reality\nmax 5 iterations"] --> L
    L["Log + Loop\nStore to memory\n--tillend:\nschedule next"]
    L -->|"more to do"| R

    style R fill:#00D2AA22,stroke:#00D2AA
    style B fill:#8B5CF622,stroke:#8B5CF6
    style V fill:#F59E0B22,stroke:#F59E0B
    style L fill:#10B98122,stroke:#10B981

/mastermind:autodev --tillend              # loop until nothing left
/mastermind:autodev --tillend --focus security   # bias toward security fixes
/mastermind:autodev 3                     # exactly 3 improvements

Universal loop flags

Flag	Purpose
--tillend	Repeat until empty round (zero findings, zero actions)
--repeat <N>	Repeat exactly N times
--focus <area>	Bias toward: security · dx · performance
--auto	No confirmation prompts
--maxruns <N>	Safety cap (default 50)

---

🚀 Quickstart

# 1. Install
npm install -g monomind

# 2. Initialize in your project
cd your-project
monomind init

# 3. Wire into Claude Code as an MCP server
claude mcp add monomind npx monomind mcp start

# 4. Health check
monomind doctor --fix

Open Claude Code. You now have 60+ slash commands available:

/mastermind:autodev --tillend     # start autonomous code loop
monomind org run my-team          # run your first AI org (see .monomind/orgs/sample-team.json)
/mastermind:help                  # show all commands

---

🧠 Memory That Persists

Every session, every agent, every org writes to a persistent memory store — a JSON pattern store with episodic recall that survives across sessions. The next time you run anything, Monomind already knows what was built, what failed, and which patterns work.

graph TD
    L0["L0 - In-flight\nCurrent session drawers\nephemeral"]
    L1["L1 - Working\nCross-session memory\nBM25 K1=1.5, B=0.75"]
    L2["L2 - Long-term\nEpisodic store\nSemantic recall"]
    L3["L3 - Shared\nCross-agent namespace\nFederated swarm reads"]

    L0 -->|promoted| L1 --> L2 --> L3

    style L0 fill:#00D2AA11,stroke:#00D2AA
    style L1 fill:#F59E0B11,stroke:#F59E0B
    style L2 fill:#8B5CF611,stroke:#8B5CF6
    style L3 fill:#EF444411,stroke:#EF4444

monomind memory store "key insight" --namespace my-project
monomind memory search "auth implementation"     # BM25 + semantic hybrid

---

🗺️ Monograph — Your Codebase, as a Graph

Before touching any file, Monomind queries Monograph — a SQLite-backed knowledge graph of your entire codebase. Nodes are files, classes, and functions. Edges are imports, calls, and dependencies.

/mastermind:understand          # build the graph
/mastermind:graph-status        # nodes · edges · freshness

# Inside Claude Code, Monograph runs automatically:
# → "what files does auth.ts import?"
# → "what breaks if I change UserService?"
# → "find all callers of validateToken()"

19 default MCP tools (+27 advanced via MONOGRAPH_MCP_ADVANCED=1). Impact analysis. Community detection. Zero grep.

---

🎣 Hooks & Workers

Monomind wires 29 hook subcommands into Claude Code across edit, task, command, and session lifecycle events — logging patterns, routing agents, and feeding the intelligence system.

flowchart LR
    CE["Claude Code\nEvent"] --> H["Hook Router"]
    H --> P["pre-edit\npre-task\npre-command"]
    H --> SS["session-start\nsession-end\nnotify"]
    H --> I["route\nlearn\nbuild-agents"]
    H --> T["teammate-idle\ntask-completed"]

    I --> DB[("patterns.json\nmemory store")]
    DB -->|next session| CE

15 background workers run at session start (staleness-gated, refreshed when older than 6 hours): security · health · swarm · learning · patterns · git · performance and more.

---

🛡️ MonoFence AI — Security Layer

Every agent boundary is defended by monofence-ai — real-time detection of prompt injection, jailbreaks, homoglyphs, base64 evasion, multi-turn escalation, and PII leakage.

import { isSafe, createMonoDefence } from 'monofence-ai';

isSafe('Ignore all previous instructions');  // → false (~0.04ms)

const fence = createMonoDefence({ enableContextTracking: true });
const result = await fence.detect(userInput);
// result.safe · result.threats · result.overallRisk

---

📋 60+ Slash Commands

Everything runs from inside Claude Code via slash commands. Here's the highlight reel:

Development

Command	What it does
/mastermind:autodev	Autonomous research → build → review loop
/mastermind:build	Build a feature from a brief
/mastermind:review	Iterative review until zero findings
/mastermind:debug	Systematic root-cause debugging
/mastermind:tdd	Red → Green → Refactor
/mastermind:architect	Architecture review + file structure
/mastermind:plan	Comprehensive implementation plan
/mastermind:worktree	Feature work in isolated git worktree

Organizations

Command	What it does
monomind org run <name>	Start an org as a real SDK-backed daemon
monomind org status / list	Runtime state for one or all orgs
monomind org stop <name>	Request a graceful stop
/mastermind:approve	Action pending approval requests

Business Domains

Command	What it does
/mastermind:marketing	Campaigns, copy, SEO, social
/mastermind:content	Blog posts, threads, newsletters
/mastermind:sales	Outreach, proposals, pipeline
/mastermind:finance	Budgets, invoicing, modeling
/mastermind:ops	Operations and workflow automation

→ Full reference (60+ commands)

---

📦 Packages

Package	npm	Purpose
monomind	npm	Umbrella — install this one
@monoes/monomindcli	npm	CLI engine (31 commands)
monofence-ai	npm	AI manipulation defence
@monoes/monograph	npm	Code knowledge graph

---

🏗️ How It's Built

graph TD
    CC["Claude Code"]
    MCP["MCP Server\nmonomind mcp start"]
    D["Background Workers\n(@monomind/hooks, in-process)"]
    ORG["OrgDaemon\nmonomind org run\nreal SDK sessions"]

    CC <-->|"MCP tools: monograph, memory"| MCP
    MCP <--> D

    D --> ADB[("Memory store\npatterns + episodes")]
    D --> MG[("Monograph\ncode graph")]
    D --> HK["Hooks\n29 subcommands"]

    CC -->|"Task tool - spawns agents"| AG["In-session agents\narchitect, coder\ntester, reviewer\nsecurity, perf"]
    AG <-->|reads and writes| ADB
    ORG -->|"spawns, policy-gated"| RA["Role agents"]
    ORG <-->|reads and writes| ADB

    style CC fill:#00D2AA22,stroke:#00D2AA
    style AG fill:#8B5CF622,stroke:#8B5CF6
    style ADB fill:#F59E0B22,stroke:#F59E0B
    style ORG fill:#F59E0B22,stroke:#F59E0B

Claude Code's Task tool drives in-session multi-agent work; monomind org run drives persistent background orgs. Your data never leaves your machine.

---

Resources

• 📖 Full Documentation
• 🏢 Autonomous Orgs
• ⚡ Mastermind Reference
• 📋 All Slash Commands
• 🐛 Issues
• 💬 Discussions

---

_{Built with ♥ by monoes · MIT License}