Skip to content
/
Tier B A6 Multi-agent orchestrator

Hive (aden-hive)

hive-aden · aden-hive/hive · ★ 10k · last commit 2026-05-22

Primitive shape 108 total
Skills 3 Subagents 2 Hooks 1 MCP tools 102
00

Summary

Hive (aden-hive) — Summary

OpenHive (aden-hive/hive) is a Python/TypeScript multi-agent execution harness from Aden (YC W25) with 10k+ stars, designed for production business-process automation rather than ad-hoc scripting. It provides a zero-setup, model-agnostic runtime that compiles a natural-language goal into a strict, graph-based execution DAG of specialized worker agents; the DAG evolves when tasks fail, enabling self-healing workflows. The stack has three layers: a core/ Python framework (agent loop, orchestrator, server, observability), a tools/ MCP server with 102 tools (browsing, filesystem, code execution, integrations), and a React/TypeScript web UI (core/frontend/) served at localhost that functions as the agent control plane — users write goals in a chat box and the "queen" agent designs + executes the agent graph. The framework ships three Claude Code skills (triage-issue, test-reporting, browser-edge-cases) and one PostToolUse hook (auto-linting via ruff) indicating active dogfooding. Persistent role-based memory is stored per-agent-session in JSON; the queen agent tracks graph state, worker outputs, and cost. Compared to the seeds, Hive is closest to claude-flow (both are multi-agent harnesses with observable DAG execution) but Hive uniquely auto-generates the DAG from a goal description rather than requiring the user to define workflow nodes manually.

01

Overview

Hive (aden-hive) — Overview

Origin

Built by Aden (YC W25, previously Acho); Timothy Drury is the lead developer (CLAUDE.md references local paths with /home/timothy/aden/hive). The project is positioned as the production runtime layer for multi-agent business automation.

Philosophy

From the README:

"OpenHive is a zero-setup, model-agnostic execution harness that dynamically generates multi-agent topologies to tackle complex, long-running business workflows without requiring any orchestration boilerplate."

"By simply defining your objective, the runtime compiles a strict, graph-based execution DAG that safely coordinates specialized agents to execute concurrent tasks in parallel."

"As models improve, the upper bound of what agents can do rises — but their reliability and production value are determined by the harness."

The core manifesto: you describe outcomes, and the system builds itself. The queen agent is the architect; worker agents are executors; the harness is the production guarantee.

Design pillars

  1. Goal-driven topology generation: natural language goal → queen agent → execution DAG
  2. Self-healing: if a worker fails, the graph evolves (tasks retry or re-decompose)
  3. State persistence: role-based memory per agent, per session, per project
  4. Full observability: real-time metrics, budget enforcement, audit trails
  5. Human-in-the-loop: pause points, cost limits, approval gates
  6. Model-agnostic: LiteLLM-backed; Anthropic, OpenAI, Google, OpenRouter, Hive LLM

Metaphor

The badge line reads: "The agent harness for production workloads." The queen/worker terminology is explicit: the queen is a supervisor agent that designs and manages the hive's task graph; workers execute nodes.

HoneyComb companion

honeycomb.open-hive.com is a "stock market for jobs" where community agents compete to automate professions — a public leaderboard for agent capability benchmarking.

02

Architecture

Hive (aden-hive) — Architecture

Distribution

  • Type: standalone-repo (clone + quickstart script; not pip-installable as a package)
  • Install: ./quickstart.sh (macOS/Linux) or .\quickstart.ps1 (Windows)
  • Required runtime: Python 3.11+, uv workspace
  • License: Apache-2.0

Repository structure

hive/
  core/               # Python agent framework + web UI
    framework/        # Core runtime
      agent_loop/     # Agent execution loop
      agents/         # Queen + worker agent definitions
        queen/        # Queen agent nodes
      cli.py          # Framework CLI
      config.py       # LiteLLM configuration
      host/           # Process manager
      llm/            # LLM provider adapters
      observability/  # Metrics, traces
      orchestrator/   # Graph orchestrator
      pipeline/       # Task pipeline
      runtime/        # Execution runtime
      server/         # FastAPI server
      skills/         # Internal skills system
      storage/        # Session/memory storage
      tools/          # Tool implementations
    frontend/         # React/TypeScript web UI
  tools/              # MCP tool server
    src/aden_tools/   # 102 MCP tools
      tools/          # Tool category folders
  hive/               # CLI wrapper scripts
    hive.sh / hive.ps1
  .claude/            # Claude Code settings + skills
    settings.json     # PostToolUse hook (ruff)
    skills/           # 3 Claude Code skills
  quickstart.sh       # Setup script

