Private beta — join the waitlist

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 — a build breaking, then unbreaking
The Hive runs dashboard: two builds in progress with live progress bars, one queued, a failed run on feature/checkout-v2, and the green run from the agent-authored fix that followed it.
Hive’s own dashboard — a red build, the agent’s fix, and the green run after it.

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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

hive — run #4821, and why it failed
A failed Hive run: a "why did this fail?" panel naming the failing step and the three failing tests, a dependency graph with one step red and two blocked behind it, and the commit that caused it.
Step 02 — the diagnosis: the failing step, the three failing tests, and what actually caused them.
hive — the agent that fixed it
An agent's transcript inside Hive: it regenerates the stale order fixtures, re-runs pytest to 1262 passing, commits, pushes, and reports the root cause — with the cost of the whole session shown at the bottom.
Step 03 — the agent that fixed it: every tool call it made, and what the session cost.

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.

HiveJenkinsTeamCityGitHub Actions
Fixes its own failuresAI agent swarm → fix PRNoNoNo
Pipeline configStarlark (typed, reusable)Groovy DSLKotlin DSL / UIYAML
Cost on your own hardwareFree — no seat or agent feeFree + your ops time~$350 / agent / yrSelf-hosted runners, still per-seat
Maintenance burdenNothing to operate — we run itPlugin ecosystem = your problemModerateManaged (cloud only)
Build cachingWarm images + template DBsDIYPartialCache 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
Join the waitlist

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
Join the waitlist

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
Talk to us

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.