Skip to main content

See it first — 2 minutes, no waiting for your own data

The impact report and the skills leaderboard are most convincing on real data — so both ship with a one-command sandbox that seeds a realistic agent and trace corpus into your workspace. See the payoff before you instrument anything.
pip install decimalai   # requires Python 3.10+
export DECIMAL_API_KEY="dai_sk_..."   # grab one at app.decimal.ai/settings
DecimalAI requires Python 3.10 or newer. On Python 3.9 and older, pip silently installs an outdated release that lacks the demo command.
Pick the door that matches your job — or run both:

For engineers

Catch regressions before they ship.
decimalai demo regression
Seeds a v1→v2 agent change and links you straight to the impact report — which production traces the change would break, which may behave differently, and which are unaffected.

For prompt engineers

Find skills that actually work.
decimalai demo skills
Seeds three skills with real, varied effectiveness and links you to the ranked registry — per-model pass rates and cross-org activation, not download counts.
No account yet? Browse the public skill registry right now — no signup — to see skills ranked by production effectiveness.
Once a demo makes the value land, wire DecimalAI to your own agent below.
You’ll do five things in this guide:
1

Install the SDK

1 minute.
2

Get your API key and verify your setup

1 minute.
3

Instrument your agent

3 minutes.
4

View your first trace in the dashboard

1 minute.
5

Add the GitHub Action so every PR gets a manifest impact report

5 minutes.
By the end, your team’s next agent change will get an automatic structural impact analysis on the PR — without you writing any eval cases. Here’s the kind of report that lands on the PR:

Run this in Colab

Run the SDK portion interactively — no local setup required.

1. Install the SDK

pip install decimalai   # requires Python 3.10+

2. Get Your API Key

Sign in to the DecimalAI Dashboard and navigate to Settings → API Key. Or generate one via the API:
curl -X POST https://api.decimal.ai/api/v1/api-keys \
  -H "Authorization: Bearer <your-token>" \
  -d '{"label": "my-key", "scope": "global"}'
Verify your setup instantly: Run decimalai init to check your API key, test connectivity, and send a test trace — all in one command.
You should see:
✓ API key: dai_sk_8f3...3a2c
✓ Connected to workspace: ws_7Hq2Kp (scope: workspace)
✓ Test trace sent successfully

→ Open dashboard: https://app.decimal.ai/traces
→ Docs: https://docs.decimal.ai/quickstart
→ Quickstart notebook: https://colab.research.google.com/github/decimal-labs/decimalai-python/blob/main/examples/quickstart/quickstart.ipynb

3. Instrument Your Agent

import decimalai

decimalai.init(
    api_key="dai_sk_...",
    langchain=True,
)

# Run your agent as usual — traces are captured automatically
agent.invoke({"input": "Hello!"})

Run this in Colab

Live notebook, no setup — just paste your API key.
Auto-detection depth varies by framework. LangChain and OpenAI Agents (with explicit install(agent=...)) extract full tool schemas; LlamaIndex / CrewAI / AutoGen extract tool names only. See the capability matrix before deciding which integration to commit to.

4. View Your Traces

Open the Traces page in the dashboard. Your first trace should appear within seconds. Each trace is auto-tagged with the of the agent that produced it — this is what powers the regression check in the next step.
Skills (SKILL.md files) in your project are auto-discovered and tracked automatically — no extra configuration needed. See Skills.
Now wire DecimalAI into your CI so every PR gets a manifest impact report. This is the most-used capability for engineering teams. Three things, all copy-pasteable below: a tiny scripts/init_for_decimal.py that calls your agent factory, a .github/workflows/decimal.yml that runs it under DECIMALAI_MODE=manifest_only, and your DECIMAL_API_KEY in GitHub Secrets. Here’s what runs on every PR: 1. Add scripts/init_for_decimal.py — five lines that import and call your existing agent factory. In manifest_only mode the SDK reads tools, prompts, and models from the runtime objects, then exits without any LLM calls:
scripts/init_for_decimal.py
from myapp.agent import build_agent  # adjust to your agent factory

if __name__ == "__main__":
    build_agent()  # DECIMALAI_MODE=manifest_only captures the manifest, no LLM calls
2. Add .github/workflows/decimal.yml:
.github/workflows/decimal.yml
name: Decimal Manifest Impact
on: [pull_request]

jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.12'
      - name: Install dependencies
        run: pip install -e .
      - name: Manifest extraction
        env:
          DECIMALAI_MODE: manifest_only
          DECIMAL_API_KEY: ${{ secrets.DECIMAL_API_KEY }}
          OPENAI_API_KEY: dummy_for_init  # placeholder; NOT called in manifest_only mode
        run: python scripts/init_for_decimal.py
      - name: Impact check
        uses: decimal-labs/regression-check@v1
        with:
          api-key: ${{ secrets.DECIMAL_API_KEY }}
          agent-name: support-agent  # the same name you use in decimalai.init()
3. Add the DECIMAL_API_KEY secret in Settings → Secrets and variables → Actions → New repository secret, with the value from app.decimal.ai/settings. That’s the whole setup. On your next PR you’ll get a comment like this within ~30 seconds:
🔍 Decimal Manifest Impact — support-agent

🔴 HIGH IMPACT — 247 traces will break (called the removed `compare_competitors` tool)
🟡 MEDIUM IMPACT — 501 traces may behave differently
🟢 LOW IMPACT — 1,254 traces unaffected
Full setup, troubleshooting, severity thresholds, override behavior, and alerting are in the Regression Check Guide.

Here for skills instead?

The steps above wire up the regression capability — what most teams start with. The skills workflow is a separate, shorter track (no GitHub Action needed):
1

Browse the registry

Find skills ranked by SkillScore in the public registry — no signup.
2

Prove one helps

A/B-benchmark a skill with skillevaluation (pip install "skillevaluation[runner]") to measure its lift on your own cases.
3

Install it

Fork it into your workspace and write it to disk with router.install(...) — see the Skills guide.

Next Steps

Regression Check Guide

Full configuration, troubleshooting, and severity tuning for the GitHub Action.

Manifests Guide

What manifests capture, how diffs work, and the compatibility policy model.

Concepts

How traces, manifests, evals, and datasets connect.

Training Pipeline

End-to-end: trace → evaluate → fine-tune.