---
title: "Robion — a cockpit for Claude Code agents on macOS"
description: "Robion runs your Claude Code agents as tasks in one window: a git worktree per task, review and merge, automations, a phone client and a live CAD workshop. Free."
url: "https://robion.app/"
lang: en
---

# Robion — a cockpit for Claude Code agents on macOS

> Robion runs your Claude Code agents as tasks in one window: a git worktree per task, review and merge, automations, a phone client and a live CAD workshop. Free.

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

Robion is a macOS app around Claude Code. Every task is a real session in its own tab, on its own git worktree if you want. Diffs, reviews, commits and merges happen in the same window; the phone, a terminal or a Linux server pick up where the Mac leaves off.

## Describe the part. Watch it take shape.

The agent writes parametric CAD — OpenSCAD, build123d — and Robion renders it live next to the conversation, with sliders the agent builds for you. Drawings, BOMs and KiCad checks follow from the same source. Same cockpit, same rules.

## 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.

- **Project rail** — One cell per agent, coloured by state: blue works, amber needs you, green finished and unread, red failed.
- **The task tab** — A real Claude Code session in Robion’s own pane host. Quit the app; it keeps running.
- **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.
- **TASKS** — Tasks grouped by checkout: the main checkout and each worktree, with its uncommitted changes counted.
- **GIT** — Changes since the last agent turn, staged with checkboxes, committed and pushed from here.
- **Status line** — What needs you across every project, in one line.

## 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.

- **INBOX — Decisions, not noise** — Proposals waiting for a go, a rule an agent wrote, a finished turn with the agent’s last message. Accept, snooze until the next working day, edit the brief, or dismiss with a reason the Steward learns from.
- **AUTOMATIONS — Five triggers, six actions** — issue.created and issue.updated from Jira, GitLab or GitHub; cron; the desk waiting on agents, or you sitting too long. Actions: start a task, push, send text to an agent, press a run button, propose in the Inbox, ask the Steward. A rule an agent writes stays off until you switch it on.
- **STEWARD — A planner on a short leash** — A headless Claude Code run with a briefing the server wrote: open tasks, tickets, yesterday’s outcomes, your board. It proposes a handful of well-briefed tasks; at level 2 it starts the safe ones itself. No shell, no git, no other MCP servers.
- **BOARD — The list the Steward plans from** — todo, doing, done. Agents add cards (“remember to…”); a card starts a task and follows it to doing. The order in a column is the priority.

## 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.

### 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.

```sh
robion-cli tui
robion-cli attach "rate limiting"
```

### Linux server

The same server headless on an always-on box — a home server, a Raspberry Pi 5, a VPS. One-line install, pair with a link, and its projects join the rail next to the local ones. Updates switch atomically; running agents survive.

## 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.

- **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.
- **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.
- **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.
- **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.
- **The model, live** — The STL in the 3D panel: triangles, size in mm, volume; fit, Δ original ghost, a print-bed check, SpaceMouse.
- **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

Formats: 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_file, open_files, open_diff, open_url, request_review, set_title, get_activity
- **preview**: preview_screenshot, dom_query, request_element_pick
- **controls**: set_controls, get_controls, remove_controls, controls_help
- **logs & terminals**: set_log_sources, query_logs, remove_log_sources, read_terminal, search_terminals
- **fan-out**: start_task, wait_task
- **board**: board_list, board_add, board_update, board_move, board_remove
- **automations**: set_automation, test_automation, list_automations, remove_automation, automation_history, automations_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: https://github.com/biokys/robion-releases/releases/latest