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

# Quickstart

> Get Station running in 2 minutes

## Prerequisites

* **Docker** - Required for:
  * [Jaeger](https://www.jaegertracing.io/) - OTEL tracing backend for observability
  * [Ship CLI](https://github.com/cloudshipai/ship) - MCP tools for filesystem operations
  * [Sandbox](/station/sandbox) - Isolated container for agent code execution
  * [`stn up`](/station/docker) - Run environments/bundles in containers

* **AI Provider** - Choose one:
  * **OpenAI API Key** (recommended) - gpt-5, gpt-5-mini, etc.
  * **Google Gemini API Key**
  * **Anthropic API Key** - pay-per-token billing

## Step 1: Install Station

```bash theme={null}
curl -fsSL https://raw.githubusercontent.com/cloudshipai/station/main/install.sh | bash
```

Verify the installation:

```bash theme={null}
stn --version
```

## Step 2: Initialize with Your AI Provider

<Warning>
  **Anthropic OAuth Unavailable**: Anthropic has restricted third-party OAuth tokens. Claude Max/Pro subscription authentication is **not working until further notice**. Please use API key authentication instead.
</Warning>

<Tabs>
  <Tab title="OpenAI (Recommended)">
    ```bash theme={null}
    export OPENAI_API_KEY="sk-..."
    stn init --provider openai --ship
    ```

    Defaults to gpt-5-mini.
  </Tab>

  <Tab title="Google Gemini">
    ```bash theme={null}
    export GEMINI_API_KEY="..."
    stn init --provider gemini --ship
    ```
  </Tab>

  <Tab title="Anthropic (API Key)">
    ```bash theme={null}
    export ANTHROPIC_API_KEY="sk-ant-api03-..."
    stn init --provider anthropic --ship
    ```

    Uses pay-per-token billing (not Claude Max/Pro subscription).
  </Tab>
</Tabs>

<Note>
  **What is Ship?** [Ship](https://github.com/cloudshipai/ship) is an MCP CLI tool that provides filesystem and development tools for Station agents.
</Note>

### Git-Backed Workspace (Optional)

For version-controlled agent configurations:

```bash theme={null}
# Initialize in a specific directory
stn init --provider openai --ship --config ~/my-station-workspace

# Your agents, MCP configs, and variables are now version-controllable
cd ~/my-station-workspace
git init && git add . && git commit -m "Initial Station config"
```

## Step 3: Start Jaeger (Tracing)

Start the Jaeger tracing backend for observability:

```bash theme={null}
stn jaeger up
```

Jaeger UI available at [http://localhost:16686](http://localhost:16686).

## Step 4: Connect Your MCP Client

<Tabs>
  <Tab title="Claude Code CLI">
    ```bash theme={null}
    claude mcp add station -e OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318 --scope user -- stn stdio
    ```

    Verify: `claude mcp list`

    **With custom workspace:**

    ```bash theme={null}
    claude mcp add station -e OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318 --scope user -- stn stdio --config ~/my-station-workspace
    ```
  </Tab>

  <Tab title="Claude Desktop">
    Edit your config file:

    | OS      | Path                                                              |
    | ------- | ----------------------------------------------------------------- |
    | macOS   | `~/Library/Application Support/Claude/claude_desktop_config.json` |
    | Windows | `%APPDATA%\Claude\claude_desktop_config.json`                     |
    | Linux   | `~/.config/Claude/claude_desktop_config.json`                     |

    ```json theme={null}
    {
      "mcpServers": {
        "station": {
          "command": "stn",
          "args": ["stdio"],
          "env": {
            "OTEL_EXPORTER_OTLP_ENDPOINT": "http://localhost:4318"
          }
        }
      }
    }
    ```

    **With custom workspace:**

    ```json theme={null}
    {
      "mcpServers": {
        "station": {
          "command": "stn",
          "args": ["stdio", "--config", "/path/to/my-station-workspace"],
          "env": {
            "OTEL_EXPORTER_OTLP_ENDPOINT": "http://localhost:4318"
          }
        }
      }
    }
    ```
  </Tab>

  <Tab title="Cursor">
    Add to `.cursor/mcp.json` in your project (or `~/.cursor/mcp.json` for global):

    ```json theme={null}
    {
      "mcpServers": {
        "station": {
          "command": "stn",
          "args": ["stdio"],
          "env": {
            "OTEL_EXPORTER_OTLP_ENDPOINT": "http://localhost:4318"
          }
        }
      }
    }
    ```
  </Tab>

  <Tab title="OpenCode">
    Add to `opencode.jsonc`:

    ```jsonc theme={null}
    {
      "mcp": {
        "station": {
          "enabled": true,
          "type": "local",
          "command": ["stn", "stdio"],
          "environment": {
            "OTEL_EXPORTER_OTLP_ENDPOINT": "http://localhost:4318"
          }
        }
      }
    }
    ```
  </Tab>
</Tabs>

## Step 5: Start Using Station

Restart your editor. Station provides:

* **Web UI** at [http://localhost:8585](http://localhost:8585) for configuration
* **Jaeger UI** at [http://localhost:16686](http://localhost:16686) for traces
* **41 MCP tools** available in your AI assistant

**Try your first command:**

```
"Show me all Station MCP tools available"
```

## Step 6: Interactive Hands-On Tutorial (Optional)

Ready to dive deeper? Copy this prompt into your MCP client (Claude, Cursor, etc.) for a guided, interactive tour of Station's features:

<Accordion title="Interactive Tutorial Prompt">
  ```text theme={null}
  You are my Station onboarding guide. Walk me through an interactive hands-on tutorial.

  RULES:
  1. Create a todo list to track progress through each section
  2. At each section, STOP and let me engage before continuing
  3. Use Station MCP tools to demonstrate - don't just explain, DO IT
  4. Keep it fun and celebrate wins!

  THE JOURNEY:

  ## 1. Hello World Agent
  - Create a "hello-world" agent that greets users and tells a joke
  - Call the agent and show the result
  - NOTE: Agent execution may take 10-30 seconds depending on your AI model
  - Point me to http://localhost:8585 to see the agent in the UI
  [STOP for me to try it]

  ## 2. Faker Tools & MCP Templates
  - Explain Faker tools (AI-generated mock data for safe development)
  - Note: Real MCP tools are added via Station UI or template.json
  - Explain MCP templates - they keep credentials safe when deploying
  - Create a "prometheus-metrics" faker for realistic metrics
  - IMPORTANT: Faker tool calls can take 30-60+ seconds as the AI generates realistic mock data. This is normal!
  - Show me results at http://localhost:8585
  [STOP to see the faker]

  ## 3. DevOps Investigation Agent
  - Create a "metrics-investigator" agent using our prometheus faker
  - Call it: "Check for performance issues in the last hour"
  - NOTE: This may take a minute as the agent uses faker tools to simulate real metrics
  - Direct me to http://localhost:8585 to inspect the run
  [STOP to review the investigation]

  ## 4. Multi-Agent Hierarchy
  - Create an "incident-coordinator" that delegates to:
    - metrics-investigator (existing)
    - logs-investigator (new - create a logs faker)
  - Show hierarchy structure in the .prompt file
  - Call coordinator: "Investigate why the API is slow"
  - Multi-agent runs take longer as each agent executes sequentially
  - Check out the delegation chain at http://localhost:8585
  [STOP to see delegation]

  ## 5. Inspecting Runs
  - Use inspect_run to show detailed execution
  - Explain: tool calls, delegations, timing
  - Compare with the visual view at http://localhost:8585
  [STOP to explore]

  ## 6. Workflow with Human-in-the-Loop
  - Create a workflow: investigate → switch on severity → human_approval if high → report
  - Make it complex (switch/parallel), not sequential
  - Start the workflow
  - Show me the workflow state at http://localhost:8585
  [STOP for me to approve/reject]

  ## 7. Evaluation & Reporting
  - Run evals with evaluate_benchmark
  - Generate a performance report
  - View detailed metrics at http://localhost:8585
  [STOP to review]

  ## 8. Grand Finale
  - Direct me to http://localhost:8585 (Station UI)
  - Quick tour: Agents, MCP servers, Runs, Workflows
  - Celebrate!

  ## 9. Want More? (Optional)
  Briefly explain these advanced features (no demo needed):
  - **Schedules**: Cron-based agent scheduling
  - **Sandboxes**: Isolated code execution (Python/Node/Bash)
  - **Notify Webhooks**: Send alerts to Slack, ntfy, Discord
  - **Bundles**: Package and share agent teams
  - **Deploy**: `stn deploy` to Fly.io, Docker, K8s
  - **CloudShip**: Centralized management and team OAuth

  Start now with Section 1!
  ```
</Accordion>

<Tip>
  **Performance Note**: Faker tools generate AI-powered mock data, which can take 30-60+ seconds per call. This is normal! Real MCP tools (like Prometheus, Datadog) are much faster since they query actual APIs.
</Tip>

## Next Steps

<CardGroup cols={2}>
  <Card title="Create Agents" icon="robot" href="/station/agents">
    Build custom AI agents with prompts and tools
  </Card>

  <Card title="Add MCP Tools" icon="wrench" href="/station/mcp-tools">
    Connect MCP servers to give your agents powerful tools
  </Card>

  <Card title="Multi-Agent Teams" icon="users" href="/station/multi-agent-teams">
    Create agent hierarchies with coordinators and specialists
  </Card>

  <Card title="GitOps Workflow" icon="code-branch" href="/station/gitops">
    Version control your agents and collaborate with your team
  </Card>
</CardGroup>