early access · self-hosted orbitwork.sh

Don't replace your people. Elevate them.

Orbit is extra tooling for your AI harness: knowledge bases, a terminal kanban, decision plans, and cloud runtimes. Every operator becomes the planner behind a fleet of agents, so the judgement stays human while the agents do the lifting.

Get early access How it works
you become
the planner
agents handle
the execution
secrets exposed
zero
~ /workspace · orbit v0.1.0 
$ orbit board show
  ▸ ENG — Engineering

  TODO       │ IN PROGRESS │ IN REVIEW  │ DONE
  ───────────┼─────────────┼────────────┼─────────────
  ENG-42     │ ENG-37      │ ENG-31     │ ENG-29
  Cloud      │ Decompose   │ Patch lock │ Update OAS
  runtimes   │ auth epic   │ contention │ schemas

$ orbit runtime create --size medium
  ✔ machine booted · orbit logged in · claude ready
  ▸ runtime cloud-ab12 online
01 the discipline
▲ no slop

Output you'd stake your name on.

Your expert writes the spec. Agents decompose, assemble, and verify against it, held to the standard the expert would hold themselves to.

encoded in the system
◆ expert-led

The thinking stays with you.

You become the planner: architect, strategist, reviewer. Orbit holds the spec, the catalogs, and the verification so your intent survives every run.

encoded in the system
● force multiplier

Scale every person, not the team.

One senior engineer driving agents ships like five. One ops lead runs what used to need a department. Hire for new capability, not more of the same.

encoded in the system

One expert per domain. Agents do the rest.

One expert directs the agents. Their judgement stays; their output multiplies.

  • Software dev

    first vertical · deep templates

  • Operations

    SOPs · runbooks · escalations

  • Research

    literature · synthesis · briefs

  • Content

    drafting · review · publish

  • Business mgmt

    clients · proposals · billing

  • Customer support

    triage · respond · escalate

02 the loop

Define where
the business
is going.

Name the destination, take an honest read of where you actually are, and close the gap between them. Motion is not progress.

Verify, don't vibe.

  1. Define

    stage · 01

    Desired state, written down.

    Every domain, whether a feature, a system, or the business itself, gets a spec with verifiable criteria. No vision-board fluff, just acceptance you can answer yes or no.

  2. Snapshot

    stage · 02

    Current state, measured.

    Boards, metrics, dashboards, agent telemetry. Orbit takes a continuous read of where things actually stand, not where you hope they are.

  3. Close

    stage · 03

    Plan, execute, verify.

    Tasks decomposed to assembly-grade specificity. Agents glue documented components together. Verification gates every column transition.

03 one cli · the whole platform

Built for
the agent,
not the mouse.

Orbit is extra tooling for your AI harness. One binary exposes the whole platform. Every command is non-interactive and prints concise plain text, so an agent reads the output as easily as you do.

  • ▸Agent-first. Plain-text output, deterministic exit codes, no TUI to trap a bot.
  • ▸Composable. Pipe a tool into a map into a ticket. Capabilities snap together.
  • ▸One install. curl -fsSL https://orbitwork.sh/install.sh | sh
▸ orbit --help command families
orbit board kanban

terminal kanban: boards, tickets, links

orbit plan planning

surface a decision fork, get an answer back

orbit kb knowledge

recall + compound self-healing knowledge

orbit runtime compute

spin up a cloud machine, keep it till you kill it

orbit secret vault

encrypted credentials, never inlined

orbit tool integrations

wrap any HTTP API as a workspace module

orbit map data

jq-like JSON→JSON transforms, composable

orbit bucket storage

per-workspace S3 via presigned URLs

+ skill · playbook · template · repo · workflow stdout · plain text
04 kanban · in the terminal

The board
the expert
plans from.
Agents work from.

A first-class terminal kanban: boards, WIP limits, dependencies, and ticket links, all over the API. The expert writes the spec; agents pick it up and run.

  • ▸Epics, stories, tasks, and bugs, decomposed and linked.
  • ▸WIP limits enforced, dependencies surfaced.
  • ▸Spec methods built in: EARS, Gherkin, testable criteria.
try it $ orbit board kanban --watch
▸ ENG platform delivery board · WIP 5
WIP 5
TODO (6)
ENG-44 TASK · MED

Define vault rotation policy

@tino

ENG-45 STORY · HIGH

