GitHub-native software production

File an Issue. Get a release.

No new workspace. Orbi runs the delivery line on the Issues already in your repository. GitHub stays the source of truth.

Start Cloud with GitHub

Register with GitHub and continue onboarding in Cloud.

Prefer to self-host? Run Orbi yourself ↗

Inspect how Orbi builds Orbi →
  • Independent review that fixes and re-tests
  • Only the reviewed commit merges
  • Frozen SHA, tag, release

How to write an ai-ready Issue (12 factors) ↗

From Issue to tagged release →

LINE 01 / RUNNING orbi-build/orbi
  1. SCOPE Epic + milestone define the release boundary
  2. ORDER Native blockedBy work starts when evidence says ready
  3. BUILD Issue #48 → PR #193 implement · test · review · fix · merge
  4. SHIP Release v0.2.0 frozen SHA · full gate · immutable tag
ORBI BUILDING ORBI · LIVE Inspect the public records →

orbi-build/orbiOrbi itself

0days running
0issues closed
0PRs merged
0releases shipped

orbi-build/orbi-websiteThis website

0days running
0issues closed
0PRs merged
0deploys shipped

orbi-build/orbi-cloudPrivateCloud control plane

0days running
0issues closed
0PRs merged
0releases shipped

Teams already running Orbi

AI agents write the code.
Shipping it still needs a system

As agents work for hours and run in parallel, the bottleneck moves. It is no longer typing code. It is deciding what should change, ordering dependent work, proving the result, controlling authority, and carrying an exact version into production.

Stronger agents make the production system more important, not less.

  1. 01Prompt→Long-running delegation
  2. 02One agent→Purpose-fit coordination
  3. 03Code output→Versioned outcomes
  4. 04Human supervision→Human decisions

How Orbi automates
GitHub Issue to tagged release

An Issue is the executable unit, but Orbi does not manage Issues in isolation. Epics and milestones hold scope. Dependencies order the work. Review and repair converge each PR. A Release Issue freezes the result into a version.

01Coordinate
EpicMilestoneScope

Group outcomes without letting the Runner mistake coordination for execution.

02Order
IssueblockedByReady

Use GitHub's real dependency graph. A task enters production only when its blockers close.

03Deliver
WorktreeAgentTestsReview + fixExact-head merge

A second session may patch the branch. Only its reviewed head is allowed to land.

04Release
Freeze SHAFull gateTag + release

Validate scope and the repository, then publish an immutable version—without an Agent improvising the release.

RECOVERY BUS

Process killed. Test failed. Commit not pushed. The same run, branch, worktree, and PR remain the scene for the next tick.

  • Open source (AGPL-3.0), free forever
  • Self-hosted — code never leaves your machine
  • Bring your own model

One Issue, reviewed
merged, and released

Issue #48 entered the real Orbi repository. An isolated run implemented it, a separate session reviewed the exact diff, PR #193 merged, and the work shipped in Release v0.2.0 with every Issue in scope verified item by item. The record is still inspectable because the record is GitHub.

Issue #1018 · PR #1023 · Release v0.5.17

Run this on your own repository

curl -fsSL https://aiready.sh | sh

Needs Python 3.14, git, gh, systemd, and a model endpoint. orbi doctor names whatever is missing.

Prefer to run the four steps by hand
git clone https://github.com/orbi-build/orbi.git && cd orbi
uv tool install --force --reinstall --editable --python /usr/bin/python3 .
cp .orbi.example.toml orbi.toml
orbi setup --config orbi.toml
Start Cloud with GitHub Read the setup guide

Prefer to self-host? Run Orbi on your own machine — the open source (AGPL-3.0) core is free forever. Setup guide ↗

Self-hosted, so your code
never leaves your machine

Orbi runs where the repository and model access already live. GitHub carries durable coordination and evidence; your machine carries the execution.

CONTROLGitHubIssues · PRs · dependencies · releases
RUNNEROrbipolicy · recovery · merge gates
EXECUTIONYour machinerepo · models · keys · tests

Bring your own model
Any OpenAI-compatible API, or local

The self-hosted, open source (AGPL-3.0) core ships today. Managed Cloud is Orbi's commercial managed service on the same GitHub-native ledger — with a founding partner offer.

SHIPPING TODAY

Self-hosted, free forever

Run Orbi on your own machine, GPU, and model credentials. The self-hosted delivery core has no platform fee.

  • Your repository and keys stay on your machine
  • Use local models or any supported provider
  • GitHub remains the durable production record
Self-host Orbi ↗

