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

# Quickstart

> Find the coding agents already running on your machine, see what each one costs, and route one to the model you choose.

In about ten minutes you'll install the CLI, discover the coding agents on your machine, start reporting their sessions to a Nasiko cluster, and see their spend in TokenOps. Routing a harness to a different model is an optional last step.

Nothing about how you use your harnesses changes. Claude Code, Codex, OpenCode and the Cursor CLI keep running exactly as they do today.

<Tip>
  Want to build and deploy your own agent instead? Follow [Quickstart: deploy an agent](/quickstart-deploy).
</Tip>

## Prerequisites

* [Rust](https://rustup.rs) to install the CLI
* [Docker](https://docs.docker.com/get-docker/) with Compose, to run a local Nasiko cluster — or the URL of your organization's cluster and an account on it
* At least one supported coding agent installed: Claude Code, Codex, OpenCode or the Cursor CLI

## Find and measure your coding agents

<Steps>
  <Step title="Install the CLI">
    ```bash theme={null}
    git clone https://github.com/Nasiko-Labs/nasiko.git && cd nasiko
    cargo install --path cli --force
    ```

    This installs `nasiko` into `~/.cargo/bin`. Use `--force` when you update: every build reports version `0.1.0`, so the version number alone won't tell you whether you have the latest commands.
  </Step>

  <Step title="Discover what's already running">
    ```bash theme={null}
    nasiko agents discover
    ```

    ```text theme={null}
    AGENT      DETECTED   CONNECTED   VERSION              CONFIG
    ----------------------------------------------------------------------------------------
    claude     yes        no          -                    ~/.claude
    codex      yes        no          -                    ~/.codex
    opencode   -          no          -                    ~/.config/opencode
    cursor     yes        no          -                    ~/.cursor
    ```

    Discovery reads your machine, prints one row per supported harness, and exits. It changes no settings, needs no account, and sends nothing off the machine. **Detected** means the harness binary is on your `PATH` or its config directory exists. **Connected** means session reporting is installed, and **Version** is the version of the Nasiko reporting hook.
  </Step>

  <Step title="Start or connect to a Nasiko cluster">
    <Tabs>
      <Tab title="Local (Docker Compose)">
        From the `nasiko` repo you cloned:

        ```bash theme={null}
        cp .env.example .env
        ```

        Edit `.env` and set:

        * `ADMIN_PASSWORD`: the password for the `admin` account
        * `OPENAI_API_KEY`: a model provider key
        * `AGENT_JWT_SECRET`: uncomment it and set a random value (`openssl rand -base64 48`). Model routing in the last step needs it.

        ```bash theme={null}
        docker compose up -d
        nasiko connect http://localhost:8080 --name local
        ```

        The first build compiles the server inside Docker and takes a few minutes. The dashboard is at [http://localhost:8080](http://localhost:8080). The Compose stack already sets up everything coding-agent cost reporting needs. See [Deploy the stack](/self-hosting/deploy) for details.
      </Tab>

      <Tab title="Your organization's cluster">
        ```bash theme={null}
        nasiko connect https://nasiko.example.com --name work
        ```

        Get the URL and an account from your administrator.
      </Tab>
    </Tabs>
  </Step>

  <Step title="Sign in — reporting installs itself">
    ```bash theme={null}
    nasiko auth login
    ```

    When you sign in, Nasiko installs session reporting for every detected harness that doesn't already have it, and registers each harness with the cluster. Run `nasiko agents discover` again and **Connected** reads `yes`.

    To install reporting for one harness explicitly, or to leave prompt and response text out of what's reported:

    ```bash theme={null}
    nasiko agents install claude
    nasiko agents install codex --no-content
    ```

    <Note>
      Restart OpenCode after reporting is installed so it loads the plugin. Codex asks you to trust the new Nasiko hooks the next time it starts.
    </Note>
  </Step>

  <Step title="Work as usual, then look at the spend">
    Use your harness the way you always do. Each completed turn is queued on your machine and delivered to the cluster in the background. If the cluster is unreachable, turns wait in the queue and the harness is never blocked.

    ```bash theme={null}
    nasiko sessions              # every harness session, alongside your other chats
    nasiko history <session-id>  # the turns in one session
    ```

    In the dashboard, **Sessions** lists the same conversations. **Overview** and **TokenOps** break down spend by agent — each harness is registered as its own agent — and by model. See [the TokenOps dashboard](/tokenops/dashboard).
  </Step>

  <Step title="Optional: route a harness to the model you choose">
    Harnesses arrive tied to a vendor: Claude Code to Anthropic, Codex to OpenAI. Routing gives the model choice back to you. Register a provider key once, then connect a harness to it:

    ```bash theme={null}
    nasiko llm-config create --name my-openai --provider openai --model gpt-4o \
      --api-key-secret OPENAI_API_KEY --secret-value "$OPENAI_API_KEY"
    nasiko connect claude --config my-openai
    ```

    Claude Code keeps speaking its own protocol, and Nasiko routes each call to the model in your config. Routing is available for Claude Code, Codex and OpenCode. Undo it at any time with `nasiko disconnect claude`. See [Route models](/coding-agents/routing) for what changes on your machine and how failures behave.
  </Step>
</Steps>

## Next steps

<CardGroup cols={2}>
  <Card title="How reporting works" icon="satellite-dish" href="/coding-agents/session-reporting">
    What's captured, where it's queued, and how delivery is kept safe.
  </Card>

  <Card title="Cost attribution" icon="coins" href="/tokenops/attribution">
    One cost schema across every harness and vendor.
  </Card>

  <Card title="Per-harness guides" icon="terminal" href="/coding-agents/claude-code">
    Claude Code, Codex, OpenCode and Cursor specifics.
  </Card>

  <Card title="Deploy an agent" icon="rocket" href="/quickstart-deploy">
    Build and run your own agent on the same cluster.
  </Card>
</CardGroup>

<Tip>
  Stuck? See [Troubleshooting](/coding-agents/troubleshooting), ask in [Discord](https://discord.com/invite/HmnfkTfjFv), or email [support@nasiko.com](mailto:support@nasiko.com).
</Tip>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.