# Quickstart (/docs/rlx/quickstart)

By the end of this page, a manager agent and two coders are working on a goal
you described in your own words, each one a real session you can watch and
type into. You need a terminal on macOS, Linux or WSL2, a git repo to work on,
and Claude Code or Codex with an account for it.

<Steps>
  <Step>
    ### Install [#install]

    From the repo you want the agents to work on, run the one-line installer. It
    installs only what your machine is missing and registers that repo as your
    first project:

    ```sh
    curl -fsSL https://aisquare.studio/rlx/install.sh | sh
    ```

    Prefer to see each step, or on Windows? [Install](/docs/rlx/install)
    has the by-hand route with uv, the WSL2 line for PowerShell, and how to read
    the script before you run it.
  </Step>

  <Step>
    ### Open rlx [#open-rlx]

    The installer offers to open the UI at the end. Otherwise:

    ```sh
    rlx
    ```

    `rlx` opens full screen on **Welcome**: three cards that take you from an
    empty home to a running fleet. The sidebar on the left lists your projects;
    the cards are on the right.

    
  </Step>

  <Step>
    ### 1 Project [#1-project]

    If you started `rlx` in the repo the installer registered, this card is
    already done. Otherwise press &#x2A;*Use \<name>** for the folder you are in
    (or one of your projects), or type a path and press **Use this folder**. **Choose
    another** changes the pick later. A folder that is not a project yet is added
    in the background: rlx registers it and runs its checks without leaving
    the UI, and it appears as a card in the sidebar.
  </Step>

  <Step>
    ### 2 Coding agent: Claude Code or Codex [#2-coding-agent-claude-code-or-codex]

    The card is titled with the agent the fleet runs, such as *Claude Code*, or
    *Coding agent* while none is installed. The one-line installer already
    connected your agent, so this card is usually done too. If it is not ✓, press
    **Connect**. It installs rlx's hooks into the agent, which is how the manager
    receives its instructions and how `rlx` knows what every agent is doing. If
    the agent is missing, the card links its install page; it notices the install
    within a few seconds, and **Check again** looks at once. If you are signed out, **Sign in**
    opens the Accounts page, and once the sign-in lands `rlx` brings you back to
    Welcome with the keyboard on the next step.
  </Step>

  <Step>
    ### 3 Fleet [#3-fleet]

    1. Press **Start manager**.
    2. Press **Open the manager**. The agent asks once whether you trust this
       folder: answer it in the manager's pane.
    3. Press `F12` to hand the keyboard back to the sidebar, then `w` to return to
       Welcome, and press **Start the coders**.

    You now have a manager and two coders (`coder-1` and `coder-2`), listed under
    the project in the sidebar, each a session of its own.

    
  </Step>

  <Step>
    ### Give the manager a goal [#give-the-manager-a-goal]

    Click the manager and type what you want, in prose, the way you would brief a
    tech lead. Be concrete about the outcome and how you will judge it:

    * "Add a `--json` flag to the `export` command, with tests, and document it
      in the README."
    * "Signup accepts email addresses with spaces in them. Fix the validation and
      add a regression test."
    * "`make test` fails about one run in five on CI. Find out why and make it
      deterministic."
  </Step>
</Steps>

## What happens next [#what-happens-next]

The manager plans and steers; the other agents do the work. You will see:

* **Numbered tasks on the board.** The manager writes your goal down as tasks
  (`#1`, `#2`, ...), each with acceptance criteria. Open the project's
  **Board** tab to watch them move. Its top line counts what needs you:
  waiting agents, questions, reviews and blocked work.
* **Coders in their own worktrees.** Each coder claims a task and works in its
  own git worktree on a `fleet/...` branch. When the task's contract asks for
  it, the coder pushes and opens a pull request (with
  [gh](https://cli.github.com) installed).
* **A review loop.** The manager sends a tester to try to break each change, a
  ui-tester to check anything a user sees in a real browser, and a reviewer to
  read the pull request. A failed check reopens the task with the reason, and a
  coder picks it up again.
* **A clear finish.** When everything passes, the manager posts `READY:` with
  the pull requests and the evidence.

The manager never writes code and never merges. Reviewing and merging stay
with you.

Each agent in the sidebar carries a state icon: &#x2A;*▶*&#x2A; working, &#x2A;*⏸**
waiting, **🔔*&#x2A; when it needs you (with a terminal bell), or &#x2A;*⏳** when it is
parked on a Claude usage limit. The board and `rlx fleet ls` spell the
same states out, such as **🔔 NEEDS YOU**. On the project's **Manager** tab, a line under the
manager's info line counts the agents it runs by role and state; click it to
open the Board.

<Callout type="info" title="Pick the model once">
  Type `/model` or `/effort` in any fleet agent's pane as you would in Claude
  Code. rlx remembers your last pick, and agents spawned after it start on
  that model and effort unless a role's own settings say otherwise. With no
  pick, Claude Code runs the account's own default. See
  [Run a fleet](/docs/rlx/fleet).
</Callout>

## Moving around [#moving-around]

* **Click an agent** and its pane has the keyboard: everything you type goes
  straight to its Claude Code session. A screenshot you drop onto `rlx` goes
  to the agent on screen.
* **`F12`** hands the keyboard back to the sidebar. It is the one key a pane
  never forwards.
* From the sidebar, &#x2A;*`w`*&#x2A; returns to Welcome, &#x2A;*`?`*&#x2A; lists every key, and
  &#x2A;*`q`** quits `rlx`.
* **The agents keep running** after you quit. Open `rlx` again and it
  re-attaches to them. `rlx fleet attach` shows the same sessions in raw
  tmux from any terminal.

Once a project is set up, `rlx` asks you once whether to share anonymous usage
counts with AISquare. It is off unless you say yes; see
[See where your usage goes](/docs/rlx/usage-and-stats#share-anonymous-counts-only-if-you-choose-to)
for what would be sent.

<Callout type="info" title="Add a second Claude account now">
  A busy fleet can use up one account's five-hour window quickly. Open
  **⚙ Settings ▸ Accounts*&#x2A;, press **+ Add Claude account**, and sign in. From
  then on, new agents start on an account with room, and an agent that hits
  its limit moves to another account and resumes its own session.
  See [Connect more than one Claude account](/docs/rlx/add-accounts).
</Callout>

## Memory only, no fleet [#memory-only-no-fleet]

If you want your Claude Code sessions to remember your preferences and each
project's conventions, without running a fleet, you need only
[uv](https://docs.astral.sh/uv/) and Claude Code: no installer, no tmux.

```sh
UV_PYTHON_DOWNLOADS=automatic uv tool install --python 3.13 aisquare-cli
cd path/to/your/repo
rlx init --local --agent claude-code
rlx remember --user "prefer pytest over unittest"
```

`init` registers the repo and wires Claude Code's hooks, so every new session
starts with what you told it to remember. `rlx context list` shows what is
in scope. See [Memory](/docs/rlx/memory) for the rest.

## Next steps [#next-steps]

<Cards>
  <Card title="Tour of rlx" href="/docs/rlx/fleet-ui" description="The sidebar, agent panes, Settings and the keys you will use every day." />

  <Card title="Run a fleet" href="/docs/rlx/fleet" description="The roles, spawning your own agents, and every default you can change." />

  <Card title="Connect more than one Claude account" href="/docs/rlx/add-accounts" description="Several Claude accounts, one pool, and agents that move when one runs out." />

  <Card title="The board" href="/docs/rlx/board" description="Numbered tasks, claims and the review loop, live." />
</Cards>