Key framework modules

Module Purpose
framework/agents/queen/ Queen agent: goal → DAG generation
framework/orchestrator/ Graph-based DAG executor
framework/agent_loop/ Per-worker agent execution loop
framework/storage/ Session state (JSON)
framework/observability/ Metrics, budget tracking
framework/server/ FastAPI server for web UI
core/frontend/ React UI (TypeScript)

MCP tool server (tools/)

  • 102 tools via aden_tools package
  • Includes: browser control, filesystem, code execution, API integrations
  • Served as MCP server connected to worker agents

LLM providers (via LiteLLM)

Anthropic, OpenAI, OpenRouter, Google Gemini, Hive LLM (custom), any OpenRouter-compatible provider.

Web UI

React/TypeScript frontend at core/frontend/. Served by FastAPI at localhost (port inferred from quickstart.sh). Interface includes: agent graph view, run monitoring, template library, cost tracking.

03

Components

Hive (aden-hive) — Components

Claude Code Skills (.claude/skills/)

Name Purpose
triage-issue Analyze a GitHub issue, verify claims against codebase, close invalid issues with technical response
test-reporting Generate structured test reports
browser-edge-cases Handle browser automation edge cases

Claude Code Hooks (.claude/settings.json)

Event Matcher Command
PostToolUse Edit|Write|NotebookEdit ruff check --fix "$CLAUDE_FILE_PATH"; ruff format "$CLAUDE_FILE_PATH"

Framework agent types

Agent Role
Queen agent Goal intake → DAG generation → worker coordination → synthesis
Worker agents Execute individual DAG nodes (specialized by task type)

MCP tools (102 total, from aden_tools)

Categories observed:

  • Browser automation (GCU browser tools: browser_navigate, browser_screenshot, browser_click_coordinate, browser_type_focused, browser_evaluate, browser_wait, browser_open, browser_status, browser_get_rect)
  • Filesystem operations
  • Code execution
  • API integrations

Core framework primitives

Name Type Purpose
AgentContext class Per-agent execution context
AgentLoop class Worker agent run loop
Orchestrator class Graph-based DAG executor
QueenLifecycleTools class Queen agent lifecycle management
TaskPipeline class Task queuing and routing
ConversationStore class Session message persistence
HiveCredentials class Encrypted API key store (~/.hive/credentials)

Template agents

The examples/ directory and web UI template library include pre-built agent templates for common business processes (brand design, coding, research, etc.).

CLI

hive shell script (wraps core/framework/cli.py). Commands include hive open (launch web UI).

05

Prompts

Hive (aden-hive) — Prompts

Verbatim: triage-issue SKILL.md (excerpt)

## Workflow

### Step 1: Fetch Issue Details
```bash
gh issue view <number> --repo adenhq/hive --json title,body,state,labels,author

Step 4: Evaluate Validity

Categorize the issue as one of:

Category Action
Valid Bug Do NOT close. Inform user this is a real issue.
Valid Feature Request Do NOT close. Suggest labeling appropriately.
Misunderstanding Prepare technical explanation for why behavior is correct.
Fundamentally Flawed Prepare critique explaining the technical impossibility.
Duplicate Find the original issue and prepare duplicate notice.

Step 5: Draft Response

For issues to be closed, draft a response that:

  1. Acknowledges the concern — Don't be dismissive
  2. Explains the actual behavior — With code references
  3. Provides technical rationale — Why it works this way
  4. References industry standards — If applicable
  5. Offers alternatives — If there's a better approach for the user

**Technique**: Structured workflow with categorization table + response template. Uses a "judgment tree" pattern where the agent must classify before acting — prevents premature closure of valid issues.

## Verbatim: CLAUDE.md context injection for Conductor

```markdown
## Conductor Notes
When working in Conductor, you can use the `.context/` directory for scratch notes 
or agent-to-agent handoff artifacts. This directory is gitignored.

Technique: Cross-agent handoff via shared filesystem artifact. The .context/ directory is a designated scratch space for agent-to-agent communication in a multi-agent environment.

Queen agent prompt pattern (inferred from framework)

The queen agent receives the user's natural language goal + available worker agent capabilities, then generates a structured DAG definition. The exact prompt template is internal to core/framework/agents/queen/nodes/, but the output format is JSON with node types, dependencies, and agent assignments.

09

Uniqueness

Hive (aden-hive) — Uniqueness

Differs from seeds

