Private Beta — jetzt vormerken

CI/CD, die sich selbst repariert.

Hive führt Ihre Builds aus — und wenn einer bricht, diagnostiziert der Agenten-Schwarm den Fehler und öffnet einen Fix-PR, bevor Sie überhaupt hingeschaut haben.

hive — ein Build bricht, dann läuft er wieder
Das Runs-Dashboard von Hive: zwei laufende Builds mit Live-Fortschrittsbalken, einer in der Warteschlange, ein fehlgeschlagener Run auf feature/checkout-v2 und der grüne Run des Fixes, den ein Agent danach geschrieben hat.
Das Dashboard von Hive selbst — ein roter Build, der Fix des Agenten und der grüne Run danach.

Hive baut Hive — jeder Commit an diesem Produkt läuft durch seine eigene Pipeline, Agenten inklusive.

  • Starlark

    Pipelines als Code

  • Ihr Key

    Ihr Modell-Anbieter

  • EU

    Server in Deutschland

Rote Builds reparieren sich nicht von selbst. Bis jetzt.

Diese drei Posten zahlt jedes Team, jede Woche — und keiner davon steht auf einer Rechnung.

  • Ihre Aufmerksamkeit

    Sie hüten Ihre CI

    Ein roter Build heißt: alles stehen lassen, Logs durchwühlen, aus dem Arbeitsfluss fallen. Jeder Fehlschlag kostet einen Kontextwechsel — das Teuerste in der Softwareentwicklung.

  • Ihre Personaldecke

    Ihre CI ist ein Zweitjob

    Jenkins-Plugins, Groovy-Skripte, Agents, die aus der Zeit fallen. Irgendjemand im Team ist immer der inoffizielle CI-Admin — und in keiner Stellenbeschreibung steht das.

  • Ihr Budget

    Sie zahlen für Stillstand

    Klassische CI-Systeme kosten mehrere hundert Euro pro Build-Agent und Jahr — für Software, die genau das tut, was sie vor zehn Jahren tat: melden, dass etwas kaputt ist, und dann auf Sie warten.

So funktioniert’s

Vom roten Build zum Fix-PR, ohne Ihr Zutun.

  1. 01

    Ein Build wird rot

    Hive führt Ihre Pipeline aus — Builds, Lints, Tests, Deployments — als DAG auf Ihren eigenen Maschinen oder in der Cloud. Und irgendetwas bricht, wie immer.

  2. 02

    Die Factory stellt die Diagnose

    Die Code-Factory von Hive liest Logs, Diff und fehlgeschlagene Tests und benennt die Ursache — nicht bloß das Symptom.

  3. 03

    Ein Agenten-Schwarm repariert ihn

    KI-Agenten schreiben den Fix, lassen die betroffenen Checks lokal laufen und arbeiten nach, bis die Pipeline grün ist — mit Ihrem eigenen Modell-API-Key.

  4. 04

    Sie prüfen einen PR, keine Logwüste

    Der Fix kommt als Pull Request auf Ihrem Branch an, die Diagnose hängt daran. Mergen, anpassen oder verwerfen — die Entscheidung bleibt bei Ihnen.

hive — Run #4821, und warum er gebrochen ist
Ein fehlgeschlagener Hive-Run: ein Panel „why did this fail?“ benennt den gebrochenen Schritt und die drei fehlgeschlagenen Tests, dazu ein Abhängigkeitsgraph mit einem roten Schritt und zwei dahinter blockierten sowie der auslösende Commit.
Schritt 02 — die Diagnose: der gebrochene Schritt, die drei fehlgeschlagenen Tests und deren tatsächliche Ursache.
hive — der Agent, der es repariert hat
Das Transkript eines Agenten in Hive: er erneuert die veralteten Order-Fixtures, lässt pytest erneut laufen bis 1262 Tests grün sind, committet, pusht und nennt die Ursache — unten stehen die Kosten der gesamten Session.
Schritt 03 — der Agent, der es repariert hat: jeder Tool-Aufruf und die Kosten der Session.

Coding-Agenten

Eine Umgebung für die Agenten, die Sie steuern — auf Ihrer Maschine oder auf unserer.

Die Factory repariert ungefragt, was kaputtgegangen ist. Das hier ist die andere Hälfte: Sie setzen Agenten auf die Arbeit an, die Sie selbst ausgewählt haben — und beobachten sie dort, wo Sie auch Ihre Builds beobachten.

Auf Ihrer Maschine, in einem echten Worktree

