CI/CD that fixes itself.
Hive runs your builds — and when one breaks, its agent swarm diagnoses the failure and opens a fix PR before you've even looked.

Hive builds Hive — every commit to this product ships through its own pipeline, agents included.
Starlark
pipelines as code
Your key
your model provider
EU
servers in Germany
Red builds don’t fix themselves. Until now.
Every team pays these three, every week, and none of them appear on an invoice.
- Your attention
You babysit your CI
A red build means dropping what you were doing, digging through logs, and losing your flow. Every failure costs a context switch — the most expensive thing in engineering.
- Your headcount
Your CI is a second job
Jenkins plugins, Groovy scripts, agents that drift out of date. Somebody on the team is always the unofficial CI admin — and it is never their job title.
- Your budget
You pay for standing still
Legacy CI charges hundreds per build agent per year for software that does exactly what it did a decade ago: tell you something broke, then wait for you to fix it.
How it works
From red build to fix-PR, hands-free.
- 01
A build goes red
Hive runs your pipeline — builds, lints, tests, deploys — as a DAG across your own machines or the cloud. Something breaks, as it always does.
- 02
The factory diagnoses it
Hive’s code factory reads the logs, the diff, and the failing tests, and pins down the root cause — not just the symptom.
- 03
An agent swarm fixes it
AI agents write the fix, run the affected checks locally, and iterate until the pipeline is green — using your own model API key.
- 04
You review a PR, not a log dump
The fix lands as a pull request on your branch, with the diagnosis attached. Merge it, tweak it, or toss it — you stay in control.


