Hive watches GitHub, your Grafana alerts, and anything that can POST a webhook, then routes them through rules your own coding agent wrote. One local queue, one ping per real change, and a config file that lives in your dotfiles.
Free and open source · MIT licensed · macOS and Linux
The flow editor is the same canvas that runs in the app. Sources stream raw observations through filters and functions that pass, drop and split them, so a firehose of GitHub activity, firing alerts and webhook deliveries becomes a handful of feeds you can actually act on.
Point a source at any GitHub search query or your notification inbox, across as many accounts as you have. Pair it with Grafana alerts, a PromQL expression, or anything that can POST JSON to a local endpoint. Read, archive and ignore state stays on your machine — triaging here never writes back to GitHub.
Hive renders skill files out of its own live node registry into ~/.claude, ~/.codex, ~/.pi and ~/.agents, then keeps them in step — add a node type and your agent already knows it. Describe the work you want surfaced and it writes the flow, dry-runs it against real input, and hands it back for you to review.
A notification means something actually changed. Re-polling the same PR never re-fires, a cooldown floors how often one item can reach you, pings that went stale while you were away are dropped instead of replayed as a burst, and a restart recomputes every feed without notifying anything twice.
Wire sources through filters and functions on a canvas, watch per-node run status, then deploy. Filters are declarative and their reject branch is wireable, so nothing has to be thrown away. Functions are your own JavaScript with up to sixteen outputs and durable per-node memory — one alert can fan out into one tracked item per firing entity.
Flows and actions are plain YAML in your config directory: diff them, PR them, keep them in your dotfiles. Edit on the canvas or in your editor. Hive validates on save and reloads live, and a file that fails to build keeps its last good version in service rather than taking the feed down with it.
An item can launch a coding-agent session from a prompt template, run a shell command, publish a message for another session to pick up, or render straight to your clipboard. An action can ask you for input first, and each one fires once per item. Run it by hand from the detail pane, or let a flow node do it for you.
The parts you only notice when they're missing: the stuff we keep fixing between weekly builds.
⌘K reaches every command: switch profiles, jump to a feed, run an action. Every binding is rebindable.
Everything lands in a local SQLite database, and retention rules prune old runs and long-archived items so it never grows unbounded.
Each GitHub account gets its own fetcher, its own response cache and its own rate-limit budget, so a busy work org can't starve your personal repos.
Each item carries the actions its flow defines: launch a session, run a script, publish a message, or fill the clipboard. An action can collect input first, all from the keyboard.
Feeds, filters and flows are files. Edit in the app or in your editor; commit them like any other code.
Conditional requests, GitHub's own poll-interval hints, and automatic backoff keep Hive well inside your API rate limits.
Every feed, filter and action is a node in a YAML file. Hive renders skill files out of its own live node registry and installs them into the coding agents you already run — so describing what you want watched is the whole of the setup.
Sign in with the device flow, or paste a token. Either way it goes straight to your OS keychain. Hive never keeps a copy.
In Settings ▸ Agents ▸ Skills, pick the agents you use. Hive writes schema-complete skill files into ~/.claude, ~/.codex, ~/.pi and ~/.agents — generated from the node types this build actually has, and refreshed on every launch. Anything you edit yourself is reported, never overwritten.
Tell your agent what you want surfaced. It writes flows/<id>.yaml against the schema it just learned and dry-runs it against real input without touching live state. Hive picks the file up live — review it on the canvas and deploy.
Prefer to do it yourself? Every feed, filter and action can also be created and edited by hand, on the canvas or straight in the YAML.
Hive is built in three modes you switch between from the title bar. The inbox is the one you get on install; the other two are further behind it and ship switched off until they settle.
Where the work arrives.
Sources poll GitHub, Grafana and your own webhooks. Flows filter, split and route what comes back into feeds you arranged yourself, and every item carries the actions its flow defines. Triage stays on your machine and is never written back.
Where the work gets done.
Attach to the tmux session behind a Hive session and read the agent you launched from a feed without leaving the app. Sessions are real git checkouts — create, rename, recycle or prune them from the sidebar, with a pre-flight that names uncommitted or unpushed work before anything is destroyed.
Where you brief them.
Named workspaces on disk that generate the config your agent actually reads — CLAUDE.md, .mcp.json, a Codex profile — from one manifest you edit. Pick an autonomy posture per workspace and the editor shows the literal flags it will launch with. Chats run in tmux, so closing the app doesn't end them.
The inbox is the product today. Code and Agents ship switched off while they settle — a license covers every build in its window, so they arrive as they land rather than as an upgrade you buy again.