🧠 Hivemind

One prompt. A full AI engineering team. Go lie on the couch.

Describe a feature in plain English. Hivemind deploys a PM, developers, reviewer, and QA — all working in parallel — and delivers tested, committed code. No babysitting. No copy-pasting. No "continue".

Website · Quick Start · How It Works · Architecture · Features · Dashboard · Agent Roster · Contributing

</div>

What is Hivemind?

Open-source AI engineering team that builds production code while you sleep

If Claude Code is a developer, Hivemind is the engineering team.

Hivemind is a Python orchestrator and React dashboard that turns AI coding agents into a full software engineering team. Give it one prompt — it plans the work, spins up specialist agents in parallel, passes artifacts between them, reviews the output, and commits tested code.

Under the hood: a LangGraph-based DAG executor, adaptive complexity triage, read-only code review, self-healing retry logic, and a single living DAG that grows dynamically as you send new messages.

Ship features, not prompts.

| Step | | Example | | --- | --- | --- | | 01 | Describe the feature | "Add JWT authentication with a login page and protected routes" | | 02 | Watch the team work | Triage → Architect → PM plans → Frontend + Backend + DB work in parallel → Tests → Review | | 03 | Get production code | Tested, reviewed, committed. Open your IDE and it's already there. |

COMING SOON: Template Marketplace — Download pre-built project DAGs and run them with one click. SaaS starters, API backends, full-stack apps — pick a template and let the team build it.

If it can write code, it's hired.

Hivemind is right for you if

✅ You want to describe a feature once and get production-ready code back
✅ You're tired of babysitting Claude Code — typing "continue", fixing context loss, managing files manually
✅ You want parallel execution — frontend, backend, and tests built simultaneously
✅ You want a read-only code review gate that critiques without breaking your code
✅ You want to monitor everything from your phone while lying on the couch
✅ You want self-healing — when an agent fails, the system fixes it automatically
✅ You want zero extra API costs — runs on your existing Claude Code subscription

⚡ How It Works

You: "Add user authentication with JWT tokens and a login page"
                    │
                    ▼
         ┌──────────────────┐
         │   Triage          │  Simple task? → Skip planning, execute directly
         │   (Adaptive)      │  Complex task? → Full pipeline below
         └────────┬─────────┘
                  │
         ┌────────▼─────────┐
         │  Architect Agent  │  Reviews codebase, identifies patterns,
         │  (Pre-planning)   │  produces architecture brief
         └────────┬─────────┘
                  │
         ┌────────▼─────────┐
         │    PM Agent       │  Creates TaskGraph (DAG) with dependencies,
         │    (Planning)     │  file scopes, and role assignments
         └────────┬─────────┘
                  │
         ┌────────▼─────────┐
         │   LangGraph DAG   │  Executes tasks in dependency order.
         │    Executor       │  Parallel where safe, sequential where needed.
         └────────┬─────────┘
                  │
    ┌─────────────┼─────────────┐
    ▼             ▼             ▼
┌────────┐  ┌────────┐  ┌────────┐
│Backend │  │Frontend│  │Database│   Writer agents serialized (write lock),
│  Dev   │  │  Dev   │  │ Expert │   reader agents run in parallel
└───┬────┘  └───┬────┘  └───┬────┘
    │           │           │
    └─────────┬─┘───────────┘
              ▼
    ┌──────────────────┐
    │   Test Engineer   │   Tests the combined output
    └────────┬─────────┘
             ▼
    ┌──────────────────┐
    │    Reviewer       │   Read-only critique (no code modification).
    │  (Code Review)    │   Automated lint/format with test safety net.
    └────────┬─────────┘
             ▼
        ✅ Committed & Ready

New message mid-execution? It gets injected into the live DAG — adding or cancelling tasks dynamically. There is always exactly one DAG per project. No parallel DAGs, no lost messages.

🏗️ Architecture

Core Pipeline

