> ## 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: Freeze AI Agent Sessions into Replayable Recipes

> Doppels converts AI agent sessions into typed, validated, replayable local Capabilities — same inputs, same steps, same auditable result every time.

Doppels is the freeze button for AI agent work. When your agent finally cracks that tricky migration, build pipeline, or data fetch, Doppels captures the working path as a **Capability** (the typed contract of inputs and outputs) and a **Recipe** (the YAML steps that run on your machine). From that point on, you replay the exact same result at zero cost — no tokens, no re-prompting, no hoping the model takes the same path twice.

## The problem Doppels solves

Coding agents are great at discovery and terrible at memory. You spend 40 minutes getting Claude to produce a working database migration script — it runs beautifully once. A week later, you need to run it again. The chat is gone, the context is stale, and you're starting over.

Scripts pasted into chat windows die when the session closes. Documentation drifts out of sync with the actual commands. Re-running "that ops fix" means re-explaining everything from scratch. The knowledge the agent produced was real and valuable — but it was trapped in a conversation thread with no shelf life.

Doppels solves this by giving the agent a freeze button. The same session that produced the solution also produces the artifact you keep.

## The core value

**Freeze once → replay forever at zero tokens.**

While the agent is working, it burns tokens exploring, retrying, and refining. That's the right time to let it work. Once it has a solution, `doppel freeze` captures it as deterministic YAML. Every subsequent replay executes locally: same inputs, same steps, same auditable result — without touching an AI model.

Execution stays entirely on your machine. Credentials live where they already are: `aws`, `gcloud`, `psql`, SSH, VPN. Nothing is sent to a cloud runtime. You can run Recipes offline.

## How it works

Doppels organizes everything into three concepts:

**Capability** — the public contract. A Capability declares what a task does: its named inputs (with types) and its declared outputs. It says nothing about *how* it runs. You can request a Capability even before a Recipe exists; a human can fulfill it manually.

**Recipe** — the local implementation. A Recipe declares `provides` (which Capabilities it fulfills) and lists the shell steps that produce the outputs. Recipes live in `recipes/` in your project and are committed to git like any other source file. The CLI validates them against the Capability contract before every run.

**Run** — one local attempt with fixed inputs. When you call `doppels run`, the CLI resolves the matching Recipe, locks the inputs, executes each step in order, and stores the result under `.doppels/runs/<id>/` — logs, artifacts, and return values all captured for inspection.

```text theme={null}
Capability ← Recipe
     ↓
  Request → Run → logs + artifacts
```

Here is what a frozen Recipe looks like in practice — the `hn-top-stories` example from the homepage:

```yaml theme={null}
apiVersion: doppels.so/v1alpha1
kind: Recipe

metadata:
  name: hn-top-stories
  version: 1.0.0

provides: [hn-top-stories]
runtime: shell

requires:
  commands: [node, curl]

steps:
  - id: fetch
    name: Fetch top stories from HN API
    run:
      shell: sh
      script: |
        curl -s "https://hacker-news.firebaseio.com/v0/topstories.json" \
          | node -e "
              const ids = JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')).slice(0,10);
              process.stdout.write(ids.join('\n'));
            " > ids.txt
    produces:
      ids_file:
        file: ids.txt

  - id: write_csv
    name: Write stories CSV
    env:
      IDS_FILE: "{{ steps.fetch.ids_file }}"
    run:
      shell: sh
      script: |
        node scripts/fetch-stories.js "$IDS_FILE" > stories.csv
    produces:
      csv:
        file: stories.csv

returns:
  stories: "{{ steps.write_csv.csv }}"
```

The YAML is human-readable, reviewable in a PR, and runnable offline — no black-box agent replay.

## Supported agents

Doppels works with any agent or editor that supports skills:

* **Claude** (claude.ai, Claude Desktop)
* **Cursor**
* **Codex** (OpenAI)
* **OpenCode**
* **Windsurf**
* **VS Code** (with agent extensions)

The freeze skill installs once and teaches your agent how to write valid Capability and Recipe YAML, validate it with the CLI, and confirm the contract with you before finishing.

## Open source

Doppels — the CLI, schemas, and freeze skill — is released under the **Apache 2.0** license. Inspect the source, fork Recipes, and contribute on [GitHub](https://github.com/doppelshq/doppels).

<Note>
  **Status:** Doppels is currently pre-alpha. The latest tagged releases are prereleases (`v0.0.0-dev.*`) intended to exercise the release pipeline. Schemas and CLI commands may change before a stable release.
</Note>

<CardGroup cols={3}>
  <Card title="Installation" icon="download" href="/installation">
    Install the `doppels` CLI on macOS or Linux in under a minute.
  </Card>

  <Card title="Quickstart" icon="rocket" href="/quickstart">
    Run your first Capability from the example Space included in the repo.
  </Card>

  <Card title="How It Works" icon="gear" href="/concepts/how-it-works">
    Explore the full Capability–Recipe–Run model and the freeze skill internals.
  </Card>
</CardGroup>