> ## Documentation Index
> Fetch the complete documentation index at: https://www.rumus.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Workspace

> Arrange multiple terminals, monitors, and notes on a zoomable canvas — and broadcast commands to several at once.

A **workspace** is a special tab type that opens onto an **infinite canvas** — a 2D surface where you can place cards (terminals, monitors, markdown notes), arrange them freely, and save the layout for next time.

Use workspaces for project-shaped work: one workspace per service, environment, or incident, with the terminals and monitors you need for that job already laid out.

## Cards

Everything on the canvas is a **card**. Three types ship today:

| Card              | What it is                                                                                          |
| ----------------- | --------------------------------------------------------------------------------------------------- |
| **Terminal card** | A shell session — local or remote — exactly like a terminal tab, just placed on the canvas          |
| **Monitor card**  | A live view of CPU, memory, disk, and GPU metrics for a host — see [Monitoring](/docs/remote/monitoring) |
| **Markdown card** | A free-form note for runbooks, command snippets, or status notes                                    |

Add a card with the canvas toolbar's **New Terminal**, **New Markdown**, or **New Monitor** buttons, or by right-clicking empty canvas space.

## Working with the canvas

<CardGroup cols={2}>
  <Card title="Pan" icon="arrows-up-down-left-right">
    Middle-drag, two-finger trackpad pan, or hold Space + drag.
  </Card>

  <Card title="Zoom" icon="magnifying-glass">
    Pinch on a trackpad, Ctrl/Cmd + scroll, or use the **Zoom in / Zoom out / Reset zoom** controls.
  </Card>

  <Card title="Move & resize cards" icon="up-down-left-right">
    Drag the card header to move; drag the corner to resize. Cards snap to a grid.
  </Card>

  <Card title="Stack and focus" icon="layer-group">
    Cards have a z-order. Click a card to bring it to the front; the canvas remembers your stacking.
  </Card>
</CardGroup>

### Toolbar actions

The canvas toolbar exposes a few helpers:

* **Select All** — select every card on the canvas (useful for [broadcast](#multi-terminal-broadcast)).
* **Fit to Screen** — zoom and pan so all cards are visible.
* **Auto Arrange** — re-tile cards into a clean grid.
* **Minimap** — toggle a small overview map in the corner for navigating large canvases.
* **Zoom In / Zoom Out / Reset Zoom** — adjust the zoom level.

### Multi-select

Multi-select cards by:

* **Drag-select** — drag an empty area of the canvas to draw a selection box.
* **Ctrl/Cmd + click** — toggle individual cards in the selection.

The most useful thing to do with multi-select is [broadcast a command](#multi-terminal-broadcast) to several terminals at once.

## Saving and switching workspaces

A workspace persists everything it contains: cards, positions, sizes, z-order, and the canvas viewport (pan / zoom). The next time you open it, it looks exactly as you left it.

* Open the **workspace switcher** in the top bar to switch between workspaces or create a new one.
* Each workspace has a **name**, **description**, **icon**, and **color** you can edit from the switcher or from **Settings → WorkSpace**.

## Multi-terminal broadcast

When you need to run the same command across several servers — a fleet update, a parallel restart, a quick health check — Rumus can broadcast a single command to multiple terminal cards simultaneously. It's a workspace canvas feature, available the moment you have more than one terminal card selected.

### When you'd use it

Typical cases:

* Run `df -h` across every node in a cluster and eyeball them side by side.
* Roll a single `systemctl restart` to a small fleet during a maintenance window.
* Fan out a quick `tail -n 50 /var/log/...` to see logs from each replica together.

### How to broadcast

<Steps>
  <Step title="Select multiple terminal cards">
    Two ways:

    * **Drag-select** — drag an empty area of the canvas to draw a box around the cards you want.
    * **Ctrl/Cmd + click** — toggle individual cards into the selection.

    The canvas surfaces the count: *"{count} terminal(s) selected"*.
  </Step>

  <Step title="Type the command">
    The broadcast input bar appears with the placeholder *"Enter command to send to {count} terminals…"*. Type a command and press **Enter**.

    Smart autocomplete works here too — partially type a command and accept the suggestion the same way you would in a single terminal.
  </Step>

  <Step title="Watch the results">
    The command runs in every selected terminal in parallel. Each card scrolls independently with its own output, so you can compare results side by side.
  </Step>
</Steps>

### What gets broadcast

* The literal text you type, followed by a newline.
* Smart autocomplete suggestions, when accepted.

That's it. If a target terminal is in the middle of an interactive prompt, your broadcast input is sent to that prompt — same as if you'd typed it locally.

### Caveats

* **No "abort all"** — once typed, each terminal runs the command independently. To stop a runaway, focus the offending terminal and send your usual interrupt (`Ctrl+C`).
* **Pseudo-terminal differences matter.** A command that depends on environment variables or shell aliases will only behave the same way if every selected terminal has those set up.
* **Broadcast targets are terminal cards on the same canvas.** It's not a cross-tab feature — plain terminal tabs aren't selectable.
* **Approval flows still apply.** If a target terminal has the AI agent active and command approval gating is on, the broadcasted command is treated like any other input.

### Tips

* For a fleet of identical hosts, group them in a workspace with a clean grid layout (use **Auto Arrange**) so output is easy to scan.
* Combine with **Monitor cards** ([see Monitoring](/docs/remote/monitoring)) to watch CPU / memory react to whatever you just rolled out.
* Pair with [Skills](/docs/ai/rules-skills) so the AI can suggest broadcast-safe commands before you fire them across a fleet.

## When *not* to use a workspace

Plain terminal tabs are still the right choice for ad-hoc work — quick one-off shells, scratch sessions, or anything you don't need to come back to. Workspaces shine when:

* You repeatedly need the same set of terminals and monitors together.
* You want to keep prod / staging / dev environments visually separate.
* You're running an incident response and want notes alongside live shells.

## Next steps

<CardGroup cols={2}>
  <Card title="Monitoring cards" icon="chart-line" href="/docs/remote/monitoring">
    Add a live CPU / memory / disk / GPU chart for any host.
  </Card>

  <Card title="Remote hosts" icon="server" href="/docs/remote/hosts">
    Save the SSH targets you broadcast to.
  </Card>
</CardGroup>
