Monomind

Hire an AI team. Set a goal. Walk away.
Autonomous Claude Code orchestration with persistent memory, self-coordinating agent orgs, and a codebase knowledge graph.

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

What is Monomind?

Claude Code is already powerful. Monomind makes it run itself.

Install once. Wire it into Claude Code. Then instead of prompting Claude to do individual tasks, you tell Monomind what outcome you want — and it assembles a team, coordinates the work, and delivers.

# Assemble an AI content team and let it run
/mastermind:createorg content-team "publish 3 SEO-optimized posts per week"
/mastermind:runorg --org content-team

# Or run the autonomous code improvement loop
/mastermind:autodev --tillend --focus security

That's it. Come back later.

🏢 Autonomous Organizations

This is the headline feature. Build a persistent AI organization — roles, hierarchy, shared task board — and start it as a background daemon that runs without you.

The idea

Every business function needs a team. Monomind lets you design that team in one command, then run it forever. The org persists across sessions. It checkpoints, recovers from failures, and coordinates its agents through a shared task board — all automatically.

flowchart TD
    U(["You"])
    CO["/mastermind:createorg\nDefine goal + roles"]
    RO["/mastermind:runorg\nStart daemon"]
    BOSS["Boss Agent\ncoordinator"]
    W["Writer\nContent Creator"]
    S["SEO Specialist"]
    R["Reviewer"]
    M["Growth Marketer"]
    BOARD[("Shared\nTask Board")]
    MEM[("AgentDB\nMemory")]

    U --> CO --> RO --> BOSS
    BOSS -->|spawns| W
    BOSS -->|spawns| S
    BOSS -->|spawns| R
    BOSS -->|spawns| M
    BOSS <-->|claims + reports| BOARD
    W <-->|stores output| MEM
    S <-->|reads context| MEM

    style BOSS fill:#00D2AA22,stroke:#00D2AA
    style BOARD fill:#F59E0B22,stroke:#F59E0B
    style MEM fill:#8B5CF622,stroke:#8B5CF6

Two commands to a running org

Step 1 — Design it:

/ mastermind:createorg content-team
  "Build and publish 3 blog posts per week on AI dev tools"

Deriving roles from goal...

╔ ORG: content-team
║ TOPOLOGY: star (5 roles)

  boss      → coordinator
  writer    → Content Creator
  reviewer  → reviewer
  marketer  → Growth Hacker
  seo       → SEO Specialist

Type "go" to save, or describe changes.
→ go

✓ Saved .monomind/orgs/content-team.json
  → Run: /mastermind:runorg --org content-team

Step 2 — Start it:

/mastermind:runorg --org content-team

# Boss agent spawns in background
# Coordinates all roles via shared task board
# Checkpoints every 30 minutes
# Loops until you stop it

What runs under the hood

Topology is auto-derived

graph LR
    A["1-3 roles"] -->|mesh| B["All-to-all\ndirect comms"]
    C["4-6 roles"] -->|star| D["Boss to workers\nfan-out"]
    E["7+ roles"] -->|hierarchical| F["Boss to leads to workers\nmiddle management"]

Org management commands

/mastermind:createorg <name> "<goal>"   # design org from a goal
/mastermind:runorg --org <name>         # start as background daemon
/mastermind:orgs                        # list all orgs + status
/mastermind:orgstatus --org <name>      # detailed status for one org
/mastermind:stoporg --org <name>        # stop a running org
/mastermind:approve                     # review pending approval requests

⚡ 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

🚀 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. Start the background daemon
monomind daemon start

# 5. Health check
monomind doctor --fix

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

/mastermind:autodev --tillend     # start autonomous code loop
/mastermind:createorg my-team     # create your first AI org
/mastermind:help                  # show all commands

🧠 Memory That Persists

Every session, every agent, every org writes to AgentDB — a hybrid SQLite + HNSW vector store 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\nAgentDB + HNSW index\nSemantic search"]
    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()"

23 MCP tools. Impact analysis. Shortest-path queries. Community detection. Zero grep.

🎣 Hooks & Workers

Monomind wires 22 hook events into Claude Code. Every edit, task, command, and session fires hooks that log patterns, route agents, and train 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[("AgentDB\npatterns.json")]
    DB -->|next session| CE

12 background workers run continuously: 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

📋 80+ Slash Commands

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

Development

Organizations

Business Domains

→ Full reference (80+ commands)

📦 Packages

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

🏗️ How It's Built

graph TD
    CC["Claude Code"]
    MCP["MCP Server\nmonomind mcp start"]
    D["Background Daemon\n12 workers"]

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

    D --> ADB[("AgentDB\nSQLite + HNSW")]
    D --> MG[("Monograph\ncode graph")]
    D --> HK["Hooks\n22 event types"]
    D --> SW["Swarm\n6 topologies\n5 consensus algos"]

    CC -->|"Task tool - spawns agents"| AG["Agent Swarm\narchitect, coder\ntester, reviewer\nsecurity, perf"]
    AG <-->|reads and writes| ADB

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

Claude Code handles all execution. MCP tools only coordinate. Your data never leaves your machine.

Resources

• 📖 Full Documentation
• 🏢 Autonomous Orgs
• ⚡ Mastermind Reference
• 📋 All Slash Commands
• 🐛 Issues
• 💬 Discussions
• 📦 Changelog v1.11

_{Built with ♥ by monoes · MIT License}