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.
```bash
# 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.
```mermaid
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[("Persistent\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:**
```bash
/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
| What | How |
|---|---|
| **Boss agent** | Coordinator type, no supervisor β owns the goal |
| **Role agents** | Spawned on demand, specialized by task type |
| **Task board** | Todo β Doing β Done, shared across all agents |
| **Memory** | All output stored in an org-scoped memory namespace |
| **Checkpoint** | State saved every 30 min β survives crashes and restarts |
| **Governance** | `auto` (free), `board` (approve sensitive), `strict` (approve all external actions) |
### Topology is auto-derived
```mermaid
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
```bash
/mastermind:createorg "" # design org from a goal
/mastermind:runorg --org # start as background daemon
/mastermind:orgs # list all orgs + status
/mastermind:orgstatus --org # detailed status for one org
/mastermind:stoporg --org # 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.
```mermaid
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
```
```bash
/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 ` | Repeat exactly N times |
| `--focus ` | Bias toward: `security` Β· `dx` Β· `performance` |
| `--auto` | No confirmation prompts |
| `--maxruns ` | Safety cap (default 50) |
---
## π Quickstart
```bash
# 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 80+ slash commands available:
```bash
/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 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.
```mermaid
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
```
```bash
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.
```bash
/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 22 hook events into Claude Code. Every edit, task, command, and session fires hooks that log patterns, route agents, and train the intelligence system.
```mermaid
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.
```typescript
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
| 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 |
|---|---|
| `/mastermind:createorg` | Design an autonomous agent org |
| `/mastermind:runorg` | Start it as a background daemon |
| `/mastermind:orgs` | List all orgs + status |
| `/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 (80+ commands)](https://monoes.github.io/monomind/#slash)**
---
## π¦ Packages
| Package | npm | Purpose |
|---|---|---|
| `monomind` | [](https://www.npmjs.com/package/monomind) | Umbrella β **install this one** |
| `@monoes/monomindcli` | [](https://www.npmjs.com/package/@monoes/monomindcli) | CLI engine (31 commands) |
| `monofence-ai` | [](https://www.npmjs.com/package/monofence-ai) | AI manipulation defence |
| `@monoes/monograph` | [](https://www.npmjs.com/package/@monoes/monograph) | Code knowledge graph |
---
## ποΈ How It's Built
```mermaid
graph TD
CC["Claude Code"]
MCP["MCP Server\nmonomind mcp start"]
D["Background Workers\n(@monomind/hooks, in-process)"]
CC <-->|"MCP tools: monograph, memory, swarm"| MCP
MCP <--> D
D --> ADB[("Memory store\npatterns + episodes")]
D --> MG[("Monograph\ncode graph")]
D --> HK["Hooks\n22 event types"]
D --> SW["Swarm\n4 topologies\n3 consensus strategies"]
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](https://monoes.github.io/monomind/)
- π’ [Autonomous Orgs](https://monoes.github.io/monomind/#orgs)
- β‘ [Mastermind Reference](https://monoes.github.io/monomind/#mastermind)
- π [All Slash Commands](https://monoes.github.io/monomind/#slash)
- π [Issues](https://github.com/monoes/monomind/issues)
- π¬ [Discussions](https://github.com/monoes/monomind/discussions)
---
Built with β₯ by monoes Β· MIT License