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

# The 2-Minute Demo

> See the impact report and the ranked skills registry on realistic seeded data — one command each, no agent code, no LLM keys.

The fastest way to understand DecimalAI is to see its two headline outputs on real-looking data. Both ship as one-command sandboxes that seed your workspace and link you straight to the result:

1. **`decimalai demo regression`** — what a risky agent change does to production traffic (the impact report)
2. **`decimalai demo skills`** — the skills registry, ranked by measured effectiveness

Everything seeded is prefixed `[Demo] ` and fully removable. No agent code, no framework setup, no LLM API keys.

## Prerequisites

* **Python 3.10+** (`python --version` — older Pythons silently install an outdated SDK)
* A DecimalAI API key from [app.decimal.ai/settings](https://app.decimal.ai/settings)

```bash theme={null}
pip install decimalai
export DECIMAL_API_KEY="dai_sk_..."
```

<Steps>
  <Step title="Run the regression demo">
    ```bash theme={null}
    decimalai demo regression
    ```

    In \~30 seconds this seeds a demo support agent with **two manifest versions** and a production trace corpus, then runs the regression check:

    ```
    Demo A — "Your agent changed"
    Seeding the demo agent (v1 → v2 + traces)…
      agent: [Demo] support-agent  ·  traces: 10  ·  v1 c7664af1 → v2 1d163437
    Running the regression check (v2 vs auto-resolved v1)…

    Verdict: high_risk — 2 traces will break. Review before merging.
    Traces analyzed: 110 (high 2 / med 108 / low 0)

    Open the impact report (keep / repair / replay / drop fan-out):
      https://app.decimal.ai/agents/.../impact-reports/<id>
    ```

    The v1→v2 diff contains the three change types you'll actually ship: a **model swap**, a **tool rename + removal**, and a **prompt rewrite**.

    <Note>
      `traces: 10` and `Traces analyzed: 110` mean different things. `10` is the seeded corpus you'll see in the dashboard; `~110` is what the engine actually analyzes — it pulls in roughly 100 additional history rows so the check runs against a realistic volume.
    </Note>
  </Step>

  <Step title="Read the impact report">
    Open the printed link. The report answers the question every reviewer has — *what does this change do to traffic we've already served?*

    * **🔴 HIGH IMPACT** — traces that called the removed tool. They *will* break.
    * **🟡 MEDIUM IMPACT** — traces touched by the model swap / prompt rewrite. Outputs *may* differ; structural analysis can't predict direction.
    * **🟢 LOW IMPACT** — traces that never touched a changed surface.

    Below the severity bands, each affected trace gets a **keep / repair / replay / drop** verdict — the same classification that keeps training datasets valid as your agent evolves.

    This is exactly what the [GitHub Action](/guides/regression-check) posts on every PR — computed against *your* production traces instead of seeded ones.
  </Step>

  <Step title="Run the skills demo">
    ```bash theme={null}
    decimalai demo skills
    ```

    Seeds three public skills with deliberately varied effectiveness and runs the stats recompute:

    ```
    Demo B — "Find skills that work"
    Seeding 3 public skills + stats + traces (runs the recompute)…
      skills: [Demo] code-review, [Demo] sql-optimizer, [Demo] deploy-checklist

    Open the Skills Registry (ranked by SkillScore — measured quality, not installs):
      https://app.decimal.ai/skills
    ```

    The three seeded skills land at different SkillScores by design:

    | Skill              | Effectiveness | Rank — why                                                         |
    | ------------------ | ------------- | ------------------------------------------------------------------ |
    | `code-review`      | High          | **#1** — verified, high eval pass rate and strong AI-judge quality |
    | `sql-optimizer`    | Medium        | **#2** — solid pass rate, fewer activations                        |
    | `deploy-checklist` | Low           | **#3** — low pass rate; the kind of skill you'd retire or rewrite  |

    The high performer is verified and tops the ranking; the weak one sits at the bottom — because [SkillScore](/guides/skillscore) is computed from live eval pass rates and AI-judge quality, not install counts.
  </Step>

  <Step title="Clean up (optional)">
    ```bash theme={null}
    decimalai demo reset
    ```

    Removes all `[Demo] `-prefixed agents, manifests, traces, and skills. Exact-prefix matched — anything you created yourself is untouched. Re-running either demo also resets first by default, so you always land in a clean state.
  </Step>
</Steps>

## What just happened

```mermaid theme={null}
%%{init: {'theme':'base','themeVariables':{'primaryColor':'#f5f5f4','primaryBorderColor':'#a8a29e','primaryTextColor':'#44403c','lineColor':'#a8a29e'}}}%%
flowchart LR
    A[Seeded agent<br/>v1 → v2 + traces] --> B[Manifest diff<br/>model · tools · prompt]
    B --> C[Trace-store query<br/>who touched what changed?]
    C --> D[Impact report<br/>HIGH / MED / LOW<br/>keep / repair / replay / drop]
```

No agent was executed and no LLM was called — the regression check is a **structural query against the trace store**, which is why it runs in seconds and costs nothing. The same mechanism, pointed at skills, produces the registry's effectiveness ranking.

## Do it with your own agent

<CardGroup cols={2}>
  <Card title="Quickstart" icon="rocket" href="/quickstart">
    Instrument your agent and get your first real trace in \~5 minutes.
  </Card>

  <Card title="Regression Check on every PR" icon="shield-check" href="/guides/regression-check">
    Wire the GitHub Action so this report appears on your next pull request.
  </Card>

  <Card title="Skills guide" icon="puzzle-piece" href="/guides/skills">
    Auto-discover your SKILL.md files and measure them on your traffic.
  </Card>

  <Card title="Run the manual loop in Colab" icon="play" href="https://colab.research.google.com/github/decimal-labs/decimalai-python/blob/main/examples/quickstart/quickstart.ipynb">
    Prefer code? Build the v1→v2 loop yourself in a live notebook.
  </Card>
</CardGroup>