Most similar to claude-flow (both are multi-agent harnesses with DAG execution and observable runs), but with two critical differences: (1) Hive automatically generates the agent topology from a natural language goal — the user never writes workflow definitions or agent graphs; (2) Hive has a built-in React web UI as the primary interaction surface, while claude-flow is CLI-only. Unlike superpowers or BMAD-METHOD (skill-based behavioral frameworks), Hive is a runtime environment not a CLAUDE.md augmentation. The closest structural analog is taskmaster-ai (both decompose goals into tasks and track completion), but Hive's graph is a live DAG with concurrent execution and self-healing, not a sequential task file.

Positioning

Hive targets the gap between "agent scripting" and "business process automation platform." It is the only framework in this batch with a consumer-grade web UI as the primary interface rather than code or CLI.

Distinctive features

  1. Automatic DAG generation: goal description → agent graph, no manual definition
  2. Self-healing graph: failed nodes trigger create_colony (subtree re-generation), not just retry
  3. 102 MCP tools bundled in aden_tools: the largest bundled tool count of any framework in this batch
  4. HoneyComb: a public leaderboard where community agents compete to automate job categories — unique gamification of agent capability
  5. Browser automation via GCU (General Compute Use) — native browser control tools in the MCP server
  6. Encrypted credential store at ~/.hive/credentials — cross-agent secret management

Observable failure modes

  1. No pip install: requires uv workspace + git clone; higher setup friction than pip-installable peers
  2. Queen agent bottleneck: all decisions route through the queen; if the queen's model is slow or expensive, the entire workflow slows
  3. Graph quality depends on model: weak models generate poor DAGs; no fallback mechanism described
  4. Cost visibility: budget enforcement is present but limits are user-defined; accidental runaway execution possible without explicit limits
  5. Windows support: marked as "supported via PowerShell" but community issues suggest rough edges
04

Workflow

Hive (aden-hive) — Workflow

Primary workflow (web UI path)

Phase Artifact
1. User types goal in web UI chat box Natural language objective
2. Queen agent interviews user for clarification Clarified requirements
3. Queen generates agent graph (DAG) Graph definition (JSON)
4. Worker agents execute DAG nodes concurrently Node outputs
5. Failed nodes trigger graph evolution (retry/redecompose) Updated DAG
6. Queen synthesizes final result Delivered outcome

Template agent path

Phase Artifact
1. Select template from UI Agent config
2. Click Run Execution started
3. Monitor in real-time Live graph status

Self-healing loop

flowchart: EXEC → CHECK → (Pass → DONE) or (Fail → EVOLVE → EXEC)

Failed tasks are captured, analyzed, and the graph is modified before re-execution. No human intervention required.

Approval gates

  • Cost limits: configurable budget enforcement
  • Human-in-the-loop: pause points in the graph where human confirmation is required
  • Credential prompts: at setup, quickstart.sh prompts for API keys (stored encrypted in ~/.hive/credentials)

Phases

  1. Define Goal — natural language in web UI
  2. Coding Agent Generates — queen creates graph, connection code, test cases
  3. Workers Execute — SDK-wrapped nodes run with tool access
  4. Control Plane Monitors — real-time metrics, budget enforcement
  5. Evolve — failed nodes trigger graph evolution
  6. Deliver — final result returned to user

Context window management

Session messages stored in ConversationStore; long contexts are truncated/summarized before sending to LLM (queen handles compression).

06

Memory Context

Hive (aden-hive) — Memory & Context

Memory architecture

Layer Storage Scope
Session messages ConversationStore (JSON files in ~/.hive/agents/) Per-session
Agent memory Role-based JSON files per agent Per-agent
Credentials Encrypted key store (~/.hive/credentials) Global
Graph state In-memory + JSON Per-run

Session storage

Observed from .claude/settings.json file path references:

~/.hive/agents/queens/<agent_name>/sessions/session_<timestamp>_<id>/

Each session directory contains JSON files with message history, graph state, and run metadata.

Skill storage

~/.hive/skills/        # User-defined skills
~/.hive/backup/        # Skill backups (SKILL.md files)

Context injection

The queen agent's system prompt is dynamically built from:

  1. User goal
  2. Available worker agent capabilities
  3. Session history (with compression for long sessions)
  4. Current graph state
  5. Budget/cost constraints

Cross-session handoff

The queen agent can reference previous session artifacts when picking up a paused workflow. The .context/ directory (from CLAUDE.md) serves as a cross-agent handoff zone.

Memory persistence

Session-scoped: each run creates a new session directory; historical sessions are queryable but not automatically injected.

Compaction

Long message histories are truncated/summarized before LLM calls. _is_context_too_large_error in agent_loop.py handles overflow detection.

