Run many agents. Get called only when one needs you.

Everything an agent does, where you can see it.

This is the app as it ships, on a small demo repository. Projects on the left, one tab per task with the real Claude Code terminal, the panels the agent opens next to it, and the side panel with the checkouts, the tree and git.

• 1
• 2
• 3
• 4
• 5
• 6

1. 1

   Project rail

   One cell per agent, coloured by state: blue works, amber needs you, green finished and unread, red failed.

2. 2

   The task tab

   A real Claude Code session in Robion’s own pane host. Quit the app; it keeps running.

3. 3

   Panels the agent opens

   open_diff, open_file, open_url: the diff of the file it just changed, a rendered model, a dev-server preview — next to the conversation, not instead of it.

4. 4

   TASKS

   Tasks grouped by checkout: the main checkout and each worktree, with its uncommitted changes counted.

5. 5

   GIT

   Changes since the last agent turn, staged with checkboxes, committed and pushed from here.

6. 6

   Status line

   What needs you across every project, in one line.

• working
• needs you
• done, unread
• error

You are interrupted only when it matters.

A permission, a question, an error, or a finished turn nobody has read — that is the whole list. Everything else stays blue and quiet. Amber looks the same on every surface, so you can leave the desk.

⌘J

jumps to the agent that needs you: permissions first, then questions, then errors, then unread results.

OVERVIEW ⌘0

every task grouped by state; allow or deny on the tile.

Dock badge

counts every agent waiting for you; a notification when the window is not in front.

Phone push

allow or deny from the lock screen — end-to-end encrypted, no third-party service.

Stream deck

an amber key per ask: press to allow, hold to deny.

Terminal

robion-cli tui shows the same rail over ssh; y and n answer.

Each agent on its own worktree. Main stays yours.

A task starts in the main checkout or in its own worktree (claude --worktree), where the agent cannot reach the files you are editing. When it is done you review the diff, stage what you want, commit and push — or merge the branch with one of four strategies. No agent tool merges, updates or removes a checkout; those are your clicks.

Start

main checkout or own worktree, per task or as the project default; unattended tasks always get a worktree.

Review

the GIT section shows changes since the last agent turn; request_review flags them; a selected line range goes back to the agent as a prompt.

Commit & push

checkboxes stage, one field commits, push asks once — never with force, never an amend.

Merge

fast-forward, squash, merge commit or a pull request; three checks first: the worktree is clean, no agent is running there, no overlap with uncommitted changes in main.

Update

rebase onto the default branch; on a conflict, let an agent resolve it or open a shell — Robion never resolves one itself.

Tidy

worktrees with no task, merged or older than 14 days, listed for one-click removal.

Rules start work. The Steward plans it. The Inbox waits for your go.

Automations react to the outside world with no model in the path: a ticket assigned to you, a time of day, a desk that has been waiting on agents. They start a task, push to your phone, or leave a proposal in the Inbox. The Steward is a planning session that reads your projects, tickets and board and proposes the day.

steward · plan · weekdays 06:30
briefing: 4 projects · 3 open tasks · 2 tickets · board 7 cards
yesterday: 2 proposals accepted · 1 dismissed ("not now")
→ proposes ≤ 5 tasks into INBOX · level 2 starts the safe ones

A control panel per project, written by the agent.

Through set_controls an agent adds run buttons with hotkeys, sliders, toggles, selects, status lights, progress bars, checklists, tables and image tiles to a panel of its own, with a file or a URL as the panel’s viewport. Up to 12 named panels per project, 64 widgets each. The stream deck mirrors the run buttons; the phone shows the whole panel.

/robion:cockpit

reads package.json, a Makefile, docker-compose, cargo or go and builds the dev cockpit: dev server, tests, lint, build, release, with live status.

Run buttons

a command per button, hotkeys 1–9, a run state under its key: running, ok, error.

Sliders as parameters

a number control becomes -D key=value for OpenSCAD or ROBION_PARAMS for a Python model; move it and the viewport re-renders.

Machines start on a click

agent-defined commands run when you press the button, never on their own. That holds for printers and mills too.

The cockpit follows you.

Robion’s server is a small process on loopback. The Mac app, the phone, a terminal and a stream deck are all clients of it — and so is a Linux box you run it on.

Phone

A web app served by your Mac and exposed only inside your Tailscale tailnet. Chat with the agent, answer its question cards, read the diff, merge the worktree, tap the control panel — and get pushed when something turns amber.

More about the phone →

Terminal

robion-cli tui puts the rail and one live session in any terminal, over ssh too: j and k move, y and n answer, c starts a task, x ends one. robion-cli attach drops your terminal into any running task and Ctrl-] gives it back.

• $ robion-cli tui
• $ robion-cli attach "rate limiting"

robion-cli tui

