Your AI coding agents, organised.

1. Open a workspace

   Any folder whose subfolders are your projects. The task board, shared notes, skills and MCP servers live in its .hive folder, beside your code.

2. Sign in once

   Add your Claude Code and Codex accounts in Hive, or a model server, and choose which each workspace uses; GitHub Copilot uses its one sign-in for the PC. Your terminal's own sign-ins stay yours.

3. Add agents

   One agent, a builder and a reviewer, or a whole team from a template. Switch away and they keep working in the background; Hive tells you when one needs you.

1. Solo

   One agent in the project folder. No reviewer: you read the work yourself, and a card is done once it’s committed.

2. Pair

   A builder and a reviewer take the cards in turn, as a lane. Quick checks pass before review, nobody reviews their own work, and Hive merges what the reviewer approves.

3. Team

   Up to twelve agents (24 if you raise it), several lanes at once. The tests run before review and again on the merged result, and cards labelled ui or release wait for your OK.

• A new project asks once: How do you work? Choose a preset, customise it, or decide later
• With Pair or Team on Git, each card is built in its own folder, a slot, on a branch of its own, and Hive’s merge queue merges it only once it’s approved and its checks pass; Solo works in the project folder
• Every option says what it does and why; one switch in Settings turns the rules off
• Lanes run with or without the Hive Assistant: start one from the board and Hive starts each next card, and tells you when a review fails or a card is blocked

Panes, Tiles and focus

Your whole team at a glance.

The Session tab shows your agents as Panes or Tiles. Panes give each agent its own terminal, up to six to a page. Tiles fit as many as the window holds: each agent’s state, its card, its progress and the first lines of its latest reply, with the agents waiting for you standing out. Click a tile and the agent opens in the focus view, large, with the rest of the team in a strip beside it.

• A toolbar above the agents: Panes | Tiles, your agents counted by state (pick one to jump to it), the pages and layouts, and + Add
• Tiles keep the panes’ order, or put the agents that need you first; drag one onto another to swap them
• In the focus view, each agent in the strip shows its card’s number, tinted with the card’s stage on the board
• Quieter pane headers: the agent’s state, name, status and card, with everything else in ⋯ or a right-click
• A one-line footer: model, effort and mode, then the transcript’s size, context and cost, with warnings only when they matter
• Each state has its own shape as well as its colour, so you can tell them apart without colour

PanesTilesFocus view

Workflows

Your rules, from Todo to Done.

A project’s Version Control tab holds its workflow: who reviews the work, which checks pass first, who merges it and where cards are built. Start from Solo, Pair or Team and change any option; each one says what it does, why, and where its value comes from. Agents tell Hive what they did, and Hive moves the card, asks you what only you can answer, and refuses a move your rules don’t allow, saying what to do next.

• The board shows your workflow’s stages, from Todo through Active, Review and Approved to Done, and you can rename them
• Cards waiting for you (a review, an OK, an agent’s question) show For you, and your answer goes back to the agent that asked
• No code cards for a decision or a write-up, and Skip review for a card that needs no reviewer
• A change of rules applies from the next card: cards already under way finish under the rules they started with
• Workflow defaults for Hive and for each workspace, and Copy as JSON to take a project’s options to another
• Projects without Git get Solo, Pair and Team too

Task board and lanes

Build, review, approve: card by card.

A task board for the whole workspace. Give a builder and a reviewer a list of cards and they work through it as a lane: the builder does a card and submits it, the reviewer approves it or sends it back with findings, and Hive starts the next card once the last is merged. While one waits for the other it isn’t running: Hive wakes it when the card changes.

• Start a lane yourself: right-click Todo for Start Lane with These Cards…, choose the builder and the reviewer, and put the cards in order
• A card shows who builds it, who reviews it and its round; a lane that stops moving shows as stalled, and Hive tells you why
• At a lane’s round limit (10 unless you say otherwise) Hive asks you how to go on
• Paste a screenshot or a log into a card: it’s kept with the card and given to the agent that starts it
• A card’s Work section shows its branch, each revision submitted, its reviews, its checks and its merge
• The board is kept in one database in the workspace: every change is saved whole or not at all

Decisions

What you decided stays on the card.

What you decide about a card (its scope, a wording, a default, “option B”) goes in its Decisions, pinned above the comments, not buried in them. Agents follow them over the description, and a reviewer fails work that ignores one.

• An agent working on the card is told when a decision is added
• Answer a card’s questions in a chat with the Assistant: it records your words as a decision, and the agents that asked are told
• Reviews and comments stay below, numbered by round

The merge queue

Only approved work reaches main.

