early access · self-hosted orbitwork.sh

Don't replace your people. Elevate them.

Orbit is extra tooling for your AI harness: knowledge bases, a credential broker, a terminal kanban, and sandboxed 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
  Wire vault │ Decompose   │ Patch lock │ Update OAS
  to broker  │ auth epic   │ contention │ schemas

$ orbit instance start --ticket ENG-37
  ✔ sandbox booted · skills mounted · secrets brokered
  ▸ agent atlas picked up ENG-37
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 instance execution

dispatch a sandboxed agent against a ticket

orbit secret vault

brokered 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 · subscription 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 lock contention in instance scheduler

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 credential broker 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.
  • ▸Parkable. The sandbox suspends on the event bus instead of burning a 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 · sandboxed runtimes

One ticket in.
A verified
result out.

The expert writes the spec. Orbit composes the input and dispatches a sandboxed agent to implement it. The human stays the planner; the agent does the typing.

$ orbit instance start \
   --agent atlas \
   --ticket ENG-37
✔ sandbox booted · skills mounted · secrets brokered
▸ instance inst_8f2… running
instance · inst_8f2c agent: atlas · ticket: ENG-37
RUNNING

  1. Sandbox spawned

    boot

    Container starts from the Orbit image. Workspace and credentials bind-mount at runtime.

  2. Skills attached

    skills

    Required skills mount read-only into the agent's context.

  3. Secrets brokered

    broker

    The vault issues scoped, ephemeral tokens, never raw secrets.

  4. Task assembled

    execute

    The agent picks up the ticket and connects documented components exactly as specified.

  5. Gates run

    verify

    Tests, lints, and sign-off checks. The verifier moves the ticket on, not the agent.

isolation

per-instance

filesystem

scoped mount

network egress

policy gated

07 runtime · docker + lambda microvm

Run every client.
Mix nothing.

Every project runs in its own container. Orbit mounts read-only and tokens are namespaced per client, so cross-contamination stops being a rule someone has to follow and becomes a property the runtime enforces.

  • ▸Scoped access. Only mounted projects and credentials are visible.
  • ▸Controlled permissions. No accidental writes to unrelated repos.
  • ▸Reproducible environment. Same toolchain on every host.
  • ▸Auditable. Clear boundary around what Orbit can touch.

Client projects never contain Orbit internals. Skills, SOPs, and context live in Orbit and inject at runtime. Clients get the product, not the process.

Dockerfile · bind mounts · vault leases ● 
# build the orbit runtime
$ docker build -t orbit .

# launch a sandboxed instance for this project
$ docker run -it \
    --name orbit \
    -v /path/to/project:/workspace \
    -v ~/.ssh:/home/orbit/.ssh:ro \
    -v ~/.gitconfig:/home/orbit/.gitconfig:ro \
    -e ORBIT_API=https://orbit.internal \
    orbit

  ✔ orbit runtime booted
  ✔ workspace mounted · /workspace
  ✔ credentials read-only · /home/orbit/.ssh
  ▸ claude code · ready
  ▸ awaiting ticket dispatch
node · git · python · gemini cli
claude code · primary interface
no secrets baked in

isolation

per-project

orbit layer

read-only

client repo

orbit-free

--backend docker local

Run agents on your own machine. Same image, same isolation, zero cloud dependency.

--backend microvm cloud

Dispatch to AWS Lambda MicroVMs for remote, on-demand agent execution. Fan out a fleet without a server to babysit.

08 credential broker

Agents get
capability.
Not credentials.

Orbit's API holds the keys. When an agent needs to push, query, or call an API, it asks the broker and gets capability back: scoped, leased, and audited.

  • ●

    Zero-visibility secrets. Plaintext never touches the agent's context, memory, or logs.

  • ●

    Scoped leases. Tokens are bound to instance, ticket, and capability. Expire on completion.

  • ●

    Per-workspace isolation. Client A's keys can never be issued to Client B's sandbox.

  • ●

    Audit-grade telemetry. Every lease is logged, replayed, and queryable.

vault · broker pipeline 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 → broker lease        0.84
  [CONCEPT]  Integration & automation primitives   0.79

$ orbit kb compound "Orbit Codebase" --from ENG-37
  ✔ wrote node "MicroVM memory-limit prerequisite"
  ▸ linked · [[microvm-dispatch]] [[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-execute execute
    Pick a ticket, dispatch a sandbox, walk the lifecycle. The shipping skill.
  • 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 broker 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