Agentorrery
GitHubDownload

Mission control for your coding agents.

Run Claude Code, Codex and the other agent CLIs you use across every project and machine you own, from one place. Delegate the work, see who is doing what with which plan, get proof with every finished task, and answer what needs you from your phone.

RunsClaude CodeCodexOpenCodeGemini CLICursor CLIGrok CLIPiGoogle Antigravity

The console's 3D space. Five projects drawn as planets with their agents beside them and task models above them; a roster of agents on the left; a Needs you list on the right with four items lettered A to D: a permission for a test run, a question about a webhook secret, a failed task and a result to review, each circled in amber in the scene.
The space on a demo machine: five projects, eight agents at work, and four things circled in amber that need you.
Your CLIs, your accounts
orrery has no model of its own. It runs the agent CLIs already installed on the machine, signed in to your own plans and keys.
On your machines
Each machine keeps its own SQLite database. The console listens on 127.0.0.1 until you open it to your network.
You set what agents may do
Agent by agent: ask before acting, approve reading and editing on its own, or approve everything. A change outside the project always waits for you.

What you get

Less time watching terminals, more time on your own work.

Every agent you run, in one place

Claude Code, Codex and six more CLIs run as agents, across all your projects. The console opens on a live 3D space: projects are planets, agents stand beside their work, and each task floats above its project as a model of its kind.

  • Pick the runner and model agent by agent, and change either later.
  • A security audit, a test run or a release looks like what it is, so you can tell the work apart at a glance.
  • Only what needs you is circled in amber: a permission, a question, a result to review, a failure.
An agent's page: payments-audit, working, on the Codex runner. At the top its open question to you, about rotating a webhook secret, with three answers to pick; then its latest outcome, the task it works on now with the plan it reported (two of four steps done), and where it runs: project atlas-api, machine studio, Codex.
An agent reads as a digest: what it asks you, what it last did, its task and plan, where it runs.

Delegate, and see who is doing what

Message the root agent of a machine, or a project's lead, and they break the work into tasks and hand it out. The Tasks page shows every task with its agent and machine, the plan the agent reported and how far along it is.

  • Agents carry tags for what they know, so new work goes to the agent that already knows the subject.
  • A queued task can be moved to another agent; a running one stays where it is.
  • Agents message each other by name. You stop being the copy and paste between them.
The Tasks page. A Needs you section with a task to review, with its evidence and pull request, and a failed task with its error in words; a Working section where each task shows its agent at its machine, its latest note and plan progress such as Plan 3 of 5, with subtasks nested under their parent.
The Tasks page: who works on what, at which machine, how far through their plan.

Every finished task brings its proof

An agent finishes a task with its evidence: screenshots of the change working, the test runs with what passed and failed, files, and the pull request with its checks. Review it on the task before you merge.

  • A task that changed UI code is not accepted without a screenshot, nor changed code without a test run.
  • When a runner fails, the task fails: an error is never passed off as a result.
A finished task waiting for review: its summary, then its evidence: a pull request with checks passing, two test runs with their pass and fail counts, a passed security audit, and screenshots of the change in a dark and a light theme; an Accept button and a box to send it back.
A task waiting for review, with its pull request, test runs, a check and screenshots.

Answer from your phone

Tasks and conversations, with what needs you first. Approve a permission or answer a question in one tap, read a result, or message any agent, from the phone app or a phone's browser.

  • Pair a phone by scanning a QR code from the console.
  • Away from home, reach your machines over Tailscale, set up from the app.
A phone showing a permission request from an agent with Allow once, Always allow and Deny, above the task's plan and progress.
What needs you, first, on the phone.
A phone showing a conversation with the root agent, with chips for the task, the agents and the pull request it mentions.
Message any agent from wherever you are.

Checks and automations with plugins

Plugins are tools you switch on per project: a security audit of every pull request that reports back as a check and a comment, an adversarial review, UI screenshots, issues from GitHub, Jira or Trello. Run them on a schedule, on an event, or ask an agent to.

  • The Workflows page reads as a sentence per row: when this happens, run that, for this project, on this machine.
  • Agents can write a project's own plugin, with tests, for you to switch on.
The Workflows page, Checks tab: the checks switched on for each project, then one row per plugin read as a sentence, for example: when pr_opened is announced, does queue a task from audit.md, for every project, runs on studio.
Checks on each project, each read as a sentence: when, does, for, runs on.

Across machines that are not the same

Join the computers you own into one cluster: a laptop, a Mac that can build for iOS, a box with a GPU. Tag what each can do, and work lands on the machine that has what it needs.

  • Machines join with a code; the links between them are encrypted with TLS 1.3.
  • Each machine keeps its own projects and agents. The space on any of them shows all of them.
An example cluster. A task that needs ios-development lands on the Mac; the GPU work stays on the Linux box.
  • studioLinux x64

    gpudocker

    Runners
    Claude Code, Codex, Gemini CLI
    Projects
    ranker, handbook
    its own root agent
  • macbookmacOS, Apple silicon

    ios-development

    Runners
    Claude Code, Cursor CLI
    Projects
    atlas-ios, atlas-web
    its own root agent
  • desk-pcWindows x64

    windows

    Runners
    Codex, OpenCode
    Projects
    atlas-api
    its own root agent

Your phone pairs by QR code and reaches the machines on the same network, or from anywhere over Tailscale.

The model

Four things to learn.

Everything in the console is a project, a task, an agent or a machine. You do two things with them: send a message, or create a task. A conversation is how you see either.

A piece of work, from your message to its result
  1. You message the root agent
  2. Root agent routes it to a project
  3. Lead plans it as tasks
  4. Agents work, and ask you when they must
  5. Summary with screenshots, tests and the PR

How it works

From install to the first result.

  1. Install it on a machine

    The desktop app, or the daemon on its own. The welcome screen creates your account, sets up the agents folder and checks which agent CLIs are installed and signed in.

  2. Add your projects and machines

    Point orrery at folders you already work in. Join more machines with a join code, and pair your phone with a QR code.

  3. Message the root agent, or a project's lead

    Say what you want done, or create a task yourself. The root agent routes the work across projects and machines; a lead plans it for its project and hands it to agents.

  4. Answer what needs you, review what is done

    Permissions, questions and results to review come to you, in the console or on your phone. When one problem deserves your whole attention, hand the conversation to the runner's own CLI in a terminal and take it back later.

Before you download

What it needs, and what it does not do.

You need

  • Node.js 22 or newer (the desktop app brings its own when it finds none)
  • At least one agent CLI, installed and signed in
  • Linux x64 with glibc 2.35 or newer, macOS on Apple silicon, or Windows 10 or 11 x64

Limits

  • orrery brings no model and no plan of its own: what the agents can do, and what they cost, is up to the CLIs and accounts you give them.
  • It is built for one developer and the machines they own. There are no team accounts.
  • Not every runner can do everything: features such as approvals are offered where a runner supports them.
  • The builds are unsigned, and Intel Macs are not built.
  • The Android app and the iOS app are built from the source; neither is in an app store. A phone's browser works without them.

Get started

Put your machines in orbit.

These builds are unsigned. macOS will warn before it opens one, and you have to allow it yourself. They are built from the source by the release workflow on GitHub.

Daemon only

The server on its own, with the Erlang runtime included. It uses the Node.js on your PATH.

From source

With Erlang/OTP 28, Elixir 1.19 and Node.js 24, then open http://localhost:4000.

cd orrery
mix setup
bin/server

The first visit leads to the welcome screen, which creates your account, sets up the agents folder and asks which runners orrery may use.