Acceptance criteria for billing portal

@tino

ENG-46 BUG · LOW

Tighten preview rendering on small terminals

—

+3 more

IN PROGRESS (4)
ENG-37 STORY · HIGH

Decompose auth epic into assembly-grade tasks

agent:atlas

ENG-38 TASK · MED

Wire ShadCN form primitives into onboarding

agent:atlas

ENG-39 TASK · MED

Generate OpenAPI client for fabric routes

agent:hyperion

+1 more

IN REVIEW (2)
ENG-31 BUG · URG

Patch reconnect storm in runtime relay

agent:hyperion

ENG-33 TASK · MED

Verify Knex migration for ticket-link

@tino

DONE (5)
ENG-29 TASK · LOW

Update OpenAPI schemas for boards

@tino

ENG-27 STORY · HIGH

Ship cloud runtimes v1

agent:atlas

+3 more

tab · switch workspace ←→ · switch board ↑↓ · cursor ctrl+c · exit
05 planning · decisions, not dead-ends

The agent asks.
You answer.
Nobody waits
in a TUI.

When a run hits a fork, Orbit surfaces a real decision: context, the choices, and a place to write feedback. It ships you a link, so you can answer from anywhere whenever it suits you. The agent parks and resumes on your call.

  • ▸Structured forks. Markdown context, single-choice, and free-text feedback blocks.
  • ▸Non-blocking. orbit plan present prints a URL and exits instead of holding the terminal.
  • ▸Event-driven. orbit event wait --plan returns the answers the moment they land, no poll loop.
$ orbit plan present ./decisions.json
  { "id": "pln_4c…", "url": "orbitwork.sh/p/…", "status": "open" }
$ orbit event wait --plan pln_4c…
plan · pln_4c9a awaiting operator

context

The auth epic needs a refresh-token strategy before ENG-37 can proceed. Rotation policy isn't pinned in the spec.

Which rotation policy?

notes · feedback

Cap the sliding window at 30d and revoke on password change

emits · plan.submitted Submit →
06 agents · cloud runtimes

One command.
A machine
to work in.

The expert writes the spec. Agents get somewhere to build it: a cloud runtime with its own compute and filesystem. The human stays the planner; the agent does the typing.

$ orbit runtime create \
   --size medium
✔ machine booted · orbit logged in · claude ready
▸ runtime cloud-ab12 online
runtime · cloud-ab12 size: medium
ONLINE

  1. Runtime requested

    create

    You, or an agent, ask for a cloud runtime and pick a size.

  2. Machine boots

    boot

    A fresh machine starts from the Orbit runtime image and dials out to the relay.

  3. Logged in

    login

    The orbit CLI runs as you and Claude Code picks up the workspace's login.

  4. Terminals attached

    work

    Open terminals from qu2, run Claude Code, install what the project needs.

  5. Killed when done

    kill

    It stays up until someone kills it. Then the machine and its login are gone.

isolation

per-machine

filesystem

its own disk

inbound ports

none

07 runtimes · your machines + cloud

A machine when
you need one.

A runtime is a machine your terminals attach to. Host one of your own computers, or ask Orbit for a cloud runtime and get a fresh box with its own compute and filesystem, logged in and ready for Claude Code. It stays up until you, or an agent, kill it.

  • ▸Not tied to a ticket. Spin up as many as you want, for whatever you're working on.
  • ▸Logged in on boot. The orbit CLI runs as you and Claude Code picks up the workspace's login.
  • ▸No inbound ports. The runtime dials out to the Orbit relay; nothing listens on the internet.
  • ▸Ports come to you. Anything it serves on localhost is forwarded to your laptop.

Agents use the same commands you do, so an agent can start a runtime for a piece of work and kill it when it's done.

orbit runtime · cloud ● 
# start a cloud runtime
$ orbit runtime create --size medium

  ✔ cloud-ab12 · medium · starting

$ orbit runtime list
  this-laptop   hosted   online
  cloud-ab12    medium   online

# attach a terminal from qu2, then
$ claude
  ▸ logged in · /workspace

$ orbit runtime kill cloud-ab12
node · git · gh · build tools
claude code · logged in
lives until killed

small

2 vCPU · 4 GB

medium

4 vCPU · 8 GB

large

8 vCPU · 16 GB

orbit runtime serve your machine

Host your dev PC and reach its terminals and localhost from a thin laptop anywhere.

