Orbit — Agent Mission Control

Self-hosted mission control for coding agents.

Run coding agents on your own machines. Keep the plan, history, and controls in one self-hosted place.

Pre-1.0, active development MIT licensed Web + macOS + iPhone/iPad

You operate the control plane, runners, credentials, TLS, backups, and access controls. Orbit is not a managed SaaS or a no-setup autonomous service.

Decorative Orbit preview showing a durable task graph, an online runner, and an approval card
Illustrative product preview · replaceable via the public-site asset contract

Three launch scenarios

Keep agent work moving without losing the human thread.

These names and this order are the canonical launch copy. Each scene is something to verify, not a promise that an agent finishes without review.

Work that outlives a chat

Turn a multi-day migration, refactor, or test rescue into a durable task graph. Dependencies, comments, and session history survive context limits, restarts, and a closed browser.

Show
task list → dependency → resumable session → result and comment history

Parallel agents without checkout collisions

Split a backlog across runners and enable a separate git worktree per session. Review the diffs and choose what to merge; a worktree is file-collision isolation, not a security boundary.

Show
two tasks → isolated worktrees → diff review → human merge decision

Access to private infrastructure

Run a runner beside the repository, internal CLI, VPN, or cluster access it needs. Runners poll outward, and a risky command can stop at an approval card before it proceeds.

Show
private-network runner → command approval → transcript and outcome

90-second demo

Three scenes, one visible intervention point.

Use a tagged or explicitly named commit. Redact repository names, hostnames, tokens, cookies, internal URLs, and provider details before recording.

Watch the storyboard

The checked-in storyboard is the source of truth while a public recording is being prepared. It keeps the runner, repository, approval card, and human merge decision in frame.

Reserved media slot: an approved short GIF can be added under site/assets/product/demo.gif with a factual caption.

0:00–0:08
OpeningProject page + online runner. Say the category line and core promise.
0:08–0:32
Work that outlives a chatTask dependency, resumable session, result, and comment history.
0:32–0:56
Parallel agents without checkout collisionsTwo isolated worktrees, a diff, and a human merge-review action.
0:56–1:18
Access to private infrastructureRunner heartbeat, internal tool, approval card, transcript, and outcome.
1:18–1:30
ClosePre-1.0 boundary, tagged release, hardening guide, and limits.

Quick Start

From a trusted host to the first runner.

The complete operator path stays in the repository README and self-hosting guide. This page keeps only the decision points so it remains a small public entrance.

1

Start the control plane

Clone the repository, pin a reviewed tag, create two independent secrets, and run Docker Compose on a host you control.

2

Add a runner

Use Infrastructure → Add → Register a machine for the machine that has the checkout, tools, VPN, and agent credentials. Approve the browser enrollment.

3

Create a workspace and first task

Point a workspace at the checkout, start with the tiny demo fixture if useful, and review the transcript, approvals, and result.

trusted host · shell
# Pin a reviewed release before deployment
git clone https://github.com/jianghailong-xy/orbit.git
cd orbit
git checkout <release-tag>
cp .env.example .env
# Set unique JWT_SECRET and PROVIDER_SECRET_KEY in .env
docker compose up -d --build
docker compose ps

The included gateway is HTTP-only and intended as a starting point. Put HTTPS and access controls in front before network exposure; operators own backups, monitoring, host hardening, and least-privilege credentials.

Architecture & security boundary

Local execution, visible controls, honest limits.

Orbit coordinates and supervises agents. It does not turn an operator-managed runner into a sandbox or a hosted reliability service.

How the pieces connect

Web / macOS / iOS ── REST + SSE ──▶ Control plane + PostgreSQL tasks · history · approvals queue · audit · usage ▲ │ outbound poll │ Runner + local agent runtime optional git worktree
  • The control plane owns users, workspaces, projects, tasks, sessions, approvals, runners, and history.
  • Runners make outbound connections; the control plane does not require inbound access to a runner.
  • Worktrees reduce checkout collisions. Processes still inherit the runner OS account's permissions.

Before attaching sensitive infrastructure

Important: a worktree is not a security boundary, and an agent is not guaranteed to finish correctly without review, approval, or a human merge decision.

  • Use least-privilege runner accounts and credentials; isolate hosts when the trust boundary requires it.
  • Use HTTPS before network exposure, protect unique secrets, restrict the gateway, and test off-host backups and restore.
  • This is not a hosted service, HA guarantee, zero-data-loss promise, SLA, compliance certification, or enterprise support contract.
  • Provider billing, model features, resume behavior, and usage data vary by engine; the provider's bill is authoritative.

FAQ

Know what you operate.

Short answers for the first visit. The repository docs carry configuration and troubleshooting detail.

Is Orbit hosted for me?

No. You run the control plane and PostgreSQL, decide where it is reachable, and put TLS and access controls in front of the included HTTP gateway before exposing it to a network.

Do credentials leave the runner?

Supported agent CLIs use the runner's local configuration and credentials. The control plane stores coordination metadata and transcripts; provider behavior and billing remain the provider's responsibility.

Is a worktree a security sandbox?

No. It reduces checkout collisions. Processes run as the runner OS account and can access whatever that account can access.

What if a runner or browser goes away?

The task graph and session history live in the control plane. A runner that loses heartbeats is treated as offline; exact resume behavior varies by engine and provider, so verify the behavior you need.

Which runtimes are supported?

The control plane and runner know about Claude Code, Codex, Kimi Code, and OpenCode, plus configured compatible providers. Install and authenticate the runtime on the runner and start with orbit doctor.

What should I run in production?

Orbit is pre-1.0. Pin a tagged release, review upgrade notes and the hardening guide, and treat main as a development branch rather than a supported release.

Community & contribution

Bring a real deployment question.

Support is community-maintained and best effort. Sanitize logs and never post tokens, cookies, API keys, private hostnames, repository contents, or runner configuration.

Version & roadmap

Adoption gates before bigger promises.

Roadmap direction is public; delivery dates and production guarantees are not implied.

Current release posture

  • Orbit is a pre-1.0 open-source project under active development.
  • Pin deployments to a tagged release and review upgrade notes before changing versions.
  • The latest published release receives best-effort security fixes; main is a development branch and older releases are not supported.

Check the repository's Releases ↗ for the exact tag, checksums, known limits, and verification notes.

Direction, not dates

  • Now: repeatable clean-install evidence and one consistent version story.
  • Next: screenshot-led onboarding, operator configuration reference, public changelog, and stronger community operations.
  • Later: recurring schedules and inbound task sources, which are designed for but not built; v1.0 compatibility follows evidence gates.

Follow the full roadmap ↗ and maturity gates ↗.

Funnel we will measure next: visit → Quick Start click → runner online → first task. The site ships no tracking pixel; use GitHub/Pages traffic, tagged links, and sanitized operator evidence.