Earned Autonomy for AI Agents

# You earn automation with test coverage

Give a mediocre model good tests and enough turns around the loop, and it will get there. The tests do the reasoning — so coverage, not model choice, is what earns the next of six autonomy levels. You decide when to raise it.

# Put your repo on autopilot

The autonomous development lifecycle (ADLC), self-hosted and yours: a fleet of AI agents triages issues, writes the fixes, opens the PRs, and merges them on green — so you spend your time on the work you actually love.

# You earn automation with test coverage

Give a mediocre model good tests and enough turns around the loop, and it will get there. The tests do the reasoning — so coverage, not model choice, is what earns the next of six autonomy levels. You decide when to raise it.

# A deterministic pipeline, not a prompt

Every fix runs the gauntlet — build, lint, test, and policy checks — before anything merges. Autonomy comes from a repeatable pipeline you can audit, not from trusting a model's good mood.

# From a big issue to a reviewed plan

Click Plan and the architect breaks an epic into a task DAG for you to approve before any work begins. You review the plan; the fleet executes it (ACMM L5–L6).

# The AI maintainer you own outright

Free, open-source, and self-hosted. Point it at your repo, bring your own model, and run the whole fleet on your own terms — no per-seat license, no data leaving your cluster.

Request a Hive See how it works Read the ACMM paper
90% per-package coverage gate, enforced on every build
— PRs merged in the last 90 days, fleet-wide
— agent PRs the pipeline rejected before merge (90d)
— merged PRs referencing a named CVE

The 90% coverage gate is enforced on Hive's own build. The other figures are live across every repo Hive manages — the fleet of public hives below — aggregated over their spokes' contributions. Learn how earned autonomy works.

Already running a hive? Open your dashboard · Learn the concepts

🐝
Live fleet status
Hives online —
Agents running—
Managed repos—
Contributors—click to help a hive Public hives— Available hives—click to request one

How Hive compares

## The ADLC platform you own outright

A new category is forming around the autonomous development lifecycle (ADLC) — agents that triage, code, review, fix, and ship across your repos, continuously. Contenders are everywhere now, from GitHub’s own coding agent to Devin to Microsoft Planner to open-source peers like Fullsend. Where Hive stands apart: it makes autonomy something a repo earns as its test coverage grows (the six-level ACMM ladder), enforces what agents can do at the network layer rather than on the honor system, and gives you a live dashboard over the whole fleet — not just activity buried in GitHub.

Capability | Hive | Fullsend | GitHub Copilot coding agent | Devin | MS Planner / Jira Rovo
--- | --- | --- | --- | --- | ---
Free & open source | ✓Apache‑2.0 · CNCF/KubeStellar | ✓Apache‑2.0 | ✗Paid subscription | ✗Paid / enterprise | ✗M365 / Atlassian license
Self-hosted / your infra | ✓K8s, LXC, Compose | ✓Self-host supported | ✗GitHub cloud | Hybrid Planning stays in cloud | ✗Vendor cloud
Bring your own AI & model | ✓Any OpenAI-compatible; self-host vLLM/llm-d | CLI-based Model per CLI | ✗Locked to provider | ✗ | Vendor models
Multi-agent, specialized roles | ✓Scanner, quality, architect, … | ✓6 agents: triage→code→review→retro | ✗Single agent | Subagents Delegation, not peers | Assignable agents
Enforced permissions at network layer | ✓MITM proxy + scoped tokens | Guarded paths Sandbox, not network-layer | Branch rules | Rule engine Agent-layer | Graph ACL inherit
Graduated autonomy levels | ✓ACMM L1–L6, advisory→auto-merge | ✗Human-in-loop, no maturity ladder | ✗ | Allow/Ask/Deny | ✗
Transparent AI cost & budget controls | ✓Per-model cost + weekly token budget | ✗ | ✗Opaque in license | ✗ | ✗
Trajectory / goal-drift review | ✓Intent-vs-transcript, injection-aware | Injection defense No drift review | ✗ | ✗ | ✗
Durable work ledger (DAG) | ✓Git-backed beads w/ dependencies | ✗GitHub issues/PRs are the state | ✗ | In-run | Task lists
Dashboard & fleet observability | ✓Live dashboard, governor, per-agent metrics, leaderboard | ✗GitHub-native only, no UI | In GitHub | ✓Vendor UI | ✓Vendor UI
Human-in-the-loop & audit trail | ✓PR holds, pause/resume, full audit | ✓Human in the loop, transparent | ✓Draft-PR review | ✓ | ✓
Auto plan decomposition + plan review | ✓Live at ACMM L5–L6 · decompose → review gate → stall-replan | Prioritize stage No review-gated DAG | Spec/plan | ✓Interactive Planning | ✓Work breakdown

✓ yes · partial · ✗ no. Competitor rows reflect each vendor’s public documentation as of 2026; comparisons are our own.

Hive now closes what used to be the one gap: general-purpose plan decomposition with a review-before-execution gate — live today at ACMM levels 5 and 6. Click Plan on any issue (or add the `plan` label) and Hive breaks the epic into an ordered sub-task DAG, holds it behind a human plan-review gate, and — when an approved plan stalls — detects the stall and re-kicks the architect to revise it, bounded by a per-plan replan cap. Devin, Planner, and others plan; Hive plans, reviews, and self-corrects — and it’s the option you own outright.

Watch

## How Hive works — and why not build your own

A walkthrough of the agents, the governor, and the guardrails that make Hive safe to leave running — and why standing up your own agent loop means re-solving problems Hive already handles.

How it works