07

Orchestration

Hive (aden-hive) — Orchestration

Multi-agent

Yes. Queen + workers architecture; parallel worker execution via run_parallel_workers.

Orchestration pattern

hierarchical — queen supervises workers; parallel-fan-out within the graph (concurrent node execution).

The flow is: goal → queen decomposes → DAG generated → workers execute nodes concurrently → queen monitors and evolves graph on failure.

DAG execution

The Orchestrator module runs a graph-based DAG:

  • Nodes are agent tasks
  • Edges are dependencies
  • Parallel-eligible nodes execute concurrently
  • Failed nodes trigger create_colony (graph re-generation for that subtree)

Max concurrent agents

Unknown (limited by LiteLLM rate limits and asyncio; no hard cap exposed in SDK).

Isolation mechanism

Process-level: worker agents run as separate async coroutines. For General Compute Use (GCU) browser tasks, a browser process is isolated. No container isolation for Python agents.

Multi-model

Yes. Per-agent model configuration:

  • Queen: typically a capable model (claude-sonnet or gpt-5)
  • Workers: can be configured with lighter models
  • OpenRouter support allows mixing providers

Execution mode

continuous-ralph — the queen agent loops until the goal is achieved or budget is exhausted. Workers execute in event-driven fashion triggered by DAG node readiness.

Crash recovery

_is_context_too_large_error handles context overflow. Session state is persisted to JSON; partial runs can be resumed.

Consensus

None — queen is the authority; no consensus mechanism among workers.

Prompt chaining

Yes — each worker node's output is captured and injected as context into dependent downstream nodes. The queen synthesizes all outputs.

Streaming output

Yes — web UI receives real-time updates via SSE from the FastAPI server.

08

Ui Cli Surface

Hive (aden-hive) — UI & CLI Surface

CLI binary

hive — shell script wrapper around core/framework/cli.py.

Key subcommands:

  • hive open — launch web UI in browser
  • hive run — run an agent (inferred)
  • Quickstart setup via ./quickstart.sh (interactive credential + model setup)

Not a standalone binary; requires the repo to be cloned and uv workspace set up.

Local web dashboard

Yes — React/TypeScript frontend at core/frontend/.

Port: Unknown from public source (set in FastAPI server config; quickstart.sh opens it in the browser).

Tech stack: React + TypeScript (Bun for bundling, inferred from .claude/settings.json bun run:* permission).

Features:

  • Goal input (chat box)
  • Agent graph visualization (real-time DAG view)
  • Run monitoring (node status, cost tracking)
  • Template library (pre-built agent templates)
  • Human-in-the-loop approval UI
  • Budget enforcement display

IDE integration

Claude Code integration (.claude/):

  • settings.json — PostToolUse hook, permission allowlist
  • skills/triage-issue/ — GitHub issue triage skill
  • skills/test-reporting/ — Test report generation skill
  • skills/browser-edge-cases/ — Browser automation skill

MCP integration

The tools/ MCP server exposes 102 tools to worker agents:

  • Connected via ~/.hive/ MCP config (.mcp.json in core/)
  • Includes browser automation tools (gcu-tools server)

Observability

  • Real-time metrics in web UI
  • Budget enforcement (cost limits per run)
  • Audit trail: session files in ~/.hive/agents/*/sessions/
  • framework/observability/ module for metrics/traces

Related frameworks

same archetype · same primary tool · same memory type

Claude-Flow / Ruflo ★ 55k
A6 Multi-agent orchestrator

Eliminates single-agent context limits and sequential bottlenecks by orchestrating fault-tolerant swarms of specialized AI agents…

Hermes Agent (NousResearch) ★ 168k
A6 Multi-agent orchestrator

Self-improving personal AI agent with closed learning loop, 7 terminal backends, and messaging gateway — not tied to any AI…

OpenCode ★ 165k
A6 Multi-agent orchestrator

Terminal-first AI coding agent with multi-model routing, native desktop app, and a typed .opencode/ configuration system for…

OpenHands ★ 75k
A6 Multi-agent orchestrator

Open-source AI software development platform (open-source Devin alternative) with Docker sandbox isolation, 77.6% SWE-bench…

DeerFlow ★ 70k
A6 Multi-agent orchestrator

Long-horizon superagent that researches, codes, and creates by orchestrating parallel sub-agents with isolated contexts in Docker…

oh-my-openagent (omo) ★ 60k
A6 Multi-agent orchestrator

Multi-provider AI agent orchestration for OpenCode: escape vendor lock-in by routing Sisyphus (Claude/Kimi/GLM) and Hephaestus…