With Hive merges, each approved card goes into the project’s merge queue. Hive merges it in a folder of its own, runs your checks on the merged result, and moves the target branch only once they pass. A card that fails goes back to its builder, and red work never reaches the branch. The Progress panel shows the queue, the lanes and every long run.

• Merge commits as your repository makes them: its identity, its hooks, and signing as it says
• Pause and resume a queue, take a card out of it, or ask for your OK before cards with chosen labels merge
• Pushing stays yours: Hive pushes after a merge only if you turn it on, and never forces a push
• Recent merges are listed under each queue, with their merge commits
• Wrap any command in hive-progress to see its steps, and as a named check it counts for the card

Slots and Version Control

Each card in its own folder.

Hive lends each card, or each lane, a slot: a folder of its own on a branch of its own, brought up to date before the card starts, with your setup script run and your .env files copied in. Reviewers read the work in a review copy, so nothing they do touches the builder’s folder.

• The Version Control tab shows changes, history, branches and remotes, and the merge queue
• Compare any two branches without checking anything out, and clean up branches nothing uses any more
• Each branch is listed with its card, its stage and, once done, the commit that merged it
• File locks stop agents sharing a folder, of any CLI, from editing the same file

Accounts and connections

Your accounts, your models.

Hive keeps your Claude Code and Codex sign-ins in Settings → Accounts & Connections, each in a folder of its own: two plans side by side, or a work and a personal account. GitHub Copilot has one sign-in for the whole PC, which is its account there. A connection is a named setup on an account (its model, effort, context and permission mode), and every agent, and the Assistant, runs on the connection it chooses. Each workspace chooses which accounts are on.

A Claude Code account can also get its model from a server: DeepSeek, Ollama on this PC, or your own gateway. Its key is stored encrypted and masked wherever Hive shows it, and a conversation that runs only on this PC costs free (local).

• Your terminal’s own Claude Code and Codex sign-ins stay yours, as they are
• Each account shows who it’s signed in as and its plan’s usage
• Switch an agent’s connection in its settings: a running one moves at its next safe point
• Templates choose connections as you load them: one per role, the same for all, or per agent
• One CLI or a mix: Claude Code builders with Codex reviewers, each in its CLI’s own terminal, exactly as it looks when you run it yourself

Claude Code, Codex and GitHub Copilot CLI

Choose the agent for the job.

Each agent’s connection decides its CLI, so one project can mix them. Hive works with the GitHub Copilot CLI too: Copilot agents get what the others get, on your own Copilot plan.

Hand Over to… passes an agent’s work to another, of any CLI, through a handover.

• Help → Provider Setup installs each CLI, and says which versions this Hive was tested with
• Every change Hive makes to how a CLI behaves has a switch in Settings → Advanced
• Skills, MCP servers, file locks, status, transcripts and costs work for all three

Claude Code Anthropic

Sign in with a Claude plan or an Anthropic Console account, or get its model from a server: DeepSeek, Ollama on this PC, or your own gateway.

• Manual
• Accept edits
• Plan
• Auto
• Don’t ask
• Bypass

Codex OpenAI

Sign in with a ChatGPT plan or an OpenAI API key. Each account keeps its own memory, and Hive starts Codex’s one-time Windows sandbox setup for you.

• Read only
• Ask for approval
• Approve for me
• Full access
• Plan

GitHub Copilot GitHub

Runs the Copilot CLI with your GitHub account and its Copilot plan, signed in once for the whole PC; Copilot Free runs the Auto model only. Provider Setup says who it’s signed in as, and how. Accept edits is its default mode.

• Accept edits
• Ask
• Plan
• Autopilot
• Allow all

All three get the workspace’s skills, MCP servers and Hive’s own tools, with file locks, live status, transcripts and costs.

Hive Assistant

An Assistant that runs the work.

Each workspace has a Hive Assistant in a panel beside your agents. Ask it what the agents are doing, about any project, or for a plan or a review. Let it, and it runs the work: it plans cards, briefs and starts lanes, follows them to the end and asks you only for real decisions. Hive runs lanes, reviews and merges without it too.

• Four working modes: Coordinator, Planner, QA triager and Release manager, or write your own
• Undo anything it changed in the last 7 days, one change or a whole message’s
• It sets a team up from a template, showing who goes, who comes and what the workflow would change
• Its journal is its memory across sessions, kept on your PC, for you to read, correct or turn off
• You decide how far it goes: look and advise, control agents, or create projects too

Live status

Know which agent needs you.

Status comes straight from the agents’ CLIs, so every project shows whether its agents are working, waiting for you, waiting for a card, or done. A chime and a Windows notification tell you when an agent finishes or needs input, even when Hive is in the tray, and agents finishing together chime once.