## Coverage first, then autonomy

Point a hive at your repository and start at L1, where agents only advise. Strong test coverage is what earns the confidence to go further — but the autonomy level never rises on its own. You (the admin) choose to raise it, and only then do agents take on more: filing issues, opening hold-gated PRs, and eventually merging on green. Coverage tells you when it's safe to level up; the decision is always yours. A governor decides minute by minute how hard they work based on your queue depth. Hive doesn’t replace maintainers; it earns its way into the work.

01

### Issue filed

A bug report, feature request, or dependency alert lands on the repo.

02

### Triage

The scanner agent reads, labels, and assigns the issue within minutes.

03

### Fix agent

A specialized agent writes the fix in an isolated worktree, opens a PR.

04

### Coverage gate

The deterministic pipeline gates the merge — build, lint, and a per-package coverage threshold. Roughly 1 in 7 agent PRs is rejected here.

05

### Review

Reviewer agents check post-merge state, GA4 regressions, and invariant drift.

06

### Merge

PRs merge on green CI at the autonomy level you allow. No human approval needed at L6.

07

### Rerun

The loop restarts. Security patches, dep updates, and test fixes happen continuously.

Why Hive

## Automate the mundane, reclaim your time

Hive is not about replacing humans. Security patches, dependency updates, test fixes, and issue triage are essential but repetitive. Hive automates them so maintainers can spend time on outreach, adoption, innovation, and strategy — the things that are often neglected.

Hosted

### Get a hive for your project

Hosted on our infrastructure — no Kubernetes, no setup. Request one and invite contributors to run the agents.

Request a Hive

Prefer to self-host? →

Community

### Contribute compute to a hive

Lend your AI CLI to run agents for a public project via ClankeR, the contributor relay. Pick a public hive from the table below, run the contribute command, and ClankeR hands your CLI tasks to work — your GitHub username shows up as a live contributor on that hive with the PRs you land, not as a new hive. Earn trust tiers as you complete tasks and climb the leaderboard.

Start contributing
Deterministic

### A pipeline, not a prompt

Filtering, classification, and merge-gating are shell scripts that run before any LLM sees the work. Agents only get the judgment calls — and a coverage threshold decides what actually lands.

Learn the architecture

Get started

## Running in minutes

The recommended path starts with a hosted hive — no cluster or infrastructure required. Self-hosting is also fully supported.

Request a Hive Self-host guide
1

### Login with GitHub

Authenticate so we can provision your hive and install the GitHub App on your repos.

2

### Install the Hive App

Grant the Hive GitHub App access to the repositories you want maintained.

3

### Choose your autonomy level

Pick an ACMM level from L1 Inception to L6 Fully Autonomous. Start conservative, upgrade anytime.

4

### Connect your AI provider

On each agent card, pick the CLI (Claude Code, Copilot, …) and model, then authenticate — open the agent's terminal and run the CLI's login command, or use the card's Login button. Prefer local? Point agents at your own models via vLLM or llm-d — no provider account needed.

5

### Agents start working

Within minutes, agents begin triaging issues, writing fixes, and opening PRs. Watch from your dashboard.

Safety model

## Conservative by default

Every level of autonomy is opt-in. The deterministic pipeline gates every change before any AI or merge touches it.

- CI must pass before any PR merges. No exceptions at any ACMM level.
- Agents cannot push directly to main. All changes go through PRs with full audit trails.
- You control the autonomy level. Start at L1 Inception and upgrade when you’re ready.
- Deterministic pipeline filters before LLMs. Build, lint, test, and policy checks gate every change.
- All agent actions are logged. Full transparency in the dashboard and GitHub activity.
- Hosted hives are isolated. Your code stays in your repos — the hive reads issues and opens PRs.

Bring your own AI

## Runs the AI you already have

Each agent picks its own method and model. Use a subscription CLI, an API-key provider, or point agents at your own models — no provider account required for self-hosted inference.

Method | Type | Models | Authentication
--- | --- | --- | ---
Claude Code | CLI agent | Anthropic (Opus, Sonnet, Haiku) | Anthropic subscription — dashboard Login button or `/login` in the agent terminal
GitHub Copilot | CLI agent | Copilot catalog (Claude, GPT, Gemini) | GitHub device-flow login
Gemini CLI | CLI agent | Gemini | Google account or API key
Goose | CLI agent | Multi-provider | Provider API key
Codex | CLI agent | OpenAI | OpenAI login or API key
Aider | CLI agent | Multi-provider | Provider API key
Bob | CLI agent | IBM | CLI login
vLLM | Self-hosted inference | Your own models, your GPUs | None — no provider account
llm-d | Distributed inference on Kubernetes | Your own models, your cluster | None — no provider account
LiteLLM new | OpenAI-compatible gateway | Anything behind your LiteLLM endpoint | Endpoint URL + API key

## Active Hives

Want to help? Pick a public hive below and click its Contribute button to run its agents through ClankeR and contribute fixes to a hive of your choice. Your work shows up as tasks completed under your GitHub username, on that hive and on the leaderboard.

Loading hives...

## Cross-Hive Leaderboard

Loading leaderboard...

References

## Explore the ecosystem

Source code

GitHub repo

ACMM Paper

Autonomy framework

Architecture

How hive works

KubeStellar

Parent project

Get started

Request a hive

## Reading List

From the KubeStellar Medium — April 2026 onward.

View full list on Medium →

## Contribute to

Hive ID: ``

Help this project by contributing to open issues and PRs. Login with GitHub to request access — the hive owner will be notified and can approve your request.