Agentic IDE for agent orchestration

Your AI development team, ready to ship.

Hive gives you a single cockpit over a team of autonomous coding agents. Hand it a requirement — it decomposes the work into stories, assigns role-based agents, runs them in isolated worktrees, reviews, and opens the PR. From requirement to production. Automatically.

macOS Windows Linux Open source · MIT
REQ-001
Requirement
One plain-English ask
7 stories
Stories
Point-scored & ordered
agent/web—im-7c3a
Worktree
Isolated branch each
14 / 31 done
Review · QA
Lint · types · tests
PR #218
Pull request
Opened on your behalf
The agent team

Hive models a real agile team — not a chatbot.

Each role maps to a model and a complexity band. The Manager drains the inbox and supervises; the Tech Lead decomposes; seniors, intermediates, and juniors take stories sized to their pay grade; QA gates every PR.

MG

Manager

orchestrator

Drains the inbox, spawns and reaps workers, re-pends stalled stories, and escalates blockers on a tick loop.

Supervisor
TL

Tech Lead

Claude Opus

Decomposes each requirement into sized stories with dependencies, then hands them to the right agents.

Decomposition
SR

Senior

Claude Sonnet

Owns complex stories (6+ pts), reviews pull requests, and mentors the junior agents on the team.

6+ pts · review
IM

Intermediate

Claude Haiku

Takes medium-sized stories (4–5 pts) end to end in its own worktree — edit, commit, push.

4–5 pts
JR

Junior

GPT-4o-mini

Knocks out the simple stories (1–3 pts) — the routine changes that keep the backlog moving.

1–3 pts
QA

QA

Claude Sonnet

Runs lint, types, tests, and the build on every change — and approves the PR only when it all passes.

Gatekeeper
Built for operators

Watch your team work in real-time.

Where a normal IDE shows you your files and your changes, Hive shows you everything the hive is doing — every running agent, every in-flight diff, every PR it has opened.

Live diff streaming

Open any file an agent is editing and watch the changes land character by character — read-only while the agent owns the worktree.

Isolated worktrees

Every agent works on its own branch in its own git worktree. No collisions, no half-finished states leaking into your tree.

PRs opened for you

When review and QA pass, Hive opens a real pull request — titled, described, and ready for the human to merge.

Command palette

Jump to any file, project, or agent from one ⌘K palette. The whole cockpit is a keystroke away.

Persistent team memory

Requirements, stories, agent status, escalations, and findings live in a file-backed state store the whole team reads and writes.

Every project, one cockpit

Switch between projects from the title bar. See which hives are running, which are idle, and how many agents are live.

Inside the cockpit

A focused dark IDE, purpose-built for orchestration.

Hive IDE — Run
Hive IDE orchestration overview with the live manager.log, editor, and active-run panel
Orchestration overview

The active run, the log, and the roster — at a glance.

Explorer, editor, and the streaming manager.log on the left; the active run, story-point burndown, and full team roster on the right.

Agent inspector
Hive IDE showing an agent actively writing a file, with a read-only banner
Agent inspector

See exactly who owns a file.

“Intermediate is writing this file…” — the worktree is read-only while the agent owns it.

Status bar
Hive IDE status bar showing live agents, next tick countdown, and mempalace synced
Always-on status

Agents live, next tick, memory synced.

The status bar keeps the heartbeat of the hive in view at all times.

The core loop

One command to ship a feature.

Hive turns a high-level requirement into a real git PR by spawning workers in isolated worktrees, supervising them on a tick loop, and recording every decision in team memory.

1

Add a requirement

Describe what you want in plain English. It lands in the inbox as REQ-001 and waits for the next tick.

2

Tech Lead decomposes it

The requirement becomes point-scored stories with dependencies, ordered so nothing blocks on unfinished work.

3

Agents are assigned & spawned

Each story goes to the right role. The Manager spawns a worker in a fresh worktree on its own branch.

4

They build, you watch

Workers edit, commit, and push. You watch the diffs stream live and the log scroll in real-time.

5

Review & QA gate the work

Seniors review; QA runs lint, types, tests, and the build. Blocked stories are re-pended or escalated to you.

6

Hive opens the PR

When it all passes, a real pull request lands — titled and described. That’s it. Hive handles the rest.

Get started

Install Hive IDE.

Grab a signed desktop build, or clone the repo and run it from source. It’s an Electron app — React renderer, Claude Code workers under the hood.

Releases are automated from conventional commits on main — every tagged release ships macOS, Windows, and Linux installers. See the build-from-source guide for the full toolchain.

zsh — hive-ide
# clone & install
$ git clone https://github.com/nikrich/hive-ide
$ cd hive-ide && npm install

# launch the IDE (Electron + Vite)
$ npm run dev

# package a signed Mac app
$ npm run build:mac
  → release/0.1.0/Hive IDE.dmg
From requirement to production

Put your AI team to work.

Download Hive IDE, point it at a repo, and hand it the first requirement.