Hive with Claude Code
Routines is event to agent, acting as you. Hive is event to you, then to an agent.
Choose Claude Code if
- You want events to become pull requests with nobody in the loop.
- You want cloud execution that draws on your existing subscription rather than a separate compute bill.
- You want a chat transcript, per-turn checkpoints, and a session that archives itself when its PR merges.
- Everything you want automated is a GitHub pull request or release event.
Choose Hive if
- You want the event to reach you before it reaches an agent.
- The things that interrupt you are not all GitHub — firing alerts, your own webhooks, a saved search.
- You want a queue that accumulates and deduplicates rather than firing once and forgetting.
- You do not want automation acting under your own GitHub identity.
What Claude Code is
“Put Claude Code on autopilot. Define routines that run on a schedule, trigger on API calls, or react to GitHub events.”
Anthropic's coding agent, its desktop app, and Routines — the feature that turns a saved prompt into something a GitHub event can start on its own. The desktop app gives each session its own git worktree; the web version runs sessions on Anthropic-managed machines and can react to CI failures on a pull request without being asked.
https://code.claude.com/docs/en/routines ↗
What Hive is
Hive watches GitHub, Grafana and your webhooks, holds what arrives in a local queue, and dispatches only what you decide to dispatch. When you do, it launches Claude Code — Hive is one of the things that starts it, not an alternative to it.
Two different loops
Routines runs event, then agent, then pull request. Three things follow from that shape: whatever it does, it does as you and before you have seen it; its triggers are a slice of GitHub, so no Grafana alert and no webhook of your own can start one; and nothing accumulates, because there is no queue — things simply happen.
Hive runs event, then triage, then you, then dispatch. Everything waits somewhere that deduplicates and never re-pings, nothing acts under your identity, and the same queue carries alerts and webhook deliveries alongside GitHub.
Which loop you want is a real question with two defensible answers, and it depends on how much of your incoming work is the kind you would have approved anyway.
Where Claude Code is better
Genuine autopilot
A routine fires on a schedule, an API call, or a GitHub pull-request or release event, with filters on author, title, body, branch, labels and draft state. Hive does not do this and is not trying to — its whole shape puts you in the middle.
Cloud execution with no separate compute charge
Sessions run on Anthropic-managed machines against your normal subscription limits, and can be pulled back down into your terminal along with their branch. Hive runs on your machine and only your machine.
The desktop app is a better place to read an agent
A worktree per session, a real transcript, an integrated editor, and sessions that archive themselves when their pull request merges. Hive's chat view is a terminal pane with no composer and no transcript of its own.
It fixes its own pull requests
The web version subscribes to GitHub webhooks on a PR and responds to CI failures and review comments autonomously. Hive can notice a CI failure and hand it to you; it will not go and fix it unprompted.
Where Hive is better
Triggers that are not GitHub
Grafana alerts keyed by fingerprint, PromQL expressions, any GitHub search query you can write, and a local endpoint your scripts, CI or cron can POST to. A routine cannot be started by any of those.
A queue that holds things
Work accumulates with read, archive and ignore state instead of firing and vanishing. That is the difference between deciding what deserves you and finding out afterwards what was decided.
Nothing acts as you
Triage never writes back to GitHub, so nothing you do in Hive appears under your account. Routines are scoped to your individual account and act under your GitHub identity.
It is not Claude-shaped
Hive launches Claude Code and Codex, and installs its generated skill files into ~/.claude, ~/.codex, ~/.pi and ~/.agents alike. Everything Anthropic ships is necessarily built around one agent.
Side by side
| Claude Code | Hive | |
|---|---|---|
| Event becomes a pull request with no human step | ● | ○deliberately — you are the step |
| Cloud execution | ●no separate compute charge | ○local only |
| Chat transcript and checkpoints | ● | ◐a terminal pane; no transcript stored |
| Included with a subscription you may already pay for | ● | ○a separate one-time license |
| Autonomous CI-failure fixing | ● | ○ |
| Triggers on Grafana alerts or your own webhooks | ○schedule, API call, or GitHub PR and release eventssource | ● |
| A durable queue you triage | ○routines fire; nothing accumulatessource | ● |
| Acts under your own GitHub identity | ●read this row either way | ○triage never writes back |
| Works with agents other than Claude | – | ●Codex today |
This is a 'with', not a 'versus'
Hive's launch-session action starts Claude Code. Keep your subscription, keep the desktop app, keep any routines that are genuinely fire-and-forget. Put Hive in front of the work that needs a decision before an agent touches it.
The question is not which to install. It is whether an event should reach an agent before it reaches you. Routines answers yes. Hive answers you first. Both answers are right for different work, which is why Hive launches Claude Code rather than replacing it.