Control plane

A local web app for rupu — launch runs, watch them stream live, author agents and workflows, and review findings and coverage, all in one browser tab.

A web command center

The control plane is rupu's window onto everything it's doing on this host. One command opens a browser UI where you can observe every run, session, and event as it happens; control what runs and approve the steps that ask for it; and author your agents and workflows — without leaving the page. It's a thin web adapter over the same on-disk stores the CLI uses (your runs, agents, workflows, sessions, and the coverage ledger under ~/.rupu/), so the browser and the terminal are always looking at the same reality.

Start it with one command:

# serve the control plane and open it in your browser
$ rupu cp serve

By default it binds to 127.0.0.1:7878 and opens the URL in your browser when you run it interactively. Useful flags: --bind <addr> to choose a different address or port, --token <token> to guard the API with a bearer token, and --no-open to print the URL without launching a browser.

# bind a custom port and require a bearer token on /api/*
$ rupu cp serve --bind 127.0.0.1:9000 --token "$RUPU_CP_TOKEN" --no-open

Single binary, no setup. The web UI is compiled into the rupu binary — there's nothing to install or build. rupu cp serve serves the embedded app and reads your existing file-based stores directly; there is no database.

One local web app, hub for everything rupu is doing on this host.

Observe

The observability surface is the heart of the control plane — watch everything rupu is doing, live, in the browser.

Dashboard. An at-a-glance landing page with aggregated counts and charts, including multi-model token spend over time so you can see what each provider is costing you.
Runs. A list of every run, and a live run view that paints the workflow as a left→right graph with each step's status updating in place, plus a streaming transcript of the focused step as it works.
Live Events. A merged, real-time event timeline across everything on the host (streamed over server-sent events).
Sessions. Every session, with its transcript streaming token-by-token.
Coverage & Findings. The coverage status of each project and the findings filed against it, read from the coverage ledger.

Live updates arrive over server-sent events: a global stream for the event timeline and per-run streams for each run view. Runs the control plane started stream straight from the executor; runs started elsewhere (the CLI, a cron trigger, an autoflow) are tailed from their on-disk event log — so the same live view works no matter what kicked the run off.

Control

Beyond watching, the control plane drives rupu from the browser:

Launch runs. Dispatch a workflow or an agent with a target and a permission mode, straight from the UI.
Approve & reject gated steps. When a run pauses at a gate awaiting approval, approve or reject it in place. Approve marks the run for resume; a background resume worker inside rupu cp serve claims the marked run and finishes the gate.
Drive sessions. Send a prompt to a live session and watch the turn stream back as a chat.
Manage autoflows. See and manage your autoflows — the scheduled, trigger-driven workflows — from the same place you watch them run.

Same engine, new surface. The control plane doesn't reimplement any logic — launching, approving, and sending all route through the very same code the CLI uses. The browser is just another way in.

Author

You can edit your agents (.md) and workflows (.yaml) right in the browser. Agents open in a code editor; workflows open in the visual workflow editor.

The workflow editor is a single screen: a drag-and-drop DAG on top and the live YAML below, kept in lock-step. Drag node cards from a palette onto the canvas, wire steps left→right exactly like the Runs graph, and watch the YAML rewrite itself underneath — or type in the YAML and watch the graph reconcile as you go. YAML stays the source of truth: the graph is a projection of it, and every save passes through the same validation the orchestrator already applies.

Every expression field — a step's prompt, when, or for_each, a panel's subject — gets syntax highlighting and context-aware autocomplete. Inside {{ … }} it suggests the right vocabulary for where you are: declared inputs, the outputs of steps that run before this one (never a forward reference), loop locals like item inside a for_each, panel findings, and the available filters. A searchable expression reference panel surfaces the whole vocabulary and inserts at the cursor. Validity is checked live — at the field, on the node, and in a header badge — so mistakes show up before you ever save.

Multi-host

One control plane can drive rupu running on other machines, not just the one it's on. Register a remote host (any machine running rupu cp serve) and the central CP federates to it over HTTP — launch runs, agents, and sessions on a chosen host, observe and control them, all from one browser, with a Fleet → Hosts surface and host filtering on run lists. See Multi-host for setup and the transport roadmap.

← Triggers Multi-host →