Starten Sie einen Agenten auf Ihrer eigenen Workstation, und er bekommt dort ein echtes Git-Worktree — Ihr Checkout, Ihre Toolchain, Ihre Zugangsdaten, Ihre Dotfiles. Nichts wird hochgeladen, weil nichts hochgeladen werden muss: Der Code verlässt die Maschine nicht, auf der er ohnehin liegt.

Oder in der Cloud, derselbe Agent

Sie wollen Ihr Notebook zurück — oder gleich zehn Agenten parallel? Dieselbe Umgebung läuft stattdessen containerisiert auf gemieteter Kapazität: isoliert, mit Ressourcenlimit und jederzeit abschaltbar. Bezahlt wird das aus Booster-Packs, und Sie entscheiden pro Aufgabe neu.

Mitten im Turn steuern, von überall

Jede Session streamt mit Live-Status und PR-Zustand in den Browser. Lenken Sie den Agenten um, während er noch denkt, unterbrechen Sie ihn, oder beantworten Sie die Freigabe, auf die er wartet — vom Handy aus, in einer Session, die Sie am Schreibtisch begonnen haben.

Ein Team führen statt Tabs sammeln

Setzen Sie mehrere Agenten auf ein Ziel an und sehen Sie die Aufstellung: woran jeder arbeitet, sein Branch, sein PR, sein CI-Status — und welche zwei gerade dieselben Dateien anfassen und gleich kollidieren.

Agenten mit Werkzeug in der Hand

Sie sitzen im CI-System selbst, lesen fehlgeschlagene Runs, Task-Logs und Testergebnisse direkt, pushen, öffnen PRs und verfolgen ihre eigenen Checks bis grün. Diagnose ist ein Aufruf, kein Copy-Paste.

Kosten, die Sie sehen und deckeln

Kosten pro Session und pro Fix, in Euro und in Tokens, abgerechnet über Ihren eigenen Modell-API-Key zu den Preisen Ihres Anbieters — ohne Aufschlag. Setzen Sie harte Limits, und der Agent hält daran an.

Standardmäßig Ihre Keys, Ihr Modell, Ihre Hardware. Agenten authentifizieren sich mit Ihren eigenen Zugangsdaten beim Anbieter, und auf Ihren eigenen Runnern wird der Quellcode nirgendwo sonst ausgecheckt.

Plattform

Der CI/CD-Kern darunter.

Nehmen Sie die Agenten weg, und es bleibt das Build-System, das Sie ohnehin wollen würden: echter Code für Pipelines, Caches, die warm sind, bevor Sie fragen, und Hardware Ihrer Wahl.

Pipelines als Code — kein YAML-Brei

Pipelines sind Starlark: echte Funktionen, echte Schleifen, echte Wiederverwendung über Repos hinweg. Versioniert neben Ihrem Code, deterministisch ausgewertet und so diffbar wie alles andere, das Sie reviewen.

Ihre Hardware, unsere, oder beides

Wir betreiben den Control Plane, damit Sie es nicht müssen. Die Arbeit läuft, wo Sie wollen: eigene Maschinen mit einem Einzeiler anbinden und nichts für Compute zahlen — oder Booster-Packs minutenweise mieten und die Warteschlange auf unsere Kapazität überlaufen lassen, wenn Ihre voll ist.

Warme Builds von Haus aus

Fingerprint-basiertes Vorwärmen von Images, knotenübergreifend geteilte Layer-Caches in der Registry und Template-Testdatenbanken sorgen dafür, dass Ihre Pipeline heiß startet. Weniger Wartezeit — und auf gemieteter Kapazität weniger abgerechnete Minuten.

Auswertungen, die Ross und Reiter nennen

Die instabilsten Tests, die langsamsten Schritte, Trends bei der Wartezeit in der Queue, Laufzeiten je Schritt — automatisch gesammelt, ohne dass Sie irgendetwas instrumentieren, damit die Factory (oder Sie) weiß, was als Nächstes dran ist.

Jede Antwort über MCP und eine API

Runs, Logs, Testergebnisse und Flottenstatus sind über CLI, HTTP-API und einen MCP-Server erreichbar — Ihre eigenen Agenten und Skripte steuern Hive also direkt, statt eine Weboberfläche abzugreifen.

Betrieben von einer deutschen GmbH, auf EU-Servern

Hinter Hive steht eine GmbH in Bayern, und der Control Plane läuft auf einem Server in Deutschland. Kein Tracking, keine Webanalyse und kein Cookie-Banner auf dieser Seite — die Datenschutzerklärung sagt das, weil es stimmt.

Kompatibel mit