Coding agents
A harness for the agents you direct — on your machine or ours.
The factory fixes what broke without being asked. This is the other half: you point agents at the work you actually chose, and watch them from the same place you watch your builds.
On your machine, in a real worktree
Launch an agent onto your own workstation and it gets a genuine git worktree there — your checkout, your toolchain, your credentials, your dotfiles. Nothing is uploaded, because nothing needs to be: the code never leaves the machine it already lives on.
Or in the cloud, same agent
Want your laptop back, or ten of them at once? The identical harness runs containerised on rented capacity instead — isolated, resource-capped and killable. Booster packs pay for it, and you can move between the two per task.
Steer it mid-turn, from anywhere
Every session streams into the browser with its live state and PR status. Redirect it while it is still thinking, interrupt it, or answer the approval it is waiting on — from a phone, on a session you started at your desk.
Run a team, not a tab graveyard
Point several agents at one goal and see the roster: what each is on, its branch, its PR, its CI state — and which two are working the same files and about to collide.
Agents that hold the tools
They are inside the CI system, so they read failing runs, task logs and test results directly, then push, open PRs and watch their own checks go green. Diagnosis is a call, not a paste.
Spend you can see and cap
Per-session and per-fix cost, in euros and in tokens, against your own model API key at your provider’s rates — no markup. Set hard caps and an agent stops at them.
Your keys, your model, your hardware by default. Agents authenticate to your provider with your own credentials, and on your own runners the source is never checked out anywhere else.
Platform
The CI/CD core underneath.
Take the agents away and this is still the build system you would want: real code for pipelines, caches that are warm before you ask, and hardware you choose.
Pipelines as code — not YAML soup
Pipelines are Starlark: real functions, real loops, real reuse across repos. Versioned next to your code, evaluated deterministically, and diffable like anything else you review.
Your hardware, ours, or both
We run the control plane so you never operate one. The work runs wherever you want: connect your own machines with a one-line install and pay nothing for compute, or rent booster packs by the minute — and let the queue spill onto ours when yours is full.
Warm builds by default
Fingerprint-keyed image warming, registry-backed layer caches shared across nodes, and template test databases mean your pipeline starts hot. Less waiting — and on rented capacity, fewer billed minutes.
Insights that name names
Flakiest tests, slowest steps, queue-wait trends, per-step durations — accumulated automatically, with nothing for you to instrument, so the factory (or you) knows what to fix next.
Every answer over MCP and an API
Runs, logs, test results and fleet state are all reachable from the CLI, the HTTP API and an MCP server — so your own agents and scripts drive Hive directly instead of scraping a web page.
Run by a German company, on EU servers
Hive is operated by a GmbH in Bavaria, and the control plane runs on a server in Germany. No tracking, no analytics and no cookie banner on this site — the privacy notice says so because it is true.
Works with
Batteries included for the stack you already have.
Not a plugin marketplace to assemble. These are first-class in the pipeline language, with the caches, the report parsing and the integrations already done.
Languages
Lint and test, already wired
One line per lane in your pipeline, and the runner, the cache key and the report format come with it — not a shell script you maintain.
- Python
- pytest
- ruff
- uv
- TypeScript
- React
- Vite
- vitest
- ESLint
- pnpm
- Rust
- cargo
- nextest
- clippy
- Go
- Playwright
Results
Failures as data, not scrollback
Test output is parsed server-side, so a red run names the failing tests instead of handing you a log. Go streams natively; pytest and vitest stream through a one-line marker, so the pass/fail bar moves while the suite is still running. Flake and duration trends accumulate per test with nothing for you to instrument.
- go test -json
- JUnit XML
- live markers
- coverage.xml
- ESLint JSON
- ruff JSON
Build & ship
From Dockerfile to rolled out
Images build on BuildKit against a registry-backed layer cache shared across nodes, then deploy with the rollout actually verified — including the GitOps commit that makes it survive a reconcile.
- Docker
- OCI
- BuildKit
- Kubernetes
- ArgoCD
- CycloneDX
- Trivy
Where you work
It lives in your tools
Checks, statuses and PRs land in GitHub. Tickets move in Linear — an agent can take one and open the PR for it. And Hive exposes its own tools over MCP, so your agents can drive it directly.
- GitHub
- GitHub App
- Linear
- MCP
- Starlark
- PostgreSQL
- S3
Models
Your key, your provider
Agents authenticate as you — a Codex or Claude subscription, an OpenRouter key routing to whatever model you like, or Cursor. Spend is reported per session against your own account, at your provider’s rates.
- OpenAI Codex
- OpenRouter
- Anthropic Claude
- Cursor
- DeepSeek
- GLM
Not on the list? Every step is a container running a command you choose, so anything that builds in CI builds here — Java, C++, Elixir, whatever you have. The names above are the ones Hive is optimised for, not the ones it is limited to.
Why Hive
Your current CI tells you it broke. Hive fixes it.
| Hive | Jenkins | TeamCity | GitHub Actions | |
|---|---|---|---|---|
| Fixes its own failures | AI agent swarm → fix PR | No | No | No |
| Pipeline config | Starlark (typed, reusable) | Groovy DSL | Kotlin DSL / UI | YAML |
| Cost on your own hardware | Free — no seat or agent fee | Free + your ops time | ~$350 / agent / yr | Self-hosted runners, still per-seat |
| Maintenance burden | Nothing to operate — we run it | Plugin ecosystem = your problem | Moderate | Managed (cloud only) |
| Build caching | Warm images + template DBs | DIY | Partial | Cache action (slow at scale) |
Pricing
Free on your hardware. Metered on ours.
Bring your own runners
Free
your hardware, our control plane
Connect the machines you already have. No compute bill.
- Managed control plane and UI — zero ops for you
- One-line runner install: Linux, macOS, Windows
- Unlimited pipelines, unlimited runs
- Warm image & template-DB caching on your own disks
- Bring your own model API key for the factory
Booster packs
CPU-minutes
50,000 free every month during the private beta
Rent capacity when your own runs out — or skip hardware entirely.
- Packs are compute, not credit — a CPU-minute stays a CPU-minute
- Prices track our hardware cost; what you already hold never re-rates
- Metered by the millisecond, not rounded up to the minute
- ARM runners charge 0.32× — the same work, a third of the balance
- Hard caps: a wallet that runs dry queues work, never surprises you
- Optional storage for artifacts, images and test DBs on our hardware
Enterprise
Talk to us
Dedicated capacity and the paperwork your procurement wants.
- Reserved booster capacity and priority scheduling
- SSO/SAML, RBAC, audit logs
- Multi-cluster scheduling & fair-share
- Priority support & SLA
- Migration help from Jenkins/TeamCity
Packs are sold in CPU-minutes, not in euros. What a new pack costs moves with the hardware market. What you already hold does not — a CPU-minute you bought last year still buys a CPU-minute. For scale: the free beta allowance alone is 12× GitHub Actions’ free tier, and we meter by the millisecond where they round every job up to a whole minute.
You are billed for compute and storage you actually use on our hardware — never per seat, never per build. Final rates are announced at launch; waitlist members get early-bird terms and a say in them.
FAQ
Questions, answered.
How does the self-healing factory actually work?
When a run fails, Hive collects the logs, diff, and failing checks, and dispatches an AI agent with that context. The agent reproduces the failure, writes a fix, re-runs the affected checks, and opens a PR on your branch with the diagnosis attached. You review and merge like any other PR — nothing lands without you.
Is my code sent to a third party?
Only to the model provider you configure, using your own API key. Hive never stores or trains on your code. Your source is checked out on the runners you connect, so with your own runners the code never touches our hardware at all — and artifacts, images and test databases stay on your disks unless you opt into storing them with us.
Who operates Hive, and where does it run?
Hive is operated by Pulsar-Projekte GmbH, a German company registered in Bavaria. The control plane runs on a server in Germany; this marketing site is delivered as static files by Cloudflare. There is no analytics, no tracking and no cookie banner here — the Datenschutzerklärung sets out exactly what is processed and on what legal basis.
What does it cost to run the AI agents?
You bring your own model API key, so token costs go straight to your provider at their rates — no markup. Hive shows per-fix token spend and lets you set hard daily caps, so there are no surprise bills.
Do I need my own hardware?
No — but you can use it, and it is free if you do. We host the control plane and the UI; you choose where the work runs. Connect your own machines as runners with a one-line install (Linux, macOS, Windows), rent capacity from us as booster packs, or mix the two and let the queue spill over onto ours when yours is full.
Can I run coding agents on my own machine?
Yes, and that is the default. An agent launched onto your workstation gets a real git worktree there — your checkout, your toolchain, your credentials — so nothing is uploaded anywhere. The same agent can run containerised on rented capacity instead when you want your laptop back or need ten at once, and you choose per task. Either way you watch and steer it from the browser.
What is a booster pack?
Compute you rent from us by the minute instead of buying. When a run needs capacity your own runners do not have, Hive starts a VM, runs the work on it, and stops billing when it shuts it down. You see what each run spent, and a wallet that runs out queues the next job rather than quietly charging you for it. Private-beta tenants get 50,000 CPU-minutes a month. Packs are denominated in compute rather than money, so a repricing changes what a new pack costs and never what you already hold.
Do I have to replace my current CI to try Hive?
No. A repo opts in by committing one file, and Hive starts in shadow mode — it posts its own status and requires nothing, so your existing pipeline keeps gating merges exactly as before. You compare the two on real commits for as long as you like. Making Hive a required check is a separate decision you make in your repo settings, and our own onboarding runbook tells you not to retire the old CI until a preflight check reports clean. Start with one repo, one job — a useful pipeline is a few lines — and widen it when it has earned that.
Does it conflict with Claude Code, Cursor or Codex?
No — it runs them. Hive’s agents authenticate as you, with the subscription or key you already pay for: an Anthropic Claude or OpenAI Codex subscription, a Cursor account, or an OpenRouter key routing to whatever model you like. Your local setup is untouched, because CI runs server-side and needs nothing installed on your machine. And Hive exposes over a hundred MCP tools, so you can drive runs, read logs and diagnose failures from the editor and agent you already use instead of switching to our UI.
How is this different from GitHub Actions?
Actions runs your workflow and hands you a red X. Hive runs your pipeline and hands you a fix. Beyond the factory, you get pipelines as real code (Starlark, not YAML), warm caches by default, and the choice of whose hardware the work runs on — yours at no compute cost, ours by the minute, or both.
When can I get in?
Hive is in private beta now. Waitlist members are invited in order and get early-bird terms; every beta tenant gets 50,000 CPU-minutes a month to run jobs on our hardware while they try it — about 12× GitHub Actions’ free tier.
Stop babysitting builds. Let the hive do it.
Join the private beta. Connect your own machines and pay nothing for compute, or run on ours — every beta tenant gets 50,000 CPU-minutes a month.