| Stage | Component | File | Description | |---|---|---|---| | Triage | _triage_is_simple() | orchestrator.py | Lightweight heuristic that routes simple tasks directly to a single-agent execution, skipping PM + Architect. Inspired by SEMAG adaptive complexity. | | Architect | ArchitectAgent | architect_agent.py | Pre-planning codebase review. Produces an ArchitectureBrief (patterns, conventions, key files) that the PM uses for better planning. | | PM | create_task_graph() | pm_agent.py | Decomposes the request into a TaskGraph — a DAG of typed TaskInput nodes with role assignments, file scopes, and dependency wiring. Task count scales with complexity (no forced minimums). | | DAG Executor | LangGraph StateGraph | dag_executor_langgraph.py | select_batch → execute_batch → post_batch → (loop). SQLite checkpointing for fault tolerance. Self-healing retry with failure classification. | | Review | Read-only critic | dag_executor_langgraph.py | ACC-Collab Critic pattern: reviewer reads code but never modifies it. Automated lint/format runs separately with a test-after-review safety net — reverts if tests break. | | Memory | update_project_memory() | memory_agent.py | Post-execution memory update. Lessons learned are injected into future PM prompts. |

Concurrency Model

| Mechanism | Description | |---|---| | Single DAG per project | New messages are injected into the live DAG (add/cancel tasks), never spawning a parallel DAG. Messages arriving during PM/Architect phase are buffered and drained when the graph is ready. | | Writer/Reader separation | Writer agents (code-modifying) run sequentially under a project write lock. Reader agents (analysis, research) run in parallel. | | Per-project write lock | asyncio.Lock in ProjectTaskQueue prevents concurrent file modifications within the same project directory. | | Cross-project parallelism | Different projects execute independently, bounded by DAG_MAX_CONCURRENT_GRAPHS. |

Dynamic DAG

The DAG is a living structure. While execution is in progress:

User sends a new message → PM decomposes it into additional tasks → tasks are injected into the live graph → executor picks them up in the next round
PM can cancel pending tasks → tasks that haven't started are removed, dangling dependencies are cleaned up
Self-healing adds remediation tasks → when a task fails, the executor creates a targeted fix task and adds it to the graph
select_batch re-evaluates every round → newly injected tasks are discovered via ready_tasks() and is_complete()

Typed Contract Protocol

Agents communicate via structured contracts, not free-form text:

TaskInput (goal, role, file_scope, depends_on, context_from)
    → Agent execution (two-phase: work + structured summary)
        → TaskOutput (status, artifacts, files_modified, handoff_notes)

Artifacts flow downstream through context_from wiring — a frontend agent automatically receives the API contract produced by the backend agent.

Self-Healing

| Signal | Detection | Response | |---|---|---| | Agent stuck | Text similarity > 85%, no file progress | Reassign → simplify → kill & respawn | | Task failure | Exit code, error classification | Targeted retry with failure context | | Circular delegation | Watchdog pattern detection | Break cycle, direct assignment | | Post-review regression | Tests fail after lint/format | git reset --hard to pre-review HEAD | | Rate limiting (429) | Per-agent circuit breaker | Exponential backoff, other agents continue |

⚡ Features

| | | | |---|---|---| | 🧩 LangGraph DAG Executor | Tasks execute in dependency order via a LangGraph StateGraph with SQLite checkpointing, self-healing retry, and dynamic task injection. | 🔄 Self-Healing Execution | Failed tasks are classified by failure type and retried with targeted fixes — not blind restarts. | | 🔀 Artifact Flow | Agents pass typed artifacts (API contracts, schemas, test reports) to downstream agents as structured context. | 🧠 Proactive Memory | The orchestrator injects lessons learned from past sessions to prevent repeating the same mistakes. | | 🛡️ Read-Only Code Review | Reviewer critiques code without modifying it (ACC-Collab pattern). Lint/format changes are reverted if they brea

Hivemind

Install / Use

README