> ## Documentation index
> Fetch the complete index at: https://maritime.sh/llms.txt
> Setup procedure for AI agents (install, sign in, deploy, verify): https://maritime.sh/agents.md
> This page as HTML: https://maritime.sh/docs/quickstart

# Quickstart

Five minutes from sign up to a running sandbox, desktop and swarm. The first 7 days are free, with
up to $20 of usage; see [Billing & plans](https://maritime.sh/docs/billing#free-trial).

## 1. Sign up

[Sign up](https://maritime.sh/signup) with Google, GitHub or an email, and verify the email. Your
first machine asks for a card, which is not charged during the free trial.

## 2. Get your API key

The [dashboard](https://maritime.sh/dashboard) Home has the key bar at the top: **Copy key** gives
you your Default key, and makes it the first time. Every key and its scopes are under
[Developers](https://maritime.sh/dashboard/developers).

```
export MARITIME_API_KEY=mk_...
```

## 3. Onboard your agent

Copy the instructions into Claude Code, Cursor or Codex with **Copy instructions for your agent** (on the dashboard
and beside every docs page's title). Your agent reads the docs, uses `MARITIME_API_KEY` and runs
the steps below for you.

## 4. Try one of each

One short example per section. They use the CLI (`npm install -g maritime-cli`, then
`maritime login`) and the REST API with the same key.

### Sandboxes: one that runs a command

```bash
# start one; it ends with its disk after 15 idle minutes, or 60 minutes from now at the latest.
# The reply carries its "id" (sbx-...)
curl -X POST https://api.maritime.sh/api/sandboxes/ephemeral \
  -H "Authorization: Bearer $MARITIME_API_KEY" \
  -H "Content-Type: application/json" -d '{"name": "job-1", "idleMinutes": 15, "timeLimitMinutes": 60}'

# run a command in it through the Sandboxes API
maritime sandbox exec SANDBOX_ID -- uname -a
```

More in [Sandboxes](https://maritime.sh/docs/ephemeral-sandboxes); for a machine that keeps its
files, see [Agent boxes](https://maritime.sh/docs/persistent-sandboxes).

### Computers on demand: a Linux desktop and its first screenshot

```bash
# get or create the desktop for one of your users
curl -X POST https://api.maritime.sh/api/v1/computers \
  -H "Authorization: Bearer $MARITIME_API_KEY" \
  -H "Content-Type: application/json" -d '{"externalUserId": "u_1"}'
# {"id": "COMPUTER_ID", ...}

curl -H "Authorization: Bearer $MARITIME_API_KEY" \
  https://api.maritime.sh/api/v1/computers/COMPUTER_ID/screenshot -o screen.png
```

Your model drives it with clicks and keys over MCP or REST; see
[Linux desktops](https://maritime.sh/docs/computers). The same call with `"os": "windows"` or
`"android"` starts a [Windows desktop](https://maritime.sh/docs/windows-desktops) or an
[Android phone](https://maritime.sh/docs/phones) where your deployment has hosts for them.

### Sandboxes: a small swarm

```bash
maritime swarms run --count 3 --command 'echo hello from $MARITIME_SWARM_INDEX' --wait
maritime swarms results <swarm_id> -o results.jsonl
```

Three sandboxes run the command at once and are ended when done; see
[Swarms](https://maritime.sh/docs/swarms). Swarms come with the Scale plan and Dedicated: the run rents a
swarm server at $1 a minute, billed per second. Below Scale it is refused with `plan_required`; pick a plan
on the [Billing](https://maritime.sh/dashboard/billing) page.

## 5. How they fit together

A coding agent keeps its repos and tools in its
[Agent box](https://maritime.sh/docs/persistent-sandboxes) and runs commands there with
`exec`. When a task needs an app with a screen, it calls `get_computer` over MCP and works on
a [Linux desktop](https://maritime.sh/docs/computers). For one-off code it starts a sandbox, and
for a batch, a swarm. Every machine uses the same API key, shows up in Activity and is
billed per second on the same invoice.

## Or start from the dashboard

1. [Sign up](https://maritime.sh/signup), or [log in](https://maritime.sh/login).
2. In the [dashboard](https://maritime.sh/dashboard), open **New sandbox**
   (`/dashboard/new-sandbox`).
3. **Name**: name the machine, or keep the suggested name.
4. **Type**: pick a [Sandbox](https://maritime.sh/docs/ephemeral-sandboxes),
   [Agent box](https://maritime.sh/docs/persistent-sandboxes),
   [Swarm](https://maritime.sh/docs/swarms), [Linux desktop](https://maritime.sh/docs/computers),
   [Windows desktop](https://maritime.sh/docs/windows-desktops) or
   [Android phone](https://maritime.sh/docs/phones). Not sure which? Click **Don't know where to
   start?** to answer a few questions about what your agent will do and get a recommended type
   and size.
5. **Size** (sandboxes only): a preset, or your own vCPU, memory and disk. Computers, Windows
   desktops and phones have one size and skip this step. For an Android phone you choose the
   processor instead: x86_64 or arm64. arm64 appears only where your account has ARM hosts.
6. Click **Create** (for example **Create sandbox**). The new machine's own page opens. The first
   time, it asks for a card, which is not charged during the trial.

Picking Swarm opens the [Swarms](https://maritime.sh/dashboard/swarms) page, where a run of many
sandboxes starts; see [Swarms](https://maritime.sh/docs/swarms). Picking Agent box opens the
[Agents](https://maritime.sh/agents) page, where you pick a template. A sandbox started here ends with its disk after the idle time you pick under **How it ends** (default 2 minutes), or at its
time limit (default 24 hours). For other values, use the
[API](https://maritime.sh/docs/api#ephemeral-sandboxes).
Internet access, a fixed IP, private networks and other
[add-ons](https://maritime.sh/docs/add-ons) are set on the machine after it starts.

To preselect the type, link with `?type=`: `ephemeral`, `persistent`, `swarms`,
`computers`, `windows` or `android`, for example
[`/dashboard/new-sandbox?type=persistent`](https://maritime.sh/dashboard/new-sandbox?type=persistent).

## An agent from the CLI

Deploy a ready-made agent and talk to it from the terminal. Everything below also works from the
dashboard; the screenshots show the equivalent clicks.

*Recording: The whole quickstart, recorded against production: install the CLI, list templates,
create an openclaw agent, check its status, and send it a first chat message.*

### 1. Install the CLI

```
npm install -g maritime-cli
```

Requires Node.js 18 or later. Prefer clicking? Skip the CLI entirely and do all of this from
the dashboard.

### 2. Sign in

Log in with your Maritime account (the CLI prints a code and a URL to approve in your browser), or create one:

```
maritime login

# No account yet? (or sign up at maritime.sh/signup)
maritime signup -e you@example.com -p 'a long password'
```

### 3. Pick a template

Templates are complete, working agents: pick one and it deploys pre-configured. Not sure which?
[Choose a framework](https://maritime.sh/docs/frameworks) compares them; `openclaw` is the
general-purpose default.

```
maritime templates

# Output:
# NAME                FRAMEWORK    DESCRIPTION
# OpenClaw Agent      openclaw     Autonomous AI agent with 100+ skills.
# Hermes Agent        hermes       Self-improving Python agent with memory.
# ZeroClaw Agent      zeroclaw     Ultra-lightweight Rust agent.
# Claude Code         custom       Coding agent with real tools in a persistent workspace.
# Codex               custom       OpenAI's coding agent in a persistent workspace.
# DeepSeek Harness    dsh          Plugin-based harness with a full web workbench.
# ...
```

`--template` takes the **template id** (`openclaw`, `hermes`, `zeroclaw`, `claude_code`, `codex`, `dsh`),
not the framework column; the ids are listed on
[Choose a framework](https://maritime.sh/docs/frameworks).

*Screenshot: The same templates power the dashboard's New agent flow. The CLI and the dashboard
create identical agents.*

### 4. Create the agent

One command creates *and* deploys it; there is no separate deploy step. It flips to `active` in
under a minute:

```
maritime create my-agent --template openclaw

maritime status my-agent   # wait for status: active
```

*Recording: The same create flow in the dashboard: pick the OpenClaw template, name the agent, and
watch the deploy pipeline run until the agent turns Active.*

### 5. Talk to it

This is the whole point. Sleeping agents wake on their own, and the call waits for the reply:

```
maritime chat my-agent "introduce yourself and list three things you can do"
```

The OpenClaw template routes through Maritime's
[model proxy](https://maritime.sh/docs/billing#ai-credits) by default, which is paid from prepaid AI
credits, separate from your plan. Plans include none, so add AI credits on the Billing page first, or
set your own OpenAI key (step 6). The same chat works from the agent's page in the dashboard.

### 6. Add keys & config (optional)

Bring your own model key to pay your provider directly instead of using the proxy, or add any
other credentials your agent needs. Variables are secret by default: encrypted at rest, masked in
the UI.

```
maritime env set my-agent OPENAI_API_KEY=sk-... --reload
```

One exception to know: the [Claude Code](https://maritime.sh/docs/frameworks/claude-code) template
always needs your own `ANTHROPIC_API_KEY` (the proxy speaks the OpenAI format, which Claude Code
does not use). Details in [Env vars & sizing](https://maritime.sh/docs/configuration).

*Screenshot: Env vars live in the agent's Settings tab. Variables are marked secret by default:
stored encrypted, always masked in the UI. Uncheck Secret for plain-text config values.*

### 7. See what it's doing

```
maritime logs my-agent
```

*Screenshot: The same log stream lives on the agent's Overview tab; the Console tab has the
interactive terminal and the agent's files.*

## Shipping a web app instead?

Any repo with a Dockerfile can be served on a public, no-login URL that sleeps when idle and wakes
on the next visit:

```
maritime create my-app --repo https://github.com/you/app --public --port 3000
```

See [Public web agents](https://maritime.sh/docs/web-apps) for the full picture, or
[Deploy any container](https://maritime.sh/docs/frameworks/custom) to make your own code a
chattable agent.

> **Note: What happens next?**
>
> Your agent auto-sleeps when idle and wakes on the next message, trigger, or webhook; you never
> manage that. It costs $1 a month per 2 GB of memory, awake or asleep. Park it
> deliberately with `maritime sleep my-agent` whenever you like.
>
> - [Understand the platform in 5 minutes](https://maritime.sh/docs/how-it-works)
> - [Connect Telegram, WhatsApp, or Google](https://maritime.sh/docs/channels)
> - [Put it on a schedule](https://maritime.sh/docs/triggers)
> - [Understand what it costs](https://maritime.sh/docs/billing)