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

# Quick Start

> Get Crewship running on your hardware in 60 seconds, then create your first crew in under 5 minutes.

Crewship is a **self-hosted runtime for AI coding agents**. This page gets you from zero to a running agent in two passes: a 60-second smoke test that proves the runtime is alive on your hardware, then a 5-minute full setup that creates your first crew.

<Warning>
  **v0.1 beta — use the Claude Code adapter.** Crewship ships scaffolds
  for Codex, Gemini, OpenCode, Cursor, and Factory Droid, but only
  **Claude Code** has production-tested streaming, MCP support, and prompt
  scrubbers in this release. Pick Claude Code in the agent picker for
  the supported path; the other adapters are marked **Beta** in-product
  and have known gaps (Cursor MCP is upstream-broken in headless mode;
  the Codex live-event stream parser is still a stub). See the README's
  "Beta status & limitations" section for the full matrix.
</Warning>

## 60-Second Smoke Test

If you just want to see the dashboard come up on your machine, this is enough:

```bash theme={null}
# 1. Install (binary, single command)
curl -fsSL https://raw.githubusercontent.com/crewship-ai/crewship/main/scripts/install.sh | bash

# 2. Start the runtime — embedded UI + SQLite + Go server, no Node.js, no external DB
crewship start

# 3. Open the dashboard
open http://localhost:8080
```

That's it. The runtime is now serving on your hardware. No agents have been created yet — that's the next pass.

## Prerequisites for the Full Setup

* **Docker** (or Apple Containers on macOS 26+) — one Linux container per crew, shared by its agents
* An LLM API key (Anthropic, OpenAI, or Google) — agents call out to whichever provider you wire up
* **Go 1.26+** and **Node.js 22+ + pnpm** — only if you build from source instead of using the binary

## Installation

