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

# Doppels Quickstart: Validate, Run, and Inspect a Capability

> Run your first Doppels Capability in minutes: initialize a Space, validate manifests, execute a run, and inspect logs — no AI agent required.

This guide walks you through the fastest path to a working Doppels run. You will initialize a Space, use the example Capabilities bundled in the repository, execute a run, and inspect its output — all without needing an AI agent. By the end you will understand the full local workflow: validate, run, inspect.

## Prerequisites

* The `doppels` CLI installed and on your `PATH`. See the [Installation](/installation) guide if you haven't done this yet.
* A local clone of the Doppels repository (only needed for the quickstart example Space):
  ```shell theme={null}
  git clone https://github.com/doppelshq/doppels.git
  cd doppels
  ```

## Quickstart walkthrough

<Steps>
  <Step title="Initialize a Space">
    A **Space** is a project directory that contains your Capabilities, Recipes, and run history. Initialize one in any project folder with:

    ```shell theme={null}
    doppels spaces init
    ```

    This creates three directories:

    | Directory       | Purpose                                              |
    | --------------- | ---------------------------------------------------- |
    | `capabilities/` | Capability manifests (commit to git)                 |
    | `recipes/`      | Recipe manifests (commit to git)                     |
    | `.doppels/`     | Runtime data: runs, logs, artifacts (gitignore this) |

    For this quickstart, you will use the example Space already present in the cloned repository rather than starting from an empty project.
  </Step>

  <Step title="Run the quickstart example">
    Navigate to the example Space and validate all manifests:

    ```shell theme={null}
    cd examples/quickstart
    doppels validate
    ```

    A passing validation looks like:

    ```text theme={null}
    ✓ capability/greet           valid
    ✓ capability/release-pipeline valid
    ✓ capability/manual-review   valid (no recipe — manual fulfillment)
    ✓ All manifests valid · 3 capabilities, 2 recipes
    ```

    Now run the `greet` Capability, passing `name` as an input and confirming automatically with `--yes`:

    ```shell theme={null}
    doppels run capability/greet --input name=Ada --yes
    ```

    Expected output:

    ```text theme={null}
    → Resolving Recipe for capability/greet
    → Validating inputs
    → Running Step: greet
    ✓ Completed in 0.3s
      message: "Hello, Ada!"
      receipt: .doppels/runs/01J.../receipt.txt
    ```

    List all runs recorded in this Space:

    ```shell theme={null}
    doppels runs list
    ```

    ```text theme={null}
    ID                    CAPABILITY       STATUS     STARTED
    01J9K2M...            greet            succeeded  2 seconds ago
    ```
  </Step>

  <Step title="Inspect the run">
    Copy the run ID from `doppels runs list` and use it to examine the full run record and its logs.

    Show the structured run summary:

    ```shell theme={null}
    doppels runs show <run-id>
    ```

    ```text theme={null}
    Run:        01J9K2M...
    Capability: greet
    Status:     succeeded
    Started:    2024-11-14T10:32:01Z
    Duration:   0.3s
    Inputs:
      name: Ada
    Returns:
      message: "Hello, Ada!"
    ```

    Stream the step-level logs:

    ```shell theme={null}
    doppels runs logs <run-id>
    ```

    Every step's stdout and stderr is captured and stored under `.doppels/runs/<run-id>/`. Nothing is sent off your machine.
  </Step>

  <Step title="List your Capabilities">
    See everything available in the current Space:

    ```shell theme={null}
    doppels capabilities list
    ```

    ```text theme={null}
    NAME              VERSION   RECIPES   DESCRIPTION
    greet             1.0.0     1         Greet a person by name
    release-pipeline  1.0.0     1         Four-step release pipeline
    manual-review     1.0.0     0         Manual review — no recipe
    ```

    Inspect the full contract of a specific Capability:

    ```shell theme={null}
    doppels describe capability/greet
    ```

    This prints the Capability's inputs, outputs, and any linked Recipe — useful before running or sharing.
  </Step>
</Steps>

<Tip>
  Add `--json` to most commands for machine-readable output. For example, `doppels runs list --json` returns a JSON array of run objects, making it easy to pipe results into other tools or scripts.
</Tip>

## What's in the example Space

The `examples/quickstart` Space contains three Capabilities that exercise different parts of the system:

* **`greet`** — a simple single-step shell Recipe that produces a `message` string and a `receipt.txt` artifact. Good for verifying your install.
* **`release-pipeline`** — a four-step Recipe (roughly 1–3 seconds per step) that demonstrates multi-step sequencing and inter-step references. Run it with `doppels run capability/release-pipeline --input version=1.2.3 --yes`.
* **`manual-review`** — a Capability with no Recipe, fulfilled by passing `--output` and `--evidence` flags directly to `doppels run`. Shows that Capabilities can be satisfied manually without any shell automation.

## Next steps

<CardGroup cols={2}>
  <Card title="Freeze with your agent" icon="snowflake" href="/guides/freeze-with-agent">
    Learn how to install the freeze skill and capture a real agent session as a reusable Capability.
  </Card>

  <Card title="Capabilities in depth" icon="file-contract" href="/concepts/capabilities">
    Understand the full Capability schema: inputs, outputs, versioning, and manual fulfillment.
  </Card>
</CardGroup>