Hive platform

Your pipelines. Your runners. One control plane.

Hive evaluates real pipeline code, schedules its DAG across the hardware you connect, keeps expensive inputs warm and exposes every run to people, scripts and agents through the same API.

Join the waitlist See self-healing CI

The hosted control plane is operated in Germany. Your runners execute wherever you place them.

.hive/main.starstarlark

load("@hive//ci.star", "standard_ci")load("@hive//checks.star", "checks")IS_PR = ctx.event == "pull_request"          # computed in the entrypoint, every runci_img = checks.ci_deps_image()fixer  = autofix_step(target = "test", when = IS_PR)     # dormant, PR-onlyhive.pipeline(**standard_ci(    gate    = checks.quality_gate(changed_files = ctx.changed_files, image_from = "ci-deps"),    tests   = backend_shards + ui_shards,    extra   = [rust_step, frontend_step],    pr_only = [test_mobile, test_cli],       # each built with `when = … and IS_PR`    autofix = [fixer],    images  = [ci_img],))

A complete pipeline file: the gate, the test shards, the extras, and one dormant fixer that wakes only on a pull request.

Pipeline language: Starlark, versioned with code
Execution: BYO runners or booster capacity
Interfaces: Web · CLI · API · MCP

Check it before you push

The real gate, on your uncommitted tree, without a commit.

hive check uploads a snapshot of your working tree and runs one step and its dependencies on the fleet.

It evaluates the pipeline from the snapshot’s own .hive tree, so a broken Starlark edit fails here before it is pushed anywhere. The run is labelled local: it never notifies, never triggers a fixer and never collides with a real run.

A red step prints its error and log tail in the terminal. It needs a reachable server, a token and a registered project — it is the gate, run early, not a local emulation of one.

hive checkshell

$ hive check --step test-23 changed file(s) vs baserunning only: test-2 (+ deps)run #4821 started on your working tree (base 9f3c2ab)https://app.hiveci.io/runs/…run #4821 failed ── test-2 (failed) ──error: exit status 1log tail:FAILED orders/tests/test_total.py::test_order_total_includes_shipping1 failed, 1261 passed in 298.11s

Composed from the command’s own output format. The test name is fixture fiction; the shape is not.

CI/CD core

A build system worth keeping even without an agent.

The agent layer is the differentiator. The scheduler, execution and data plane underneath are the reason its fixes can be verified.

Definition

Pipelines as real code

Starlark gives you functions, loops and reusable modules while evaluation stays deterministic and reviewable beside the repository.

Placement

Run where the work fits

Connect Linux, macOS, Windows or Kubernetes capacity. Labels, constraints, architectures, queues and caps shape placement.

GPU jobs

GPU work lands where the node can run it

Connect your own GPU machines; the agent reports model, count and driver. A step declaring hive.resources(gpu=N) lands only on a node with that many free GPUs and, when it names a minimum CUDA version, a driver that supports it. GPU-only nodes take nothing else, and with no GPU free the task waits and says why.

Completion webhooks

Your application hears when a run ends

Subscribe a URL per project or pipeline to succeeded, failed and cancelled runs. Each delivery is HMAC-SHA256 signed, carries the run and its artifact list, and is retried with backoff for up to a day; a stable delivery id lets the receiver drop duplicates.

Warm path

Start from warm inputs

Fingerprint-keyed images, registry caches and template test databases reduce repeated setup across nodes and runs.

Evidence

Tests and timing become platform data

Parsed reports, flaky-test history, step duration, queue wait, artifacts and logs accumulate without separate instrumentation.

Interfaces

One answer across web, CLI, API and MCP

Runs, logs, tests, fleet state and actions are first-class calls, so operators and agents do not scrape the UI.

Isolation

Tenant and lane boundaries stay explicit

Identity, scoped tokens, queue policy, resource limits and guarded actions are enforced by the control plane around each workload.

Hybrid execution

Bring hardware first. Rent bursts when it helps.

The hosted product keeps the control plane out of your operations budget while leaving compute placement under your control.

Your runners

Connect machines you already own.

A pull-based agent joins a machine or VM to the scheduler. Compute on those runners is not billed by Hive.

Booster capacity

Spill bursts onto rented hardware.

CPU-minute packs fund hosted execution when your own capacity is busy or the task needs a lane you do not operate.

Hosted control plane

We operate the coordination layer.

Projects, pipelines, runs, logs, artifacts, agents and policy stay available without asking your team to run Hive itself.

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

Talks to what you run

Integrations that exist in the code, listed by name.

GitHub: A GitHub App: per-installation tokens, webhooks, commit statuses, per-step check runs, pull-request comments and native auto-merge.
Linear: A ticket lane for agents — claim, watch, comment, move state — plus the Factory’s own client.
Sentry: Both directions: Hive reports its own errors, brokers Sentry reads to agents, and files deduplicated tickets from issues.
Grafana: A query tool over the fleet metrics sink, for people and for agents.
Kubernetes: Managed clusters as the execution substrate, plus a read and action lane — logs, describe, events, scale, restart, rollback — with changes proposed as GitOps pull requests.
Registries and S3: Container registries modelled as data with shared layer caching; artifacts, dependency caches and log archives in S3-compatible object storage.
Notifications: ntfy and Discord webhooks, delivered through a durable outbox.

What the platform enables

Move from orchestration to a control loop that can act on its own evidence.

Self-healing CI

Turn eligible red checks into candidates

The run wakes a scoped agent; the resulting branch gate remains authoritative.

Explore the repair loop

Agents

Operate sessions across the same fleet

Workstation, cloud and Factory agents share the workspace around the pipeline.

Explore the agent platform

Private beta

Bring one repository. See the whole system work.

Start on your own runner, keep your existing CI beside it, and watch Hive turn the next eligible red check into a reviewable fix.

Join the waitlist See pricing