orbit runtime create cloud

A fresh EC2 machine in Orbit's account, ready for Claude Code, gone when you kill it.

08 workspace secrets

Agents get
capability.
Not credentials.

Orbit's API holds the keys. When an agent calls an external API through orbit tool run, the API injects the key and returns the response.

  • ●

    Server-side tool secrets. Keys a tool uses stay in the API and never reach the agent's context or logs.

  • ●

    Named, not inlined. Tools reference secrets as {{SECRET_NAME}}; values are never returned by the CLI.

  • ●

    Per-workspace isolation. Client A's keys are never resolved for Client B's workspace.

  • ●

    Cloud runtimes are the exception. A cloud runtime holds your Claude login so claude just works there.

vault · tool run enforced at the API
09 knowledge · self-healing memory

Knowledge that
grounds every
agent, and
heals itself.

Build knowledge bases on the fly and they're instantly available to your whole team and every agent. Each run grounds in the KB before it acts, then compounds what it learned back in. The memory sharpens with every task.

  • ▸Ground before acting. Agents recall the source of truth before touching a thing.
  • ▸Compound after learning. New, non-obvious facts get written back as nodes.
  • ▸Hybrid retrieval. Vector + lexical + exact-match ranking, hydrated in one call.
  • ▸Team-wide. One workspace KB, shared by every person and every agent.
▸ kb · "Orbit Codebase" 247 nodes · hydrated recall 
$ orbit kb recall "Orbit Codebase" --query "secret resolution"
  ▸ ranked 3 nodes · full bodies + tree neighbours

  [DECISION] Secrets & secret resolution        0.91
  [PATTERN]  Workspace secret → tool run injection  0.84
  [CONCEPT]  Integration & automation primitives   0.79

$ orbit kb compound "Orbit Codebase" --from ENG-37
  ✔ wrote node "Cloud runtime boot sequence"
  ▸ linked · [[remote-runtimes]] [[selfhost-install]]

grounded

before

compounded

after

stale reads

zero

10 automation · absorb any capability

If it has an API,
it becomes
a module.

No third-party UI to click through. Every external capability collapses into a composable primitive your agents can reach, then chains with the next one to automate the whole workflow.

orbit tool reach out

Custom integrations

Wrap any HTTP API as a saved workspace module. Templating resolves params and {{SECRET}} values server-side, so the agent calls the capability and never sees the key.

$ orbit tool run stripe.refund --param id=ch_9
orbit map reshape

Custom data mapping

jq-like JSON→JSON transforms with simple selectors. Reshape a tool's output into exactly the shape the next step needs, then save the mapper and reuse it.

$ orbit tool run x | orbit map run flatten
orbit bucket persist

Storage, built in

Per-workspace S3 object storage via presigned URLs. Agents read and write artifacts, logs, and uploads without ever holding a raw AWS credential.

$ orbit bucket upload ./report.pdf
▸ Wrap it in a playbook and an agent runs the whole chain, step by step.
11 marketplace · modular by design

Force multipliers
for the experts
you already have.

Templates encode your standards and skills package your judgement. Dialects abstract the data layer, and adapters reach the platforms you already use. Set it up once and it scales with you.

artifact templates · zero-start architecture

software · first vertical · operations · research · content templates rolling out
▤ v1

orbit-template-api

Express · TS · Postgres · Knex · Objection

REST API with OpenAPI, auth middleware, schema migrations, and a service catalog ready for agent assembly.

▦ v1

orbit-template-web

Vite · React · TS · ShadCN · Tailwind

Frontend scaffold with routing, an OpenAPI-generated client, and a documented component catalog.

▥ v1

orbit-template-android

Kotlin · Jetpack Compose · Material

Compose scaffold with design system, navigation graph, auth flow, networking, and component library.

▧ v1

orbit-template-ios

SwiftUI · Swift Concurrency

iOS scaffold with design system, navigation, auth, networking, and a documented component catalog.

skills · packaged judgement

  • orbit-spec spec
    EARS for stories, Gherkin for tasks. Catches ambiguity, inconsistency, incompleteness before code.
  • orbit-board kanban
    Kanban automation: create, link, and move tickets without leaving the agent loop.
  • orbit-feature ship
    Design, plan, ticket, build and ship a feature as one tracked workflow run.
  • orbit-branding design
    Apply Orbit's visual identity across assets, mockups, and generated artefacts.

