Hive is an async multi-agent coding pipeline that transforms a rough idea into a merge-ready pull request without requiring you to steer a chat thread or watch terminals. It is open source under the MIT license and designed for developers who live in the terminal and want autonomous, inspectable agent workflows. The core value proposition is turning a one-sentence concept into a shipping PR by running a series of specialized agents that brainstorm, plan, execute, review, and finalize the work. Hive is terminal-first and token-heavy, making it ideal for power users with heavy agent subscriptions like Claude Max and ChatGPT Pro. It belongs to the emerging category of AI-driven software development pipelines that emphasize transparency and async operation.
The pain point Hive solves is the manual, time-consuming process of guiding AI agents through the entire software development lifecycle from idea to production code. Traditionally, developers must stay in the loop, answer every prompt, and manually approve each step in a chat thread. This reduces productivity and adds friction when the developer wants to focus on other tasks. Hive eliminates this by running the pipeline asynchronously: agents advance tasks in the background, and the only human intervention needed is answering clarifying questions in a document. This matters because it allows developers to ship code while they sleep or work on higher-level concerns, turning an ordinary idea into a deployable PR with minimal oversight.
One of the major feature groups is folder-as-agent transparency. In Hive, every task is represented as a folder, and the folder's location in the file system indicates its current stage in the pipeline. Moving the folder to the next stage is the approval gesture, and each stage leaves durable artefacts in the form of markdown files. This means all artefacts – the original idea, brainstorm notes, implementation plan, code reviews, and PR metadata – are stored as plain text files that can be read, edited, or handed to another agent. The practice is called compound engineering, and it ensures that every step produces inspectable outputs that any agent can trust. This transparency is a deliberate rejection of black-box AI systems, giving developers full visibility into the agent's reasoning and outputs.
A second major feature group is multi-agent by design. Hive runs each pipeline stage on configurable agent CLIs, with Claude as the default, but also supporting Codex and Pi. This allows developers to choose the model they trust for each specific job, such as using Claude for brainstorming and Codex for coding. The agents work sequentially but asynchronously, with each stage building on the artefacts left by the previous one. The benefit is that developers can leverage the best model for each task without being locked into a single AI provider. Configuration is straightforward via a simple YAML file, and the system handles agent invocation, retries, and error reporting automatically within the TUI dashboard.
admin
Hive also includes several additional capabilities that extend its core pipeline. The Patrol feature offers opt-in autonomous repo patrol: it maps feature slices, reviews them, validates fixes, and opens PRs for those that pass. The Babysitter keeps existing open PRs green and mergeable by running bounded repair attempts and auto-rebasing behind a moving main branch, handing off only when stuck. A Telegram bot allows users to capture ideas, check the queue, and approve work directly from their phone, supporting photos, documents, and transcribed voice notes. These features integrate seamlessly with the main pipeline, providing a comprehensive automation suite for developers who want to minimize manual intervention in the PR lifecycle.
The overall workflow is structured as nine distinct stages that every task passes through: inbox capture (jot the rough idea), brainstorm refinement (agent pins down what you actually want), plan design (scope, implementation units, and risks fixed), execute build (code written in an isolated feature worktree), open-pr (branch pushed and draft PR opened), review harden (CI fixes, multi-agent review, triage, fixes), artifacts collect (release and handoff artefacts gathered), finalize publish (PR body refreshed and marked ready), and done archive (task archived with cleanup commands). Each stage is defined by a folder location in the task's directory, and moving the folder to the next stage triggers the next agent. This approach is explicit and auditable, ensuring that no step is skipped and every artefact is preserved.
Concrete use cases demonstrate Hive's real-world effectiveness. The demo video produced a genuine public repository called ivankuznetsov/shipped, seeded with the one-sentence idea 'a Telegram bot that sends a daily digest of what was shipped.' The pipeline ran through brainstorm, plan, execute, multi-agent review, and finalize, then landed as mergeable PR #1. Hive's own releases, including this website, are built using the same pipeline. Developers can capture a feature idea in one sentence, answer a few questions in their editor, and let Hive automatically ship a PR while they focus elsewhere. The outcome is a fast, autonomous path from concept to production code with minimal human overhead.
Hive is specifically designed for developers who live in a terminal and want autonomous, inspectable agent workflows. It is a good fit if you have heavy agent subscriptions like Claude Max and ChatGPT Pro to cover the token-intensive multi-agent process. Setup is light – just a few prompts with 'hive init' – and it works on macOS (Homebrew), Arch Linux (AUR), and Linux (glibc x86_64/aarch64). Prerequisites include Ruby 3.4, git, an authenticated gh, and the agent CLIs you plan to use. Hive is free and open source under MIT, but be aware of token costs as it burns many tokens per task. For developers seeking a fully managed web app, Hive is not the right choice; it is a local TUI and daemon. Yet for those wanting to ship PRs while they sleep, Hive delivers a powerful, transparent pipeline that turns a single idea into production code with minimal intervention.
Hive is designed for terminal-native developers who already use AI agent tools like Claude and Codex and want an autonomous, inspectable pipeline for turning rough ideas into production PRs. It suits power users comfortable with CLI daemons and token-heavy workflows, especially those with Claude Max or ChatGPT Pro subscriptions. Not for cost-sensitive users or those needing a hosted web app. The tool requires Ruby 3.4, git, gh, and agent CLIs; runs on macOS, Arch Linux, and Linux (glibc).