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

# Agent Quickstart

> Install the Joyride CLI, sign in, provision the RFQ vault subaccount, connect an AI client, and request and accept a package.

This is the shortest honest path from an empty machine to a filled package. It
takes a wallet, a Joyride account, and about ten minutes.

Joyride is a request-for-quote venue. An agent names a package of option legs,
quoters price the whole package as one firm two-sided quote, and the agent
accepts one side. There is no resting order to manage.

## 1. Install the CLI

Node.js 20 or later is required.

```bash theme={null}
npm install -g joyride-cli
```

Confirm the RFQ commands are present:

```bash theme={null}
joyride rfq --help
```

If that command is not found, the installed release predates RFQ support.
Upgrade with `npm install -g joyride-cli@latest`.

## 2. Create an account

Accounts are created in the web app at
[joyride.exchange](https://joyride.exchange) with a wallet and a referral code.
A wallet with no Joyride account is rejected at sign-in with an error naming
the sign-up step. There is no API-key signup and no self-serve provisioning
from the CLI.

## 3. Sign in

```bash theme={null}
joyride login
```

The first run walks through wallet setup and writes an encrypted keystore under
`~/.joyride`. Sign-in is Sign-In with Solana: the wallet signs a server nonce
and receives a session token, which is stored and resumed by later commands.
An account may hold three concurrent authenticated sessions; a fourth evicts
the oldest.

## 4. Provision the vault subaccount

Do this before the first request. A first-time account has no margin-vault
subaccount, and RFQ reads and requests fail readiness checks until one exists.

```bash theme={null}
joyride rfq subaccount
```

Joyride pays the rent, once per wallet. The command prints one of `exists`,
`submitted`, `refused`, or `asked_recently` and exits 0 for all four: each is a
closed answer to the question that was asked. A timeout is the one non-zero
exit, and it means the outcome is genuinely unknown rather than refused.

## 5. Wait for readiness

Provisioning lands on chain and then in the read projection, which lags. Poll
until the account reports `ready`:

```bash theme={null}
joyride rfq account
```

| Readiness    | What it means                                                    | Next step                                     |
| ------------ | ---------------------------------------------------------------- | --------------------------------------------- |
| `not_funded` | No subaccount row for this wallet                                | Run `joyride rfq subaccount`, then poll again |
| `unknown`    | The subaccount exists but its balance has not been projected yet | Poll again                                    |
| `ready`      | The subaccount exists and has a free balance                     | Request a quote                               |
| `short`      | Free balance is below the `--required` amount you asked about    | Deposit in the app                            |

`unknown` is not zero. A funded account whose balance column has not landed yet
reports `unknown`, and treating that as an empty account is the single most
common first-run mistake.

Deposits are made in the web app. The CLI never moves money.

```bash theme={null}
joyride rfq account --required 500
```

## 6. Connect an AI client

The MCP server ships inside the same package. Register it with a client:

```bash theme={null}
joyride mcp install --client claude
```

`--client` accepts `claude`, `codex`, or `cursor`. The server resumes the
session token `joyride login` stored, so sign in before starting the client.

The MCP server can request quotes and read RFQ state. It cannot sign, so it
cannot accept a quote; that happens here in the CLI or in the app. See
[MCP Server](/agents/mcp-server) for what the tools expose and for the spend
ceiling an operator must configure.

## 7. Request a quote

A package is one to thirteen legs on a single underlying and a single expiry.
Quantities are signed: positive means you receive the leg when you buy the
package, negative means you deliver it.

Instruments are 0DTE and refresh daily, so pick live symbols first:

```bash theme={null}
joyride chain BTC
```

Then request a two-sided price on the package, substituting two open symbols:

```bash theme={null}
joyride rfq request \
  --leg BTC_USDC-2MAY26-77000-C:1 \
  --leg BTC_USDC-2MAY26-80000-C:-2
```

For a single leg there is a shorthand:

```bash theme={null}
joyride rfq request --instrument BTC_USDC-2MAY26-77000-C --size 1
```

The command blocks for the venue's request window and resolves one of three
outcomes. `quoted` prints the two-way price and exits 0. `unquoted` means
nobody priced the package: nothing happened, nothing is owed, and requesting
again costs nothing. `unresolved` exits 3 and means the outcome is unknown, not
that there was no quote; read the request back with `joyride rfq show` before
sending another.

## 8. Accept one side

```bash theme={null}
joyride rfq accept --rfq-id <id> --side buy --max-premium 250 --max-locked 900
```

An accept commits collateral in one irreversible signature, so the command
prints the legs, the side, the cash direction and amount, the fee and its
maximum, and the lock, and then asks for confirmation. Pass `--yes` to consent
without the prompt. Without a terminal and without `--yes` the command refuses
and signs nothing.

`--max-premium` and `--max-locked` are yours, and they are evaluated by the SDK
against the same read the signature is built from rather than pre-checked
locally. `--max-premium` bounds the total cash cost: the
premium plus the trading fee maximum the signature authorizes. Set it above
both, and note that a package whose premium comes towards you still owes the
fee, so it is not automatically under the ceiling. [CLI](/agents/cli#consent-and-operator-ceilings) has
the operator variables that do the same job unattended.

A quote is firm until its `expires_at` and the accepting side is the whole
package: every leg fills in one on-chain transaction or none does.

## Where to go next

* [CLI](/agents/cli) for the full `rfq` command group, the leg grammar, output
  modes, and the operator ceilings
* [MCP Server](/agents/mcp-server) for driving Joyride from an AI client
* [TypeScript Maker SDK](/agents/maker-sdk) if you intend to quote rather than
  take
* [Fees and Limits](/market-makers/fees-and-limits) for the live fee schedule

Questions and onboarding: [support@joyride.exchange](mailto:support@joyride.exchange).
