Skip to content
OrbitOrbitOrbitv0.37.0
Early accessWhat shipped in the latest release

Agents write. Orbit delivers.

Orbit is a local-first runtime for coding agents. Ask the agent you already use for a change: it files a scoped task, Orbit runs it in an isolated worktree and lands it. Enable review after landing to check the results while the queue keeps moving. Every step is on the record.

Get started → Connect your agent
npm install -g @orbit-tools/cli

Needs Node 18+, one signed-in agent CLI, and the GitHub CLI for pull requests · macOS and Linux · MIT licensed

Runs the agent CLI you already sign in to
  • Claude Code
  • Codex
  • Antigravity
  • Grok
  • Copilot
  • Muse Code

Legacy Gemini CLI is also available. How agents are invoked →

Captured from the real dashboard on a live workspace, 2026-10-17. Counts are from that day.

Nothing runs until you approve

New tasks land in proposed. Your agent can file as many as it likes; each one waits for an explicit approval, from you or from your agent when you tell it to. You can also authorize a drain with --approve-proposed to promote tasks that pass task-pilot verification.

Code lands fast, with optional review

Changes land on your configured base branch after the required validation commands pass. Review is off by default. Enable delivery-code-review to review batches after landing and file findings as tasks. Review before landing is optional: set review.timing to before_pr or before_landing if you want a gate. Protected branches still enforce their required checks and approvals.

Every step is on the record

Task changes, workflow events, agent turns, and tool calls land in one audit record, with secrets redacted as it is written.

How it works

From a spec to merged code. You set the direction and judge the result.

Hand a spec to the agent you already use; the orbit-orchestrate skill makes it your orchestrator. It splits the work into tasks and queues them once you approve. Orbit ships them in parallel and, when you authorize it, merges each one as soon as branch protection allows. You come back to results, not a queue of pull requests.

  1. proposed
  2. backlogon your say-so
  3. in-progress
  4. review
  5. donecompletion authorized

You write the spec

Describe the outcome, not the steps: what should exist when it's done, and how you'll know. One command connects Orbit to the agent you already use.

orbit workspace init --mcp

Your orchestrator files the tasks

With the orbit-orchestrate skill, it splits the spec into scoped tasks with acceptance criteria, queues them in the backlog once you approve, and starts a drain.

orbit.task.add

Orbit ships and merges

Tasks run in parallel, each in its own worktree and sandbox with a lock on the files it touches. Each is checked against your gates, optionally reviewed by a second agent, and merged as soon as branch protection allows.

orbit run auto --complete

You review the outcome

Judge what landed against the spec: the merged changes, what the reviewer fixed, and every agent turn and tool call behind them. Anything off becomes the next task.

orbit web serve

Choose a second-agent review point: before PR with review.timing = "before_pr", before landing with review.timing = "before_landing", or after landing with orbit auto-task toggle delivery-code-review on. See Review layers for when each runs and what it blocks. With PR delivery, leave off --complete to stop at review with the pull request open; local delivery merges before stopping at review. Or ship your first task by hand. Optional read-only exploration and operator steering support work already in progress.

Why Orbit

Run agents in parallel without losing track of what they did.

Safe in parallel

Each task gets its own worktree, a lock on the files it declared, and an OS sandbox (sandbox-exec on macOS, Bubblewrap on Linux), so parallel runs never write over each other.

orbit run auto --concurrency 8

Traceable to intent

Every workflow commit carries its task ID, so any line of code leads back to the request and the acceptance criteria behind it.

git log --grep "$TASK_ID"

Auditable end to end

One record joins task changes, workflow events, agent turns, and tool calls, with secrets redacted at write time.

orbit task show "$TASK_ID"

Local-first, your accounts

Tasks and runs stay on your machine. Model traffic goes through the agent CLI and the account you already have, and Orbit sends no telemetry.

ls .orbit/

When you step away

The same pipeline, unattended. You choose where it stops.

orbit run ship and orbit run auto submit work, print a durable run ID, and return; the run carries on without you. Authorize completion per run with --complete, or configure the owner to finish distributed handoffs with workflow.distributed_completion = "done".

One task, one PR

default
orbit run ship "$TASK_ID"
Stops at
review, with the pull request open and not merged
With --complete
merges as soon as branch protection allows, then closes the task

Merge locally

orbit run ship "$TASK_ID" --mode local
Stops at
review, already merged into the base branch. No pull request.
With --complete
closes the task once the work is merged and pushed

Drain a backlog

orbit run auto --for 4h
Stops at
the end of the window; work already shipping still finishes
With --complete
covers every task the drain admits during the window

Go further

When one task at a time is not enough.

Browse the CLI reference →

Ship your first task.

Three commands install Orbit, set up this machine, and connect your agent to a repository; your agent's orbit-setup skill can run the third for you. Choose an enabled default crew as described in the installation guide. The fourth opens the dashboard, where you approve, ship, and review what your agent files.

Read the guide View on GitHub
  1. npm install -g @orbit-tools/cli
    install
  2. orbit init
    once per machine
  3. orbit workspace init --mcp
    in your repository
  4. orbit web serve
    open the dashboard