FOUNDING PARTNERS

Managed Cloud

First 3 merged deliveries are free — no card, no subscription. Connect GitHub to Orbi's proprietary hosted control plane: issues in, reviewed and released software out — without operating the delivery line yourself. Paid annually: Solo at US$24/month (US$290/year, save 17%; monthly billing US$29) with 100M tokens, or Pro at US$66/month (US$790/year, save 17%; monthly billing US$79) with 300M tokens; when the allowance runs out, new deliveries pause. Founding partners get 50% off forever, limited to 6 places. Core delivery reliability remains open source (AGPL-3.0).

  • Platform subscription pays for orchestration, recovery, and evidence
  • Model usage included: 100M tokens a month on Solo, 300M on Pro; when the allowance runs out, new deliveries pause
Start Cloud with GitHub

Where autonomous software
development goes next

Today, explicit GitHub tasks and Release Issues enter the line. The next horizon is a closed production loop: software supplies evidence from its own operation, Orbi turns that evidence into bounded work, Agents execute, and the result is measured after release.

  1. 01 / SENSERead the software

    Incidents, telemetry, user feedback, security findings, dependency drift.

  2. 02 / DECIDEPropose the next change

    Ground work in evidence; order it by goals, dependencies, risk, and cost.

  3. 03 / BUILDChoose the right intelligence

    One Agent for sequential work, coordinated specialists where work can truly split.

  4. 04 / PROVEMake confidence executable

    Tests, evaluations, simulations, security rules, and explicit approval boundaries.

  5. 05 / SHIPControl the blast radius

    Immutable releases, progressive delivery, automatic rollback, complete provenance.

  6. 06 / LEARNFeed outcomes back

    What worked becomes evidence. What failed becomes a reproducible task—not folklore.

Models will change. Agents will improve. The durable product is the layer that keeps intent, state, authority, verification, economics, and production evidence coherent across all of them.

Read the sourced competitor comparisons →

Orbi should not become another chat window or another board. It should become the control system above the Agents.

Questions people ask
before running an agent on their repo

01What does Orbi actually need to run?

Git, a POSIX shell, and API access to a model you already pay for. Orbi runs on Linux and macOS, on your own machine or your own server. No GPU is required — the model does the thinking, and it can be a hosted API.

Self-hosted: your repository, keys, and test suite stay on your machine; nothing is uploaded to us. Cloud: the runner clones the repository you authorize onto machines we operate for the duration of a delivery — see “Can you see my code?” on the Cloud page.

02Which AI models can I use?

Bring your own. Orbi drives the agent through your credentials, using any OpenAI-compatible API or a locally hosted model, and you can change your mind later without changing your workflow.

Model spend goes to your provider at your rate. Orbi charges nothing on top: the self-hosted core has no platform fee.

03How is this different from Copilot or Cursor?

Those are editors — they make you faster while you are typing. Orbi is what happens when nobody is typing: it takes an Issue from your backlog, works in an isolated worktree, and takes it through review and merge to a tagged release.

The difference that matters is what happens after the code is written. A second session reviews the exact diff, repairs it, and reruns the suite, and only the reviewed commit is allowed to merge. That review step is the product.

04Who reviews the AI's code?

Another Orbi session, running independently of the one that wrote the code, and it can change the branch rather than only comment on it. It reruns the tests against its own repairs and judges the repaired head.

You stay the last gate. The work lands as a normal GitHub pull request, so your branch protection, required checks, and human approvals apply exactly as they do today.

05What happens when a run crashes halfway?

The next tick returns to the same scene. Because the Issue, the pull request, the labels, and the run ID live in GitHub rather than in a process, a killed process or a failed test does not produce a second story about what happened.

Restarts reconstruct state from that record — the same run, branch, worktree, and PR.

06Is it really free, and what is Managed Cloud?

Open source under AGPL-3.0, or the Sustainable Use License if your policy rules out AGPL. Self-hosting is free under either.

Managed Cloud starts with GitHub: sign in, install the App, and subscribe. Paid annually, Solo is US$24/month (US$290/year, save 17%; monthly billing US$29) with 100M tokens and Pro is US$66/month (US$790/year, save 17%; monthly billing US$79) with 300M tokens. Founding partners get 50% off forever, limited to 6 places.

Install the self-hosted agent
and turn the lights off

Open source (AGPL-3.0). Self-hosted. Bring the model you already trust. Keep GitHub as the record, and let Orbi carry the work to a tagged release.

Real run: Issue #1367 · PR #1370 · v0.5.47