The status bar says how many things need you: click it for the list, oldest first. Hive’s taskbar button shows the count too.

• Active, no session
• Ready for a prompt
• Working
• Needs your input
• Finished
• Something new to see

Transcript viewer

Read every session, in full.

The Sessions tab shows the whole conversation, including what came before each compaction, in a tree by CLI and agent. Thinking and tool calls fold to one line each, and each session says where it ran, which agent ran it and the card it worked on.

• Search one session or all of them, and export a conversation as Markdown
• Long sessions open quickly: the latest messages first, earlier ones as you scroll
• Transcript backups, so sessions survive the CLIs’ own cleanup
• Adopt sessions you started in VS Code or a terminal

Tokens and plan usage

See what every session costs.

A project’s Overview sums up the period you choose: tokens, API-equivalent cost, sessions and prompts, with every agent running now. The Workspace Overview adds up every project and the Assistant. The status bar shows each connection’s plan limits, with a warning at 80% and 95%.

Each card says what it cost while its builder and reviewer held it, and Performance lists the cards by cost.

Files and Memory

Review what your agents did.

A file browser with an editor and previews for Markdown, CSV, HTML, SVG, images and PDFs. Changes as side-by-side diffs. And CLAUDE.md, AGENTS.md and Claude Code’s auto memory, editable in place.

Ctrl+click a file path in an agent’s terminal, even in a stack trace, and it opens here at that line.

• Markdown split view with live preview
• Git status colours in the tree, updated as files change on disk
• Your unsaved edits are never overwritten by an agent’s
• Attach any file to a prompt or a card, and find it again in the Attachments tab

Skills and MCP

Skills and MCP servers, where they’re needed.

Define skills and MCP servers once in the workspace. Every skill reaches every agent, of any CLI. An MCP server runs only in the projects you add it to, or for the Hive Assistant alone.

The MCP view’s Catalogue lists servers to install, from Hive’s own catalogue or one you add, such as your company’s. Hive checks what each needs on this PC, checks the download against the catalogue’s size and checksum, and shows what it runs before you add it anywhere. Updates are offered, never automatic.

• Skills come with Hive for its ways of working, from work-on-card and card-loop to merge-ready and handover, kept up to date
• Choose which of Hive’s skills agents get
• Workspace notes for what’s true of this machine, given to every agent
• Add a server from a .json definition or a .zip: Hive shows what it runs first

Agent API

Agents that talk to Hive.

Every session, Claude Code, Codex or GitHub Copilot, gets Hive’s built-in hive MCP server: a tool for each step of a card’s work, waits that cost nothing, shared notes, handovers for the next session and notices for you. Its replies are a few lines, so they cost agents few tokens.

What Hive tells an agent goes to its inbox: kept across restarts, read between its steps, and acked once it has acted, so nothing is lost because it was busy.

Scripts get the same through a local REST API with a token and a live event stream, and apps that only show your agents get a read-only viewer token.

Read the Agent API reference

PowerShell · inside a Hive session

# Sessions started by Hive get the API's URL and token
> $h = @{ Authorization = "Bearer $env:HIVE_API_TOKEN" }
> Invoke-RestMethod "$env:HIVE_API_URL/v1/projects/task-board" -Headers $h

---

{
  "name": "task-board",
  "branch": "main",
  "status": "working",
  "agents": [
    { "name": "B1", "provider": "claude-code", "workflowRole": "builder", "slot": "slot-a", "branch": "hive/TB/TB-12-dark-mode", "status": "working" },
    { "name": "B2", "provider": "claude-code", "workflowRole": "builder", "slot": "slot-b", "branch": "hive/TB/TB-14-csv-export", "status": "working" },
    { "name": "R1", "provider": "codex", "workflowRole": "reviewer", "slot": null, "branch": null, "status": "working" },
    { "name": "R2", "provider": "codex", "workflowRole": "reviewer", "slot": null, "branch": null, "status": "watching" }
  ]
}

---

# Or, from any agent, through the built-in hive MCP server:
hive_start_card · hive_submit · hive_verdict · hive_wait_for_tasks · hive_create_handover …

Updates

Pause the team, then update.

Before you install an update while agents are at work, Pause the Team. No lane starts its next card and the merge queue takes no new one; each agent is told to finish its turn, end what it started and commit its work. Hive lists what still runs until it says All parked: safe to install. After the update, the agents carry on in their conversations, each told where it was.

