# The CLI in two minutes

Install rush, sign in once, start a run on a repository and steer it from your terminal while it works in the cloud.

`rush` is a client of the same API as the console. Every run it starts works in Rush Cloud, in its
own sandbox; your terminal only starts it, follows it and steers it. Close the terminal and the run
keeps going.

## Install and sign in

On macOS or Linux:

```bash
curl -fsSL https://cdn.getrush.ai/install.sh | bash
```

On Windows, in PowerShell:

```powershell
irm https://cdn.getrush.ai/install.ps1 | iex
```

Homebrew works too: `brew install phnx-labs/tap/rush`. Then sign in with Phoenix ID:

```bash
rush login
```

`rush whoami` shows who you are signed in as. A run on a repository needs the Rush GitHub App
installed there; `rush connections add github` installs it, or use **Settings → Integrations** in
the console.

## Start a run

```bash
rush run claude -r acme/web "Fix the flaky checkout test and open a PR"
```

The first argument is the harness (`claude`, `codex` or `opencode`) or the name of a saved agent.
`-r` names the repository; leave it out inside a checkout and `rush` uses its GitHub `origin` and
prints which one. For a long task, `-f task.md` reads the prompt from a file.

`rush run` follows the run live and prints its final status. Two flags change that:

| Flag | What it does |
| --- | --- |
| `--keep` | Keeps the sandbox after the task, so you can pause, resume and send follow-ups |
| `-d` | Prints the run id and returns instead of following |

Without `--keep`, the sandbox is torn down when the task finishes. Other flags: `-m` picks a model,
`-e` an effort, `--pr 42` starts from an open pull request's branch, and `--project` runs in a saved
Project.

## Follow and steer it

| Command | What it does |
| --- | --- |
| `rush runs` | Lists your runs; `--status running` filters them |
| `rush logs <run>` | Picks the live stream back up; `--new` prints only what is new since you last looked |
| `rush send <run> "..."` | Sends a follow-up; mid-turn, a text message queues until the turn ends |
| `rush pause <run>` | Parks a `--keep` run's sandbox with its disk and memory |
| `rush resume <run>` | Wakes it where it left off |
| `rush attach <run>` | Opens an interactive shell in the run's sandbox |
| `rush stop <run>` | Stops the run; `--turn` stops only the current turn |
| `rush open <run> pr` | Opens the pull request it produced; without `pr`, the run's console page |
| `rush artifacts <run>` | Lists the files it saved; `--get` downloads them |
| `rush transcript <run>` | Prints the captured transcript |

Leave out the run id in a terminal and the command offers a picker.

## Any API call

`rush http` calls the API with your signed-in session, so you never copy a token by hand. A path
starting with `/` goes to `https://api.prix.dev`:

```bash
rush http GET /o/acme/agents/available
rush http POST /o/acme/api-keys -d '{"name": "ci"}'
```

Set `RUSH_API_KEY` to an org key and `rush http`, and every other command, sends the key instead of
your session. That is how a CI job runs `rush` without a person signed in.

`rush --help` and `rush <command> --help` show the exact surface of the version you have installed,
and `rush upgrade` installs the latest.

## Next

- [Hand off from the terminal](/docs/learn/hand-off-from-the-terminal) walks a long run from start to
  pull request with your laptop closed in between.
- [Runs and sessions](/docs/concepts/runs-and-sessions) explains turns, follow-ups and parked
  sandboxes.