🐝 Hive

Orchestrate AI coding agents through phased development pipelines.

One dashboard. All your jobs, phases, and agent activity.

You describe a task, pick a repo and an AI agent, and Hive runs it through a configurable pipeline — explore → design → PRD → implement → review → fix → PR. At each gate you review the output, add inline feedback, and approve or ask for a redo. Multiple jobs run in parallel across repos, each in its own git worktree.

• 🔀 Phased pipelines — 7 default phases from exploration to PR, fully configurable
• 🤖 Agent-agnostic — Claude Code, Codex, or any ACP-compatible agent
• 🌿 Git worktree isolation — each job gets its own branch and worktree
• 💬 Inline feedback — click any line in the agent's output to add a comment, then redo
• 📊 Web dashboard — real-time progress, markdown/diff rendering, approval gates
• ⚡ Single binary — Go backend with embedded React frontend, nothing else to install

---

Install

Requires Go 1.24+ and bun (for building the frontend).

git clone <repo-url> hive
cd hive
make install    # builds frontend + backend, copies to ~/bin/

Make sure ~/bin is on your PATH.

Quick Start

# 1. Add your repos
hive config repos

# 2. Set up pipelines and agents
hive config pipelines

# 3. Start the daemon — opens the web UI in your browser
hive start

Once the dashboard opens, click New Job to create your first pipeline run.

Config

Location: ~/.config/hive/

repos.yaml

repos:
  - name: agent
    path: ~/code/my-project
    default_branch: main
    workdir: packages/agent      # optional subdirectory
    prepare:                     # run before creating worktree
      - git checkout main
      - git pull
    setup:                       # run inside new worktree
      - bun install
      - bun run codegen

pipeline.yaml

pipelines:
  full:
    description: "Full dev workflow"
    phases:
      - name: start
        skill: ~/.skills/dev1-start
        outputs: [tmp_context.md, tmp_exploration.md]
        gate: none

      - name: design
        skill: ~/.skills/dev2-design
        outputs: [design.md]
        gate: approval

      - name: prd
        skill: ~/.skills/dev3-prd
        outputs: [prd.md]
        gate: approval

      - name: implement
        skill: ~/.skills/dev4-implement
        outputs: [tmp_impl_plan.md]
        output_type: diff
        gate: approval

      - name: review
        skill: ~/.skills/dev5-review
        outputs: [tmp_review.md]
        gate: auto

      - name: review-fix
        skill: ~/.skills/dev6-review-fix
        skip_when: "no critical or suggestion comments"
        gate: none

      - name: pr
        skill: ~/.skills/dev7-pr
        outputs: [tmp_done.md]
        gate: none

  yolo:
    description: "No approval gates — fully autonomous"
    phases: [...]

config.yaml

server:
  port: 4800
  idle_timeout: 30m

agents:
  claude:
    command: "acpx claude"
  codex:
    command: "acpx codex"

defaults:
  agent: claude
  pipeline: full

CLI

hive start                                    # launch daemon + open web UI
hive stop                                     # graceful shutdown

hive new "build chat UI" --repo agent         # create a new job
  --agent claude                              # agent to use
  --pipeline full                             # pipeline preset
  --context src/Chat.tsx,src/hooks.ts         # context files

hive status                                   # list all jobs
hive status agent/0327-chat-ui                # detail for one job

hive approve agent/0327-chat-ui               # approve current gate
hive skip agent/0327-chat-ui                  # skip current phase
hive retry agent/0327-chat-ui                 # retry failed phase

hive logs agent/0327-chat-ui                  # tail agent output
hive logs agent/0327-chat-ui --phase design   # output for specific phase

hive open                                     # open web UI in browser
hive done agent/0327-chat-ui                  # mark finished, remove worktree

hive config                                   # open config dir in $EDITOR
hive version                                  # print version

Web Dashboard

The dashboard runs at http://localhost:4800 and provides:

View	What it does
Job list	All active jobs with phase progress and status badges
Phase output	Rendered markdown or syntax-highlighted diff for each phase
Inline comments	Click any line to add feedback — collected and sent on redo
New job form	Task description, repo/agent/pipeline selectors, @ file picker
Agent stream	Live activity feed from the running agent via WebSocket

Gate actions

When a phase reaches an approval gate:

Action	Effect
Approve	Mark complete, advance to next phase
Redo	Collect inline comments + general feedback, re-run the phase
Skip	Skip this phase, advance to next

How It Works

Jobs are the unit of work. Each job targets one repo, one agent, and one pipeline.

Phases are steps in the pipeline. Each phase is defined by a SKILL.md file — a markdown prompt with frontmatter. The orchestrator reads the skill, interpolates the task context, and sends it to the agent.

Worktrees isolate each job. Hive creates a git worktree at <repo>/.hive/worktrees/<feature>/, runs your setup commands, and points the agent at it.

Artifacts are stored at ~/.local/share/hive/jobs/<repo>/<feature>/. Each phase writes its output there — markdown docs, review comments, implementation plans. The manifest tracks job state across restarts.

Agents are executed via ACPX for session persistence across phases, or as direct subprocesses (claude -p, codex --exec) for simpler setups.

Human → New Job → Worktree created → Phase 1 (agent runs skill)
                                    → Phase 2 (agent runs skill) → Gate → Human reviews
                                    → Phase 3 ...                        → Approve / Redo
                                    → Phase 7 (PR created)       ← ←  ← ← ←

Architecture

┌─ CLI ──────────────────────────┐
│ hive new / status / approve    │
└────────────┬───────────────────┘
             │ HTTP
┌────────────▼───────────────────┐
│ Go Backend (on-demand daemon)  │
│  Job Manager · Worktree Mgr   │
│  Agent Runner · Phase Pipeline │
│  WebSocket Hub · REST API      │
└────────────┬───────────────────┘
             │ WebSocket
┌────────────▼───────────────────┐
│ React Frontend (embedded)      │
│  Job List · Phase Output       │
│  Inline Comments · Diff Viewer │
│  File Picker · Agent Stream    │
└────────────────────────────────┘

Single binary — the React frontend is embedded via go:embed at build time.

Project Structure

hive/
├── cmd/hive/              # CLI commands (cobra)
├── internal/
│   ├── server/            # HTTP + WebSocket server
│   ├── job/               # Job lifecycle + manifest
│   ├── agent/             # Runner interface + adapters
│   ├── worktree/          # Git worktree operations
│   ├── pipeline/          # Phase execution
│   ├── config/            # Config loading
│   └── skill/             # SKILL.md parsing
├── web/                   # React frontend (Vite)
│   └── src/components/    # UI components
├── embed.go               # go:embed for frontend
├── Makefile
└── SPEC.md                # Full design specification

---

Hive is a personal tool built for orchestrating AI agents across development workflows. The full design specification is in SPEC.md.