convez.ai
MCP ServerAutomaçãoAvançado
nokhodian

Monomind - Orquestração de Agentes IA Autônomos

nokhodian/monomind

Crie equipes IA autônomas que trabalham sem supervisão em background

Ver no GitHub
InicialPluginScore · de 0 a 100

MCP server que permite criar e orquestrar equipes de agentes IA especializados (60+) que trabalham de forma autônoma e coordenada. Implementa memória persistente, grafo de conhecimento de codebase e auto-aprendizado para automação enterprise de tarefas complexas em Claude Code.

Instalação

$npx convez-ai nokhodian/monomind

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
57%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Orquestração de múltiplos agentes para projetos de desenvolvimento de software
  • Automação de pipelines de conteúdo com especialistas em SEO, escrita e revisão
  • Loops de melhoria contínua de código focados em segurança ou performance
  • Coordenação de tarefas complexas via quadro de tarefas compartilhado entre agentes

Veredito

Solução robusta para quem precisa de orquestração enterprise de agentes IA em produção. A abordagem de organizações persistentes com memória vetorial e recuperação de falhas é madura, mas exige experiência em arquitetura de sistemas distribuídos.

README

A tradução para o português deste README ainda está na fila.


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

WhatHow
Boss agentCoordinator type, no supervisor — owns the goal
Role agentsSpawned on demand, specialized by task type
Task boardTodo → Doing → Done, shared across all agents
MemoryAll output stored in org-scoped AgentDB namespace
CheckpointState saved every 30 min — survives crashes and restarts
Governanceauto (free), board (approve sensitive), strict (approve all external actions)

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"]

Pre-built org types

OrgGoalRoles
content-team3 posts/week on AI toolsDirector · Writer · Reviewer · SEO · Growth
dev-squadFeatures from design specLead · Architect · Developer · QA
research-labWeekly competitive intelligenceDirector · Researcher · Analyst · Writer
sales-engineICP research + outreach sequencesDirector · Outbound · Email · Researcher
ops-squad24/7 monitoring + incident responseSRE · Security · Perf · Incident Cmdr

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

FlagPurpose
--tillendRepeat until empty round (zero findings, zero actions)
--repeat <N>Repeat exactly N times
--focus <area>Bias toward: security · dx · performance
--autoNo 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. 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

CommandWhat it does
/mastermind:autodevAutonomous research → build → review loop
/mastermind:buildBuild a feature from a brief
/mastermind:reviewIterative review until zero findings
/mastermind:debugSystematic root-cause debugging
/mastermind:tddRed → Green → Refactor
/mastermind:architectArchitecture review + file structure
/mastermind:planComprehensive implementation plan
/mastermind:worktreeFeature work in isolated git worktree

Organizations

CommandWhat it does
/mastermind:createorgDesign an autonomous agent org
/mastermind:runorgStart it as a background daemon
/mastermind:orgsList all orgs + status
/mastermind:approveAction pending approval requests

Business Domains

CommandWhat it does
/mastermind:marketingCampaigns, copy, SEO, social
/mastermind:contentBlog posts, threads, newsletters
/mastermind:salesOutreach, proposals, pipeline
/mastermind:financeBudgets, invoicing, modeling
/mastermind:opsOperations and workflow automation

→ Full reference (80+ commands)


📦 Packages

PackagenpmPurpose
monomindnpmUmbrella — install this one
@monoes/monomindclinpmCLI engine (41 commands)
monofence-ainpmAI manipulation defence
@monoes/monographnpmCode 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


Ver o original no GitHub

Bom para

Relacionados