Orbital

Orbital works like Claude Code or Codex: ask it to research, plan, write, run commands, browse the web, or operate your tools.

The difference is that Orbital treats a local folder as a long-running project. It maintains the project's context on its own — where it left off, what's next, and how to do it — as files inside that folder. Every new task starts from everything learned before it, so work compounds instead of resetting to zero.

Orbital can also dispatch Claude Code, Codex, Gemini CLI, Cursor, and other CLI agents. Every dispatch briefs the worker on the project and the task and points it at the relevant files — you never re-explain the project. Orbital watches the run, reads the result against the project's context, and writes the outcome back in. The more you delegate, the more it knows.

Why a project agent?

People already use several capable agents at work — for the newest model, the leftover quota, or because a particular tool is better at the job.

But each agent works inside its own session, with its own context and history. When you move between sessions or tools, you become responsible for carrying the project between them: restating goals, explaining previous decisions, locating artifacts, and checking what was left unfinished. You end up working as their intern, ferrying context between them to keep your own project moving.

Orbital changes the unit of work from the session to the project.

A project agent stays responsible for the project across tasks, sessions, and worker agents. It maintains the shared context, decides what needs to happen next, delegates when useful, and records every outcome back into the project.

Individual agents complete tasks. Orbital keeps the project moving.

What it means to own the project

Orbital maintains five things that normally disappear or fragment between agent sessions — all of them as plain files in your project folder:

• State — what is true about the project now (PROJECT_STATE.md)
• Decisions — what was decided and why (DECISIONS.md)
• Lessons — what the project has learned (LESSONS.md)
• Work — what is running, completed, or blocked (queue.json). Every queued task ends Completed or Blocked — an agent that stops without a verdict gets re-prompted, then force-blocked with a reason. Nothing drifts away silently.
• Artifacts — what the agents researched, wrote, or built (the workspace itself, plus orbital/output/)

These stay in the local project and become context for future work. On a cold start, Orbital assembles them into its own system prompt before it acts.

When Orbital delegates, the worker is pointed at those same files and told they are authoritative — that briefing is rendered fresh on every dispatch, not something you paste in. Each worker also keeps its own memory file inside the project, so it accumulates its own experience across dispatches. When the task finishes, Orbital reads the result and records what matters back into the project.

The worker can change. The project continues.

How it works

1. Set up once — pick an LLM provider and paste your API key; optionally connect accounts your agents will need.

2. Create a project — name it, choose the local folder that holds your work, set an autonomy level.

3. Give Orbital a task — ask it to research, plan, write, code, browse, or work with files.

4. Orbital maintains the context — it keeps the project's state, decisions, lessons, queue, and artifacts current as the work progresses.

5. Orbital delegates when useful — it dispatches work to Claude Code, Codex, Gemini CLI, Cursor, or another CLI agent against the same accumulated context.

6. Every result becomes part of the project — future tasks begin on top of the work that came before them.

flowchart LR
    You["You"] --> Orbital["Orbital<br/>Project agent"]
    Orbital <--> Project["Local project folder<br/>State · Decisions · Lessons · Queue · Artifacts"]
    Orbital -->|briefs + dispatches| Workers["Worker agents<br/>Claude Code · Codex · Gemini CLI · Cursor"]
    Workers -->|results| Orbital
    Orbital -->|every task ends<br/>Completed or Blocked| Project
    Phone["Your phone"] -.->|approvals · check-ins| Orbital

A concrete example

Suppose you ask Orbital to research a competitor.

Orbital gathers the initial information and records the findings inside the project. It then dispatches the token-heavy technical investigation to Claude Code, which starts by reading the project's goals, constraints, and previous decisions from the project folder.

When Claude Code finishes, Orbital reads its findings and records the useful results back into the project.

A week later, you ask Orbital to draft a launch plan. It begins with that earlier research, the decisions made since, and the artifacts already produced.

You do not begin again with an empty chat. You continue the project.

Quick Start

1. Launch Orbital — the setup wizard guides you through two steps:

   Step 1 — LLM Provider: Pick a provider from the preset cards, follow the key-console link to grab an API key, and paste it in. Supports DeepSeek, Anthropic, OpenAI, Moonshot, and a dozen other providers.

   Step 2 — Connect Your Accounts: Link API connectors (Google Calendar, Drive) and sign in to sites your agents will need (Google, GitHub, etc.) so they can browse without getting blocked by CAPTCHAs. Everything here is optional and can be done later in Settings.

2. Create a project — give it a name, pick a workspace directory, set an autonomy level

3. Chat — type a task in the chat bar and the project agent handles it
4. Walk away — queue the next tasks; each finished one becomes context the next builds on

See the project stay under one manager

At a Glance

Why the project never loses its memory

• Accountable management loop — one agent plans, delegates, supervises, and records outcomes for the project
• Persistent project context — PROJECT_STATE.md, DECISIONS.md, LESSONS.md, and artifacts remain available across sessions
• Self-improving skills — the agent creates reusable skills from multi-step workflows and consults them before repeating similar tasks

Why you can swap agents mid-project

• Interchangeable workers — dispatch Claude Code, Codex, Gemini CLI, Cursor, or any CLI agent against the same project context
• Task queue — queue work per project and walk away; the agent drains items one at a time, marking each completed (with a summary) or blocked (with a reason); pause mid-queue to chat and steer, then resume

Why you can delegate without watching

• Workbench (beta) — the decisions and actions only you can take, flagged by the agent as it