Alles dabei für den Stack, den Sie schon haben.

Kein Plugin-Marktplatz zum Zusammenbauen. Das hier ist erstklassig in der Pipeline-Sprache verankert — Caches, Auswertung der Testberichte und Integrationen sind bereits erledigt.

Sprachen

Lint und Test, schon verdrahtet

Eine Zeile je Lane in Ihrer Pipeline, und Runner, Cache-Key und Berichtsformat kommen mit — kein Shell-Skript, das Sie pflegen müssen.

  • Python
  • pytest
  • ruff
  • uv
  • TypeScript
  • React
  • Vite
  • vitest
  • ESLint
  • pnpm
  • Rust
  • cargo
  • nextest
  • clippy
  • Go
  • Playwright

Ergebnisse

Fehler als Daten, nicht als Scrollback

Testausgaben werden serverseitig geparst: Ein roter Run benennt die fehlgeschlagenen Tests, statt Ihnen ein Log hinzulegen. Go streamt nativ; pytest und vitest streamen über einen einzeiligen Marker, sodass sich der Grün/Rot-Balken bewegt, während die Suite noch läuft. Trends zu Instabilität und Laufzeit sammeln sich je Test von selbst an.

  • go test -json
  • JUnit XML
  • live markers
  • coverage.xml
  • ESLint JSON
  • ruff JSON

Bauen & ausliefern

Vom Dockerfile bis zum Rollout

Images bauen auf BuildKit gegen einen knotenübergreifend geteilten Layer-Cache in der Registry und werden dann ausgerollt — mit tatsächlich geprüftem Rollout, inklusive des GitOps-Commits, der ihn eine Reconcile-Runde überleben lässt.

  • Docker
  • OCI
  • BuildKit
  • Kubernetes
  • ArgoCD
  • CycloneDX
  • Trivy

Wo Sie arbeiten

Es lebt in Ihren Werkzeugen

Checks, Status und PRs landen in GitHub. Tickets bewegen sich in Linear — ein Agent kann eines übernehmen und den PR dazu öffnen. Und Hive stellt seine eigenen Werkzeuge über MCP bereit, sodass Ihre Agenten es direkt steuern.

  • GitHub
  • GitHub App
  • Linear
  • MCP
  • Starlark
  • PostgreSQL
  • S3

Modelle

Ihr Key, Ihr Anbieter

Agenten authentifizieren sich als Sie — mit einem Codex- oder Claude-Abo, einem OpenRouter-Key auf ein Modell Ihrer Wahl oder mit Cursor. Die Kosten werden je Session gegen Ihr eigenes Konto ausgewiesen, zu den Preisen Ihres Anbieters.

  • OpenAI Codex
  • OpenRouter
  • Anthropic Claude
  • Cursor
  • DeepSeek
  • GLM

Nicht dabei? Jeder Schritt ist ein Container, der einen Befehl Ihrer Wahl ausführt — was in irgendeiner CI baut, baut auch hier: Java, C++, Elixir, was auch immer Sie einsetzen. Die Namen oben sind die, für die Hive optimiert ist, nicht die, auf die es beschränkt wäre.

Warum Hive

Ihre heutige CI meldet den Fehler. Hive behebt ihn.

HiveJenkinsTeamCityGitHub Actions
Repariert eigene FehlschlägeKI-Agenten-Schwarm → Fix-PRNeinNeinNein
Pipeline-KonfigurationStarlark (typisiert, wiederverwendbar)Groovy-DSLKotlin-DSL / UIYAML
Kosten auf eigener HardwareKostenlos — keine Nutzer- oder Agent-GebührKostenlos + Ihre Betriebszeitca. 350 $ / Agent / JahrEigene Runner, trotzdem pro Nutzer
WartungsaufwandNichts zu betreiben — das machen wirPlugin-Ökosystem = Ihr ProblemMittelVerwaltet (nur Cloud)
Build-CachingWarme Images + Template-DBsSelbst bauenTeilweiseCache-Action (langsam im Großen)

Preise

Kostenlos auf Ihrer Hardware. Nach Verbrauch auf unserer.

Eigene Runner

Kostenlos

Ihre Hardware, unser Control Plane

Binden Sie die Maschinen an, die Sie ohnehin haben. Keine Compute-Rechnung.

  • Verwalteter Control Plane und UI — kein Betriebsaufwand für Sie
  • Runner-Installation als Einzeiler: Linux, macOS, Windows
  • Unbegrenzte Pipelines, unbegrenzte Runs
  • Warme Images & Template-DB-Caching auf Ihren eigenen Platten
  • Eigener Modell-API-Key für die Factory