<Tabs>
  <Tab title="Homebrew">
    ```bash theme={null}
    brew install crewship-ai/tap/crewship

    crewship version
    ```
  </Tab>

  <Tab title="curl | bash">
    ```bash theme={null}
    # Verifies SHA-256 against signed checksums.txt; cosign signature
    # verified too when cosign is on PATH.
    curl -fsSL https://raw.githubusercontent.com/crewship-ai/crewship/main/scripts/install.sh | bash

    crewship version
    ```

    The short `https://crewship.ai/install` alias will point at this
    script once the project website goes live; until then, fetch it
    straight from the repo as shown.
  </Tab>

  <Tab title="Docker Compose">
    ```bash theme={null}
    git clone https://github.com/crewship-ai/crewship.git
    cd crewship

    # NEXTAUTH_SECRET and ENCRYPTION_KEY are REQUIRED — set them in .env first.
    cp .env.example .env   # then fill in the two secrets
    docker compose -f docker/docker-compose.prod.yml up -d
    ```

    The compose file declares both secrets with the `${VAR:?... is required}`
    form, so the stack refuses to start if either is unset. See the
    [Docker Compose install guide](/guides/install#docker-compose) for the
    full defaults table and the socket-proxy security model.
  </Tab>

  <Tab title="From source">
    ```bash theme={null}
    git clone https://github.com/crewship-ai/crewship.git
    cd crewship
    make build

    # The binary is at ./crewship (repo root)
    ./crewship version
    ```
  </Tab>
</Tabs>

For pinned versions, custom install directories, and air-gapped install paths see the full [Install guide](/guides/install).

## Initial Setup

<Steps>
  <Step title="Start the server">
    ```bash theme={null}
    crewship start
    ```

    The server starts on `http://localhost:8080` with an embedded UI and SQLite database.
  </Step>

  <Step title="Create the first admin user">
    Two first-class ways — pick the one that matches your deploy:

    <Tabs>
      <Tab title="Browser">
        1. Open **`http://localhost:8080`** — `/login` auto-redirects to `/bootstrap` on a fresh instance.
        2. Fill in name + email + password (min 8 chars), click **Continue to workspace setup**.

        Single-form bootstrap, no token to copy from anywhere.

        **No rush by default.** The bootstrap page stays open until you create the first admin — the empty user table is the gate, so take your time (the same first-run pattern as GitLab/Grafana). Once an admin exists, `/bootstrap` is closed for good.
      </Tab>

      <Tab title="CLI / headless / CI">
        For Ansible, Terraform, GitOps, or any provisioning flow where launching a browser isn't an option:

        ```bash theme={null}
        crewship init \
          --server http://localhost:8080 \
          --email admin@example.com \
          --name "Your Name"
        ```

        Prompts for a password (or accept `--password-stdin` from a vault). `init` POSTs `/api/v1/bootstrap`, creates the admin row + default workspace + OWNER membership, and returns a CLI token your CI stashes for subsequent calls.
      </Tab>
    </Tabs>

    <Note>
      **Hardening for public instances (opt-in).** If you expose a fresh instance to the internet *before* bootstrapping it, set `CREWSHIP_BOOTSTRAP_WINDOW=5m` (any Go duration) to arm a finite deploy-race window: `/bootstrap` accepts requests only for that interval after startup, then returns `410 Bootstrap window expired — restart the server to open a new one` so a scanner can't grab the admin account. Both the browser form and `crewship init` POST the same `/api/v1/bootstrap` endpoint and share the window; for unattended provisioning that lands minutes-to-hours after boot, restart the server immediately before the call so the window is fresh. Left unset (the default), bootstrap simply stays open until the first admin exists.
    </Note>
  </Step>

  <Step title="Log in via CLI">
    ```bash theme={null}
    crewship login
    ```

    Authenticates your CLI session against the server.
  </Step>

  <Step title="Select a workspace (multi-workspace setups)">
    `crewship init` creates your first workspace and marks it as the default — you can skip this step on a single-workspace install. If you belong to more than one workspace, pick which one the CLI targets for every subsequent command:

    ```bash theme={null}
    crewship workspace list
    # SLUG         NAME          ID        ROLE
    # acme *       Acme Corp     ws_abc…   OWNER
    # side-proj    Side Project  ws_def…   ADMIN

    crewship workspace use side-proj
    # ✓ Default workspace set to: side-proj
    ```

    The selection is written to `~/.crewship/cli-config.yaml` and used by every subsequent CLI call. Override per-command with `--workspace <slug>` if needed.
  </Step>

  <Step title="Check system health">
    ```bash theme={null}
    crewship doctor
    ```

    Verifies Docker is running and all runtime dependencies are met. The sidecar binary is embedded in the crewship binary at build time, so no separate pre-build step is required.
  </Step>

  <Step title="(Optional) Opt out of crash reporting">
    Crewship v0.1 beta enables anonymous crash reporting by default. To opt out before any data leaves your machine:

    ```bash theme={null}
    crewship telemetry off
    ```

    Full details — what is and isn't sent, routing to your own Sentry, defense-in-depth scrubbing — in the [Telemetry guide](/guides/telemetry).
  </Step>
</Steps>

## Create Your First Crew

<Steps>
  <Step title="Add a credential">
    Store your LLM API key in the encrypted vault:

    ```bash theme={null}
    echo "sk-ant-api03-YOUR-KEY" | crewship credential create \
      --name "anthropic-key" \
      --provider ANTHROPIC \
      --type API_KEY \
      --value-stdin
    ```

    The key is validated against the provider API, then encrypted with AES-256-GCM before storage.

    <Note>
      `--type API_KEY` is for plain provider API keys (`sk-ant-api...`).
      If you instead have a Claude Code OAuth token from a flat-rate
      subscription (`sk-ant-oat...`), use `--type AI_CLI_TOKEN` — the
      runtime injects the two differently, and mixing them up breaks
      agent authentication.
    </Note>

    <Tip>
      Use `--value-stdin` to pipe the key securely. Using `--value` directly exposes the key in the process list.
    </Tip>
  </Step>

  <Step title="Create a crew">
    ```bash theme={null}
    crewship crew create \
      --name "Dev Team" \
      --slug dev-team \
      --icon code \
      --color blue
    ```
  </Step>

  <Step title="Create an agent">
    ```bash theme={null}
    crewship agent create \
      --crew dev-team \
      --name "Alice" \
      --slug alice \
      --role AGENT \
      --system-prompt "Senior full-stack developer specializing in Go and React."
    ```
  </Step>

  <Step title="Assign the credential">
    ```bash theme={null}
    crewship credential assign anthropic-key alice \
      --env-var-name ANTHROPIC_API_KEY
    ```

    The `--env-var-name` flag is required — it specifies the environment variable the agent will use.
  </Step>

  <Step title="Run the agent">
    ```bash theme={null}
    crewship run alice "Set up a basic Go HTTP server with health check endpoint"
    ```

    The agent starts in an isolated Docker container, receives your prompt, and streams output in real-time.
  </Step>
</Steps>

## Open the Dashboard

Navigate to [http://localhost:8080](http://localhost:8080) to see the web UI where you can:

* View crew boards and agent status
* Monitor real-time logs from inside each container
* Manage credentials and skills
* Create and track missions
* Chat with agents directly

## What's Next?

<CardGroup cols={2}>
  <Card title="Architecture" icon="sitemap" href="/architecture">
    Learn how the runtime, sidecar proxy, container isolation, and IPC fit together under the hood.
  </Card>

  <Card title="Credentials" icon="key" href="/guides/credentials">
    Set up credential failover, scoping, and the Keeper guardrail.
  </Card>

  <Card title="Production Checklist" icon="circle-check" href="/production-checklist">
    The 6 things a production agent system needs — and how Crewship covers all of them.
  </Card>

  <Card title="Orchestration" icon="flag" href="/guides/orchestration">
    Create missions with multi-agent task delegation.
  </Card>
</CardGroup>