• Hive checks GitHub for new releases, downloads them in the background and installs them when you quit, or when you choose Restart to Update
• Every download is checked against its published checksum
• Skip a version, or opt in to pre-releases

• What Hive adds

  A new Claude Code session starts at about 35–⁠40K tokens of context. Almost all of that is the CLI’s own system prompt and tools, which every Claude Code user has, with or without Hive. Hive adds about 3–⁠4K: its instructions, its tools’ names and a short start view of where things stand. It is cached, so reading it again each turn costs far less than fresh input.

• What uses your plan

  The work itself, and long conversations. Every turn sends the whole conversation again, so a short conversation costs less per turn than a long one.

• More agents, same work

  The work costs about the same whether one session does it or three. Parallel agents add a modest overhead (each session’s start, briefs and reports, the Assistant’s own turns) and give you speed, scale and a reviewer agent checking the builder’s work.

• Short, focused conversations

  The overhead pays for itself because Hive keeps conversations short: each lane gets a new conversation, handovers carry the work from one session to the next, and the Assistant’s journal carries what matters across sessions in a few thousand tokens instead of hours of history.

• Your accounts

  Several Claude Code and Codex sign-ins side by side, GitHub Copilot’s own sign-in, or a model server of your own. Each workspace chooses which it uses; server keys are stored encrypted.

• Nothing leaves without your OK

  Nothing is pushed or uploaded without your OK: Hive pushes after a merge only if you turn it on, and reads MCP catalogues only when you open them.

• Every rule has a switch

  Workflow rules turn off with one switch, and every change Hive makes to how a CLI behaves has its own in Settings → Advanced.

• Open source

  MIT licensed, with its source on GitHub, and in eight languages.

• English
• Deutsch
• Español
• Français
• Polski
• Português (Brasil)
• 日本語
• 简体中文

Every language but English was drafted by AI, and Hive says so in its language list, so expect the odd awkward phrase. Spotted one? Help → Improve This Translation opens the guide to fixing it, or adding a language, with a pull request. The user guide stays in English for now; the Hive Assistant answers in your language.

• Several windows

  One workspace per window, like VS Code, each of which can stay on top. Settings, the tray and updates are shared.

• Keyboard first

  Command palette, Go to Project, and shortcuts for every command, configurable per project.

• Tray and taskbar

  Close the window and sessions keep running. The taskbar badge and the tray list the agents that need you.

• Antivirus check

  Hive shows whether Microsoft Defender scans your workspace and its slots, and adds exclusions only with your consent.

• Problems said plainly

  Hive tells you when git is missing, a sign-in expires, or a project’s .hive folder is in version control.

• Recovers from crashes

  Agents run outside the window, so if it ever crashes it reloads by itself and they carry on. If Hive itself closes unexpectedly, the next start says what was running and offers to resume it.

• Copy Diagnostics

  Everything a bug report needs, with the CLI versions tested and installed, and folders, names, keys and tokens taken out.

• Nothing left running

  Hive keeps track of what each agent starts, and offers to end what a stopped agent left running: a preview server, a watcher, a shell.

• Fix a CLI change yourself

  What a coding agent’s update can break (a prompt’s wording, a mode’s name) is in Settings → Advanced, so you needn’t wait for a Hive release.

• Developer console

  Watch what each CLI sends Hive, redacted, and record it for a bug report. Off until you turn on developer features.

• Your own commands

  Name a command once and run it from the command palette, or as a workspace opens or closes: a local server your agents need, a backup, a sync.

• Carries on after a drop

  Turn it on, and an agent whose turn a Wi-Fi blip ended waits for the connection, then reruns what was cut off and carries on.

• Quit when agents finish

  Hive only asks before quitting when an agent is mid-task, and can wait for it to finish.

• Shared notes and handovers

  Team conventions and handovers in the workspace, readable by every agent. Handovers say which agent wrote them.

• Awake while agents work

  The PC doesn’t go to sleep mid-task, and transcripts are backed up if Windows shuts down.

• Easy to read

  One colour per action, every label readable in both themes (WCAG AA), and dialogs you can drag out of the way.

• Dark and light

  A VS Code-style interface with honey accents, in dark and light themes.

• Windows 10 or 11

  64-bit (x64).

• Claude Code, Codex or GitHub Copilot CLI

  The standalone CLI of one or more, on your own plan, or Claude Code with a model server such as DeepSeek or Ollama. Help → Provider Setup installs them; Claude Code and Codex sign in under Settings → Accounts & Connections, and GitHub Copilot once for the whole PC. Install guides: Claude Code, Codex, GitHub Copilot CLI

• Git (optional)

  For Version Control, slots and the merge queue. Projects without it get workflows too.