Auf die Warteliste

Booster-Packs

CPU-Minuten

50.000 pro Monat gratis während der privaten Beta

Kapazität mieten, wenn Ihre eigene ausgeht — oder ganz ohne eigene Hardware starten.

  • Packs sind Rechenzeit, kein Geldguthaben — eine CPU-Minute bleibt eine CPU-Minute
  • Preise folgen unseren Hardwarekosten; was Sie bereits halten, wird nie neu bewertet
  • Millisekundengenau abgerechnet, nicht auf ganze Minuten aufgerundet
  • ARM-Runner kosten 0,32× — dieselbe Arbeit, ein Drittel des Guthabens
  • Harte Limits: Ein leeres Guthaben stellt Arbeit in die Warteschlange, statt zu überraschen
  • Optionaler Speicher für Artefakte, Images und Test-DBs auf unserer Hardware
Auf die Warteliste

Enterprise

Auf Anfrage

Reservierte Kapazität und die Unterlagen, die Ihr Einkauf sehen will.

  • Reservierte Booster-Kapazität und bevorzugtes Scheduling
  • SSO/SAML, RBAC, Audit-Logs
  • Cluster-übergreifendes Scheduling & Fair-Share
  • Priorisierter Support & SLA
  • Migrationshilfe von Jenkins/TeamCity
Sprechen Sie uns an

Packs werden in CPU-Minuten verkauft, nicht in Euro. Was ein neues Pack kostet, bewegt sich mit dem Hardwaremarkt. Was Sie bereits halten, dagegen nicht — eine CPU-Minute, die Sie letztes Jahr gekauft haben, kauft auch heute noch eine CPU-Minute. Zur Einordnung: Allein das kostenlose Beta-Kontingent ist 12× so groß wie das Gratis-Kontingent von GitHub Actions, und wir rechnen millisekundengenau ab, während dort jeder Job auf eine volle Minute aufgerundet wird.

Abgerechnet werden Rechenzeit und Speicher, die Sie auf unserer Hardware tatsächlich nutzen — nie pro Nutzer, nie pro Build. Die endgültigen Preise nennen wir zum Start; wer auf der Warteliste steht, bekommt Early-Bird-Konditionen und ein Mitspracherecht.

FAQ

Fragen, beantwortet.

Wie funktioniert die selbstheilende Factory genau?

Wenn ein Run fehlschlägt, sammelt Hive Logs, Diff und die fehlgeschlagenen Checks und schickt einen KI-Agenten mit diesem Kontext los. Der Agent reproduziert den Fehler, schreibt einen Fix, lässt die betroffenen Checks erneut laufen und öffnet einen PR auf Ihrem Branch, mit der Diagnose im Anhang. Sie prüfen und mergen wie bei jedem anderen PR — ohne Sie landet nichts.

Wird mein Code an Dritte übermittelt?

Nur an den Modell-Anbieter, den Sie konfigurieren, und zwar mit Ihrem eigenen API-Key. Hive speichert Ihren Code nicht und trainiert nicht darauf. Ausgecheckt wird auf den Runnern, die Sie anbinden — mit eigenen Runnern berührt der Code unsere Hardware also überhaupt nicht. Artefakte, Images und Testdatenbanken bleiben auf Ihren Platten, sofern Sie sich nicht ausdrücklich für Speicherung bei uns entscheiden.

Wer betreibt Hive, und wo läuft es?

Hive wird von der Pulsar-Projekte GmbH betrieben, einer deutschen Gesellschaft mit Sitz in Bayern. Der Control Plane läuft auf einem Server in Deutschland; diese Marketing-Seite wird als statische Dateien über Cloudflare ausgeliefert. Es gibt hier keine Webanalyse, kein Tracking und kein Cookie-Banner — die Datenschutzerklärung führt im Einzelnen auf, was verarbeitet wird und auf welcher Rechtsgrundlage.

Was kostet der Betrieb der KI-Agenten?

Sie bringen Ihren eigenen Modell-API-Key mit, die Token-Kosten gehen also direkt an Ihren Anbieter zu dessen Preisen — ohne Aufschlag. Hive weist die Token-Kosten je Fix aus und lässt Sie harte Tageslimits setzen, damit keine überraschenden Rechnungen entstehen.

Brauche ich eigene Hardware?

