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

# Core concepts

> A short tour of the building blocks that make Rumus work the way it does.

Rumus combines a terminal, an AI agent, and infrastructure tools in one window. The vocabulary below shows up across the rest of the docs — it's worth ten minutes to learn.

## Tab

The top-level unit of navigation. A **tab** is whatever you currently have open across the top of the window. A tab can be:

* A **terminal** session — local or SSH.
* A **workspace** — see below.
* Settings, chat history, and a few other built-in views.

Tabs work like browser tabs: drag to reorder, right-click for actions, click the chevron next to the new-tab button to open a specific shell or remote connection.

A terminal tab is bound to a [Profile](#profile) that controls the shell, environment variables, and starting directory.

## Workspace

A **workspace** is a special kind of tab that holds a free-form 2D layout of **cards**. Where a terminal tab gives you one shell, a workspace lets you arrange several terminals — plus monitor widgets and markdown notes — side by side on a [canvas](#canvas), and persist that arrangement.

Workspaces are useful for project-shaped work: a single workspace per service, environment, or incident, with the terminals you need for that job already laid out.

Each workspace stores:

* Its **cards** — terminals, monitor widgets, markdown notes — and their position, size, and z-order.
* The **viewport** — pan and zoom of the canvas.
* Metadata: name, description, icon, color.

Open or create a workspace from the workspace switcher in the top bar. Workspaces live alongside regular tabs — you can keep a couple of workspaces and a handful of plain terminal tabs open at the same time.

## Canvas

The **canvas** is the layout *inside* a workspace tab. It's a zoomable, pan-able 2D surface where you place [cards](#card) — terminals, monitors, notes — wherever you want them. Think of it as a whiteboard for your terminals.

You can:

* Drag cards to reposition; resize from the corners; cards snap to a grid.
* Pan with middle-drag or trackpad; zoom in and out for a bird's-eye view.
* Multi-select cards (Ctrl/Cmd-click) to broadcast the same command to several terminals at once.
* Right-click empty space to add a new card at that location.

The canvas is **not** an alternative to tabs — it's what you see when the active tab is a workspace. Plain terminal tabs still behave like a normal terminal.

## Card

A **card** is one node on a workspace canvas. Three card types ship today:

* **Terminal card** — a shell session, just like a terminal tab, but living on the canvas.
* **Monitor card** — a real-time view of CPU, memory, disk, GPU, or other metrics for a host.
* **Markdown card** — a free-form note for documenting commands, runbooks, or status.

Cards are added from the workspace's right-click menu or the **+** controls in the canvas toolbar.

## Profile

A **profile** is a reusable configuration for a shell or remote connection:

* **Local profiles** — shell binary, working directory, environment variables, color scheme override.
* **Remote profiles** (a saved [Host](#host)) — SSH endpoint, credentials, jump chain.

Manage profiles in **Settings → Profiles**. The default profile picked during onboarding is what new tabs use unless you choose otherwise.

## Host

A **host** is a saved SSH target stored in the [Vault](#vault). Each host record includes hostname, port, username, auth method, optional jump hosts, proxy, and group/tag metadata.

Hosts are the entry point for Rumus's remote features: opening a shell, browsing files over SFTP, watching CPU/memory in real time, or broadcasting commands to several machines at once.

See [Remote & SSH](/docs/remote/hosts) for the full reference.

## Vault

The **vault** is Rumus's encrypted local store for sensitive data — SSH keys, host credentials, API keys for AI providers, and saved tokens. It's built on [Stronghold](https://github.com/iotaledger/stronghold.rs), an open-source secrets engine.

Key properties:

* Everything in the vault is encrypted on your device with a **secret key** that you create during onboarding.
* The vault sync feature uploads only ciphertext — Rumus servers cannot read your secrets.
* A **PIN** can be set for fast unlock so you don't re-enter the secret key every session.

If you lose your secret key, encrypted data is unrecoverable. Always keep a backup of the key file.

## Agent

The **agent** is the AI mode that can take actions on your behalf — running commands, reading and writing files, calling tools through MCP, or searching the web. Different from a plain "chat", the agent treats your request as a goal and works toward it across multiple steps.

For one-shot tasks, the agent proposes a command, asks for approval (unless it's whitelisted), and runs it. For larger jobs it switches into **plan mode** automatically — drafting a multi-step plan, working through it step by step, and adapting as it goes. There's no toggle to flip; the agent decides based on the request.

Long-running or branching jobs can spawn **sub-agents** that run in parallel and report back into the main thread.

## Skills and rules

You can teach the agent your conventions once and reuse them everywhere:

* **Rules** — short, always-on guidance ("Never run destructive commands without confirming", "Use pnpm, not npm, in this repo").
* **Skills** — named, reusable capabilities you describe in natural language; the agent invokes them when relevant.

Both live under **Settings → AI → Rules & Skills** and sync across devices.

## MCP

Rumus speaks the **Model Context Protocol** (MCP), an open spec for letting AI agents talk to tools and data sources. Add an MCP server in **Settings → AI → MCP** and the agent can call its tools just like built-in ones — your databases, internal APIs, ticket systems, and so on.

See [MCP integration](/docs/ai/mcp) for setup details.

## Built-in models vs. custom models

Rumus ships with a curated set of **built-in models** included in your subscription. You can also bring your own keys for **custom models** from Anthropic, OpenAI, Google, Z.AI, OpenRouter, Ollama, or any OpenAI-compatible endpoint. Both kinds appear in the model picker side by side.

For pricing and how to view usage, see [Built-in models](/docs/models/built-in). For setup with your own key, see the per-provider guides under [Models & Providers](/docs/models/overview).

## Where these concepts live in the UI

| Concept                        | Where to find it                                            |
| ------------------------------ | ----------------------------------------------------------- |
| Tabs                           | Top of the window                                           |
| Workspaces                     | Workspace switcher (top bar); each workspace opens as a tab |
| Canvas                         | Inside any workspace tab                                    |
| Cards                          | Right-click the canvas, or use the canvas toolbar           |
| Profiles                       | Settings → Profiles                                         |
| Hosts                          | Sidebar → Hosts, or Settings → Hosts                        |
| Vault                          | Settings → Vaults                                           |
| Agent / Plan mode / sub-agents | AI sidebar (right)                                          |
| Rules & Skills                 | Settings → AI → Rules & Skills                              |
| MCP                            | Settings → AI → MCP                                         |
| Models                         | Settings → AI → Models                                      |
