Hive

Async multi-agent coding pipeline · open source

Turn a rough idea into a
merge-ready pull request

Hive runs your idea through a pipeline of agents — brainstorm, plan, execute, review, finalize — and ships the PR. No babysitting terminals or pull requests: tasks advance in parallel in the background, and your only job is to answer questions in a doc.

Install Hive See the 2-min demo View on GitHub

Free & open source (MIT). Power-user TUI — see if it's for you.

Watch the whole loop

A sub-two-minute reel: install, hive init, capture an idea in the TUI, answer brainstorm questions in vim, and archive the finished task once Hive has shipped it.

Sped up 1.5–3× so the loop fits in 91 seconds — open the MP4 (~5 MB).

How it works: nine stages, one task folder

Every task is a folder. Its location is the state — moving it to the next stage is the approval gesture, and each stage leaves a durable artefact the next one can trust. That practice is called compound engineering.

  1. 1inboxcapture

    Jot the rough idea — one sentence is enough.

  2. 2brainstormrefine

    An agent pins down what you actually want.

  3. 3plandesign

    Scope, implementation units, and risks get fixed.

  4. 4executebuild

    The code is written in an isolated feature worktree.

  5. 5open-prdraft PR

    The branch is pushed and a draft PR opened.

  6. 6reviewharden

    CI fixes, multi-agent review, triage, and fixes.

  7. 7artifactscollect

    Release and handoff artefacts are gathered.

  8. 8finalizepublish

    The PR body is refreshed and marked ready.

  9. 9donearchive

    The task is archived with cleanup commands.

What you get

Folder-as-agent transparency

No database, no black box. Every artefact — idea, brainstorm, plan, reviews, PR metadata — is a markdown file you can read, edit, or hand to another agent.

Multi-agent by design

Stages run on configurable agent CLIs — Claude by default, Codex, or Pi — so each step uses the model you trust for that job.

Async, parallel queue

The daemon advances many tasks at once in the background. The live TUI flags the one that needs an answer — answer in your editor, then get back to your day.

Patrol

Opt-in autonomous repo patrol maps feature slices, reviews them, validates fixes, and opens PRs for the ones that pass.

Babysitter

Keeps open PRs green and mergeable — runs bounded repair attempts and auto-rebases behind a moving main, then hands off when it's stuck.

Telegram bot

Capture ideas, check the queue, and approve work from your phone — photos, documents, and transcribed voice notes included.

It already ships real code

The reel above produced a real, public repository — ivankuznetsov/shipped — seeded with the one-sentence idea "a Telegram bot that sends a daily digest of what was shipped," driven through brainstorm → plan → execute → multi-agent review → finalize, and landed as PR #1.

Hive's own releases are built the same way — this site included.

Is Hive for you?

Hive is a terminal-first, token-heavy tool. Setup is light — hive init is a couple of prompts — so the one thing to weigh before you start is token cost, not configuration.

A good fit if you…

  • Live in a terminal and want autonomous, inspectable agent workflows.
  • Have heavy agent subscriptions — Claude Max plus ChatGPT Pro for Codex give the best results.
  • Want to work async — answer questions in your own editor instead of steering a chat thread.

Probably not if you…

  • Are cost-sensitive. By default Hive runs many subagents and several coding agents per task, and burns a lot of tokens.
  • Need a hosted web app or a managed service. Hive is a local TUI and daemon.
  • Don't want a background daemon running on your own machine.

On a tight budget you can try the Pi agent with a recent Kimi model for parts of the workflow — though that integration isn't performance-tuned yet.

Install & run your first task

Hive ships as the hive-cli rubygem attached to each GitHub Release, signed with cosign keyless attestation. Every channel verifies the signature before installing. Prerequisites: Ruby 3.4, git, an authenticated gh, and the agent CLIs you plan to use (claude, codex).

macOS (Homebrew)

brew install ivankuznetsov/hive/hive

Arch Linux (AUR)

yay -S hive-bin

Linux (glibc x86_64 / aarch64)

tmpdir="$(mktemp -d)" && trap 'rm -rf "$tmpdir"' EXIT \
  && curl -fsSL https://raw.githubusercontent.com/ivankuznetsov/hive/v0.3.0/install.sh \
       -o "$tmpdir/hive-install.sh" \
  && bash "$tmpdir/hive-install.sh"

Then attach it to a project and capture an idea

cd ~/Dev/your-project
hive init .          # choose launch + permission mode, enroll the daemon
hive tui             # open the dashboard — press n to capture a new idea

Or drive it from OpenClaw

Prefer to let an agent install and run Hive? Install the ClawHub skill, then use the /hive slash command for guided setup and every workflow verb. 

openclaw skills install hive-cli
/hive setup                         # installs Hive, verifies it, sets up the daemon
/hive new . "build this feature"    # then drive any command through /hive …
/hive status

Full walkthrough in Getting started; services and the OpenClaw skill in Operating. Public listing: clawhub.ai/ivankuznetsov/hive-cli.

Ship your next idea while you sleep

Install Hive, drop one rough idea, and let the pipeline carry it to a PR — it doesn't need you in the room.

Install Hive Read the docs