$ curl -fsSL https://robion.app/install.sh | bash
…
robion-server 0.20.15 installed · systemd user service enabled
remote: https://raspberrypi.tail65c4b1.ts.net
pair:   https://raspberrypi.tail65c4b1.ts.net/pair?code=… (10 min)

The same cockpit for things you can hold.

Install the Maker Pack from settings and a project becomes a workshop: the agent turns an idea into a brief, keeps a design record, models in parametric code, renders it live, produces drawings, a BOM and a build sheet — and asks you at the gates, on the desktop or the phone.

• 1
• 2
• 3
• 4
• 5
• 6

1. 1

   The brief

   One paragraph: a bracket for the 40 mm rail, two M6 slots, a 3 mm fillet, printable without supports, and sliders for the wall and the hole count.

2. 2

   The agent builds its panel

   robion – set_controls defines four sliders, two buttons and the exported STL as the panel’s viewport; open_file shows it.

3. 3

   Sliders as parameters

   wall, fillet, holes, slot length: each becomes -D key=value for OpenSCAD. Move one and the model re-exports in about half a second.

4. 4

   Buttons with hotkeys

   export STL on 1, drawing (PDF) on 2, a material switch, a status with the mass. The stream deck mirrors the two buttons.

5. 5

   The model, live

   The STL in the 3D panel: triangles, size in mm, volume; fit, Δ original ghost, a print-bed check, SpaceMouse.

6. 6

   Files in git

   brief.md, bracket.scad, bom.md, parts/bracket.stl — every artifact derived from the source, versioned like code.

• 3D print

  from prompt to STL and a print plan for your own slicer

• electronics

  KiCad boards with DRC/ERC, gerbers, board-in-enclosure fit

• wood

  furniture-grade drawings, BOMs and finishing plans

• metal

  welded & bolted frames from steel profiles; sheet-metal flat patterns

• CNC & laser

  DXF and true-scale PDF at 1:1

• software

  where Robion started: agents, worktrees, diffs, reviews

• OpenSCAD
• build123d
• STEP · STL · 3MF · GLB
• KiCad + DRC/ERC
• Gerber · DXF · PDF
• SpaceMouse
• print-bed check

Honest limits: Robion never slices and cuts no toolpaths. A printed part ends at STL and a print plan; a CNC part at DXF and a drawing.

Thirty-two tools, all of them for showing and asking.

Every Claude Code that Robion launches gets a small MCP server. Its tools open panels, build controls, tail logs, read other terminals, start sibling tasks and write rules — always inside the task’s folder, never touching settings.

show

open_fileopen_filesopen_diffopen_urlrequest_reviewset_titleget_activity

preview

preview_screenshotdom_queryrequest_element_pick

controls

set_controlsget_controlsremove_controlscontrols_help

logs & terminals

set_log_sourcesquery_logsremove_log_sourcesread_terminalsearch_terminals

fan-out

start_taskwait_task

board

board_listboard_addboard_updateboard_moveboard_remove

automations

set_automationtest_automationlist_automationsremove_automationautomation_historyautomations_help

Rules the app never breaks.

The agent writes. You approve.

Robion never changes a file on its own; every change an agent makes is a diff you can read, stage or discard.

The pane host owns every process.

Quit the app; agents, builds and dev servers keep running. Nothing else to install — Node ships inside the app.

Tools show; they never steer.

Agent tools open panels, build controls and propose rules. They cannot change settings, and a rule an agent writes stays off until you switch it on.

Machines start on a human click.

Agent-defined commands run when you press the button — never on their own. That holds for printers and mills too.

Your code stays on your machine.

A local server on loopback; the phone only inside your tailnet. Anonymous usage counts go to PostHog in the EU and switch off in Settings → Privacy.

Amber means a human is needed.

And never anything else.

Runs on your Mac. Your code stays there.

macOS

Apple Silicon or Intel, signed & notarized build; Node ships inside

Claude Code CLI

the agents are your own Claude Code sessions, on your subscription

git

projects are repositories; worktrees, diffs and merges need it

OpenSCAD / KiCad

optional — for live model rendering and board checks

Python + build123d

optional — for BREP models, STEP and drawings

Tailscale

optional — for the phone and the Linux server

Questions

Is it free?

The download is free.

Windows or Linux?

The desktop app is macOS only. The server runs headless on Linux; you drive it from the phone and from robion-cli tui in a terminal.

Where does my code go?

Nowhere. Robion runs locally; the agents are your own Claude Code sessions on your machine.

Does Robion call a model itself?

No. Automations run with no model in the path. The only model run Robion starts is the Steward’s planning session — a Claude Code run you switch on.

Do I need to know CAD?

No. You describe the thing and tune sliders; the agent writes the parametric model. Knowing CAD helps, but the point is that it is optional.

Download Robion.

Free download. Signed and notarized DMGs, automatic updates from GitHub releases.

Latest release