database dialects

PostgreSQL primary
MySQL rdbms
SQLite embed
DynamoDB key-value

integration adapters

GitHub vcs
Linear issues
Stripe billing
Slack chat
Sentry obs
AWS cloud
12 signals · the read-only portal

Your whole
business.
Live on the wall.

Every agent reports as it works, and the signals roll up your org chart on their own. The read at the top is live, not three days old.

Read-only by design, built for the screen on the wall. You're watching the business, not operating it.

  • ▸Live signals. Every start, finish, and failure the moment it happens.
  • ▸Org-chart roll-up. Numbers aggregate up the reporting tree on their own.
  • ▸Read-only. A window into the business, not another dashboard to manage.
orbit · business portal live

agents running

9

work in flight

23

signals · today

1,284

Engineering

lead @tino

4 people 4 agents

shipping ENG board

Operations

lead @maia

3 people 2 agents

client onboarding

Support

lead @devon

5 people 3 agents

triage + respond

signal feed

  • ● ENG-37 · agent atlas · completed just now
  • ● OPS · onboarding SOP · step 4/7 00:12 ago
  • ● ENG-44 · vault policy · needs decision 02:09 ago
  • ● SUP-19 · agent hyperion · resolved 03:41 ago
13 exception-based steering

You're the
expert.
Not the bottleneck.

Encode your standards upfront so agents can self-evaluate. Orbit surfaces only the decisions that actually need a human, the ones your expertise was hired for.

metric drift

intervene

ambiguity

intervene

direction

decide

Everything else executes autonomously. Orbit handles the how. You own the what and the why.

orbit · operator dashboard live

throughput · ENG

12.4 tickets/day

▲ within band

verification pass

98.1%

▲ ok

spec ambiguity · ENG-37

Auth refresh policy not pinned.

! needs decision

cost · 24h

$4.18

▲ under budget

queue · awaiting operator

  • ! ENG-37 · refresh-token rotation02:14 ago
  • ● ENG-44 · vault policy review11:08 ago
  • ● queue otherwise green—
14 non-negotiables

What Orbit
won't compromise on.

Built for the people who'd rather elevate than replace, and ship at a multiple without diluting the standards or commoditizing the craft.

principle · 01

No third-party UI dependence.

If you have to click through someone else's interface, the system has failed. Every capability becomes an Orbit module your agents can reach, not one your mouse has to.

principle · 02

Everything modular and composable.

Capabilities are building blocks. Small, well-defined pieces that snap together to do things no single tool was designed for.

principle · 03

Continuously self-learning.

Orbit is plugged into live signals: AI news, security advisories, supply-chain threats. Awareness isn't a feature you turn on, it's part of the infrastructure.

principle · 04

Data sovereignty.

Your data lives in your infrastructure. You own the storage, the access patterns, and the lifecycle, instead of a dozen SaaS dashboards you can't audit.

principle · 05

Antifragile by design.

Every incident becomes a new SOP and every threat tightens the loop, so the system comes out of disruptions stronger than it went in.

principle · 06

Progressive autonomy.

The system earns agency. It starts supervised, proves itself over real work, and gets more scope as it does. Autonomy is granted, never assumed.

15 install · your infrastructure

One click to
stand up
the API.

Orbit's platform API deploys into your own AWS account from a single template. No keys change hands and no data leaves your perimeter. The CLI is one curl, and everything runs on infrastructure you own.

  • ●

    Launch Stack. A CloudFormation template spins up the API, database, and relay in-account.

  • ●

    Data sovereignty. Storage, secrets, and telemetry live in your account, auditable and yours.

  • ●

    Upgrade by tag. Bump the image tag; no data loss, no re-provisioning.

install · two moves self-hosted

01 · the api

Deploy to your AWS.

▸ Launch Stack ↗

CloudFormation · in-account · RETAIN policies

02 · the cli

One curl.

$ curl -fsSL \
  https://orbitwork.sh/install.sh | sh

macOS · Linux · Windows · signed binaries

no keys shared
no data egress
~$0.50 base infra
early access · self-hosted

Get Orbit
before everyone else.

Orbit is still taking shape. Drop your email and I'll send launch updates, early builds, and a heads-up the moment you can run it against a real board — no noise, just the milestones that matter.

▸

zero spam · classified by default · unsubscribe anytime