Nein — Sie können sie aber einsetzen, und dann ist es kostenlos. Wir hosten den Control Plane und die Oberfläche; wo die Arbeit läuft, entscheiden Sie. Binden Sie eigene Maschinen als Runner mit einem Einzeiler an (Linux, macOS, Windows), mieten Sie Kapazität als Booster-Packs, oder mischen Sie beides und lassen die Warteschlange auf unsere Kapazität überlaufen, wenn Ihre voll ist.

Kann ich Coding-Agenten auf meiner eigenen Maschine laufen lassen?

Ja, und das ist der Normalfall. Ein Agent, den Sie auf Ihre Workstation starten, bekommt dort ein echtes Git-Worktree — Ihr Checkout, Ihre Toolchain, Ihre Zugangsdaten — es wird also nichts hochgeladen. Derselbe Agent läuft stattdessen containerisiert auf gemieteter Kapazität, wenn Sie Ihr Notebook zurückwollen oder zehn Agenten gleichzeitig brauchen; Sie entscheiden das pro Aufgabe. In beiden Fällen beobachten und steuern Sie ihn im Browser.

Was ist ein Booster-Pack?

Rechenzeit, die Sie minutenweise bei uns mieten, statt Hardware zu kaufen. Braucht ein Run Kapazität, die Ihre eigenen Runner nicht haben, startet Hive eine VM, führt die Arbeit dort aus und beendet die Abrechnung, sobald sie heruntergefahren ist. Sie sehen, was jeder Run gekostet hat, und ein leeres Guthaben stellt den nächsten Job in die Warteschlange, statt Ihnen still etwas zu berechnen. In der privaten Beta gibt es 50.000 CPU-Minuten pro Monat. Packs lauten auf Rechenzeit statt auf Geld: Eine Preisänderung wirkt sich darauf aus, was ein neues Pack kostet, nie auf das, was Sie bereits halten.

Muss ich meine bisherige CI ersetzen, um Hive auszuprobieren?

Nein. Ein Repository nimmt mit einer einzigen Datei teil, und Hive startet im Shadow-Modus: Es meldet seinen eigenen Status und verlangt nichts, Ihre bestehende Pipeline entscheidet also weiterhin über jeden Merge. Sie vergleichen beide an echten Commits, so lange Sie möchten. Hive zu einem Pflicht-Check zu machen, ist eine separate Entscheidung in den Einstellungen Ihres Repositories — und unser eigener Onboarding-Leitfaden rät ausdrücklich, die alte CI erst abzuschalten, wenn eine Preflight-Prüfung sauber durchläuft. Fangen Sie mit einem Repository und einem Job an — eine brauchbare Pipeline sind wenige Zeilen — und weiten Sie es aus, wenn es sich bewährt hat.

Kollidiert das mit Claude Code, Cursor oder Codex?

Nein — Hive führt sie aus. Die Agenten authentifizieren sich als Sie, mit dem Abo oder Key, den Sie ohnehin bezahlen: einem Claude- oder Codex-Abo, einem Cursor-Konto oder einem OpenRouter-Key auf ein Modell Ihrer Wahl. Ihre lokale Umgebung bleibt unangetastet, denn die CI läuft serverseitig und benötigt auf Ihrem Rechner keine Installation. Dazu stellt Hive über hundert MCP-Tools bereit: Sie starten Runs, lesen Logs und analysieren Fehler aus dem Editor und Agenten heraus, den Sie schon benutzen, statt in unsere Oberfläche zu wechseln.

Worin unterscheidet sich das von GitHub Actions?

Actions führt Ihren Workflow aus und gibt Ihnen ein rotes X. Hive führt Ihre Pipeline aus und gibt Ihnen einen Fix. Dazu kommen Pipelines als echter Code (Starlark statt YAML), warme Caches von Haus aus und die freie Wahl, auf wessen Hardware gearbeitet wird — auf Ihrer ohne Compute-Kosten, auf unserer minutenweise, oder auf beiden.

Ab wann kann ich mitmachen?

Hive ist derzeit in privater Beta. Wer auf der Warteliste steht, wird der Reihe nach eingeladen und bekommt Early-Bird-Konditionen; jeder Beta-Mandant erhält 50.000 CPU-Minuten pro Monat, um Jobs auf unserer Hardware auszuprobieren — rund 12× so viel wie das Gratis-Kontingent von GitHub Actions.

Hören Sie auf, Builds zu hüten. Das macht der Schwarm.

Kommen Sie in die private Beta. Binden Sie eigene Maschinen an und zahlen Sie nichts für Compute — oder arbeiten Sie auf unseren: Jeder Beta-Mandant bekommt 50.000 CPU-Minuten pro Monat.