Quickstart

A skill is a SKILL.md file: instructions your agent reads when a task calls for them.

Want to learn by building one agent from start to finish instead? Take the tutorial.

1. Find a skill

Open playwright-cli in the registry. It teaches a model the commands of Microsoft’s browser automation CLI, and its page shows what it changes:

Passed 23 of 23 test cases with the skill, and 7 of 23 without it.

The page also shows the model it ran on, what it costs in tokens, and its safety checks. We use this skill here because the result is easy to see: a model can’t guess this tool’s exact commands. When you’re done, search the registry for one that fits your own agent.

2. Add it where you work

Pick what your agent runs on. For the Python tabs, you need Python 3.10 or later (3.11 for Pydantic AI and Google ADK) and an API key for your model.

curl -fsSL --create-dirs -o .claude/skills/playwright-cli/SKILL.md \
  https://app.decimal.ai/s/playwright-cli/SKILL.md

Start a new Claude Code session in this folder, because Claude Code finds skills when a session starts. To install skills with a slash command, or to keep them pinned and updatable, see Claude Code.

curl -fsSL --create-dirs -o .agents/skills/playwright-cli/SKILL.md \
  https://app.decimal.ai/s/playwright-cli/SKILL.md

Cursor, Copilot, Cline and Warp read this folder by themselves. Start a new chat in this project. Every route with no SDK is in Cursor and other tools.

pip install "decimalai[langchain]" langchain-openai
export OPENAI_API_KEY="sk-..."

decimalai skills add playwright-cli

Save this as main.py:

from langchain.agents import create_agent
from decimalai.langchain import agent_config

support = agent_config(
    "my-agent", fallback="You are a helpful assistant."
)
agent = create_agent(
    "openai:gpt-5.4-mini", tools=[], middleware=[support.middleware]
)

question = (
    "What command connects the browser CLI tool "
    "to a browser already running on http://localhost:9222?"
)
result = agent.invoke(
    {"messages": [{"role": "user", "content": question}]}
)
print(result["messages"][-1].text)

pip install "decimalai[openai-agents]"
export OPENAI_API_KEY="sk-..."

decimalai skills add playwright-cli

Save this as main.py:

from agents import Agent, Runner
from decimalai.openai_agents import agent_config

support = agent_config(
    "my-agent", fallback="You are a helpful assistant."
)
agent = Agent(
    name=support.name,
    instructions=support.instructions,
    tools=[*support.tools],
)

question = (
    "What command connects the browser CLI tool "
    "to a browser already running on http://localhost:9222?"
)
print(Runner.run_sync(agent, question).final_output)

pip install "decimalai[claude-agent-sdk]"
export ANTHROPIC_API_KEY="sk-ant-..."

decimalai skills add playwright-cli

Save this as main.py:

import asyncio

from claude_agent_sdk import ClaudeAgentOptions, ResultMessage
from decimalai.claude_agent_sdk import agent_config

support = agent_config(
    "my-agent", fallback="You are a helpful assistant."
)
options = ClaudeAgentOptions(
    model="claude-haiku-5-5",
    tools=[],            # none of Claude Code's own tools: no shell, no files
    setting_sources=[],  # nothing from this machine's Claude settings
)

async def main():
    question = (
        "What command connects the browser CLI tool "
        "to a browser already running on http://localhost:9222?"
    )
    async with support.run(question) as run:
        async for message in run.query(options=options):
            if isinstance(message, ResultMessage):
                print(message.result)

asyncio.run(main())

pip install "decimalai[openai]"
export OPENAI_API_KEY="sk-..."

decimalai skills add playwright-cli

Save this as main.py:

from openai import OpenAI
from decimalai.openai import agent_config

client = OpenAI()
support = agent_config(
    "my-agent", fallback="You are a helpful assistant."
)

question = (
    "What command connects the browser CLI tool "
    "to a browser already running on http://localhost:9222?"
)
with support.run(question) as run:
    messages = [{"role": "system", "content": run.system}, run.message]
    while True:
        reply = client.chat.completions.create(
            model="gpt-5.4-mini", messages=messages, tools=[*run.tools],
        ).choices[0].message
        messages.append(reply)
        if not reply.tool_calls:
            break
        for call in reply.tool_calls:
            # load_skill is answered by the run. Answer your own tools here.
            messages.append(run.tool_result(call) or {
                "role": "tool",
                "tool_call_id": call.id,
                "content": "No such tool.",
            })
print(reply.content)

pip install "decimalai[anthropic]"
export ANTHROPIC_API_KEY="sk-ant-..."

decimalai skills add playwright-cli

Save this as main.py:

import anthropic
from decimalai.anthropic import agent_config

client = anthropic.Anthropic()
support = agent_config(
    "my-agent", fallback="You are a helpful assistant."
)

question = (
    "What command connects the browser CLI tool "
    "to a browser already running on http://localhost:9222?"
)
with support.run(question) as run:
    answer = client.beta.messages.tool_runner(
        model="claude-haiku-5-5",
        max_tokens=4096,
        system=run.system,
        tools=[*run.tools],
        messages=[{"role": "user", "content": question}],
    ).until_done()
print("".join(b.text for b in answer.content if b.type == "text"))

pip install "decimalai[google-genai]"
export GOOGLE_API_KEY="..."

decimalai skills add playwright-cli

Save this as main.py:

from google import genai
from google.genai import types
from decimalai.google_genai import agent_config

client = genai.Client()
support = agent_config(
    "my-agent", fallback="You are a helpful assistant."
)

question = (
    "What command connects the browser CLI tool "
    "to a browser already running on http://localhost:9222?"
)
with support.run(question) as run:
    chat = client.chats.create(
        model="gemini-3.5-flash",
        config=types.GenerateContentConfig(
            system_instruction=run.system,
            tools=[*run.tools],
        ),
    )
    answer = chat.send_message(run.message)
print(answer.text)

pip install "decimalai[pydantic-ai]"   # Python 3.11 or later
export OPENAI_API_KEY="sk-..."

decimalai skills add playwright-cli

Save this as main.py:

from pydantic_ai import Agent
from decimalai.pydantic_ai import agent_config

support = agent_config(
    "my-agent", fallback="You are a helpful assistant."
)
agent = Agent(
    "openai:gpt-5.4-mini", name=support.name, capabilities=[support]
)

question = (
    "What command connects the browser CLI tool "
    "to a browser already running on http://localhost:9222?"
)
print(agent.run_sync(question).output)

pip install "decimalai[adk]"   # Python 3.11 or later
export GOOGLE_API_KEY="..."

decimalai skills add playwright-cli

Save this as main.py:

import asyncio

from decimalai.adk import agent_config
from google.adk.agents import LlmAgent
from google.adk.runners import InMemoryRunner
from google.genai import types

support = agent_config(
    "my-agent", fallback="You are a helpful assistant."
)
agent = LlmAgent(
    name="my_agent",  # ADK's own name: a Python identifier
    model="gemini-3.5-flash",
    instruction=support.instruction,
    tools=[*support.tools],
)
runner = InMemoryRunner(agent=agent, app_name="quickstart")

async def main():
    question = (
        "What command connects the browser CLI tool "
        "to a browser already running on http://localhost:9222?"
    )
    session = await runner.session_service.create_session(
        app_name="quickstart", user_id="me"
    )
    message = types.Content(role="user", parts=[types.Part(text=question)])
    async for event in runner.run_async(
        user_id="me", session_id=session.id, new_message=message
    ):
        if event.is_final_response():
            content = event.content
            print(content.parts[0].text if content else event.error_message)

asyncio.run(main())

pip install "decimalai>=0.27" "crewai>=1.15.27"
export OPENAI_API_KEY="sk-..."

decimalai skills add playwright-cli

Save this as main.py:

import decimalai.crewai
from crewai import LLM, Agent, Crew, Task

agent = Agent(
    role="Assistant",
    goal="Answer the question",
    backstory="A helpful assistant.",
    llm=LLM(model="gpt-5.4-mini"),
    skills=decimalai.crewai.skills(),      # the installed folder
    tools=decimalai.crewai.skill_tools(),  # reads a skill's files
)
question = (
    "What command connects the browser CLI tool "
    "to a browser already running on http://localhost:9222?"
)
task = Task(
    description=question
    + " Load any skill that could apply before you answer.",
    expected_output="The command",
    agent=agent,
)
print(Crew(agents=[agent], tasks=[task]).kickoff())

In our runs, a CrewAI agent often skipped a skill unless the task asked it to look first, so this task does. This is CrewAI’s own skill loader. With a DecimalAI key, instrument(agent_name="my-agent", enable_skill_loader=True) from decimalai.crewai serves an agent’s saved skills instead: see CrewAI.

Deep Agents, Microsoft Agent Framework, Strands: after decimalai skills add playwright-cli, their own skill loaders read the same folder. See Native skill loaders.
Anything else: fetch the file and give its text to your model as instructions. No account or package needed:

curl -fsSL https://app.decimal.ai/s/playwright-cli/SKILL.md

LlamaIndex and generic OpenTelemetry are tracing only, so skills don’t reach them this way. See OpenTelemetry.

3. See what it changes

Ask your agent this. In the Python tabs, python main.py already does:

What command connects the browser CLI tool to a browser already running on http://localhost:9222?

What you should see: the real command.

playwright-cli attach --cdp=http://localhost:9222

To compare, take the skill away and ask again. In the Python tabs, run decimalai skills remove playwright-cli. In Claude Code or an editor, delete the file and start a new session. The model now names some other tool, makes a command up, or gives a list of guesses. Then put the skill back, with decimalai skills add playwright-cli or by saving the file again. This skill shows a clear result because it holds facts a model can’t guess. Many skills change an agent less obviously, and a high score doesn’t guarantee they help yours. So test them on your own cases: see Test a change, and Part 5 of the tutorial for a worked example. Here’s what happened in the Python tabs: agent_config() gave your agent a short list of its skills and a load_skill tool. The model read the list, decided this skill applied, and opened it. With no DecimalAI key, the list comes from your project, and nothing is sent to DecimalAI. How skills reach the model has the detail.

Add a key to do more

Your agent works without an account. A free account adds this, on the Python frameworks with agent_config():

With a key	What it means
Change without redeploying	Edit the agent’s prompt and skills in the dashboard, and the next run uses them
See what each run did	Every run is traced: which skills it was offered and which it opened, its tool calls, and the versions it ran on
Test a change	Compare your agent with and without a skill, across a set of cases. `decimalai.evaluate()` runs OpenAI Agents SDK agents today; Test a change covers other frameworks

export DECIMAL_API_KEY="dai_sk_..."
python main.py

Run it inside a git repository (git init if you aren’t in one). The first run creates the agent in your workspace, copies your skills onto it, and writes .decimal/link.toml. Outside a repository your skills aren’t copied. Commit that file. From then on, the agent’s skills live on DecimalAI, and decimalai skills add adds a skill to the agent there. Claude Code and editors read files from your project, so a key doesn’t change anything there.

No agent yet?

You don’t need any agent code to start.

Create the agent. Use the dashboard form, start from a skill pack for your kind of agent, or use the CLI:

pip install "decimalai[langchain]" langchain-openai
export DECIMAL_API_KEY="dai_sk_..."
export OPENAI_API_KEY="sk-..."
decimalai agents create refund-bot --pack support

Generate the code and run it. This looks the agent up by name, and writes an agent.py that reads its prompt and skills from your workspace:
decimalai init refund-bot python agent.py
Prefer another framework? Add --framework with openai-agents, pydantic-ai, adk, anthropic, openai or google-genai, and install what it prints.
Replace the blanks. A pack’s starter prompt has blanks in angle brackets for what only you know, such as <product>. Fill them in on the agent’s Prompt & skills page.

To change	Where	When it takes effect
The system prompt	The agent’s Prompt & skills page	The next run within a minute, with no restart
Its skills	The agent’s Prompt & skills page	Within about 30 seconds, with no restart
The framework or model	Rerun `decimalai init` with `--framework` or `--model`, and `--force` to overwrite	The next run

If something goes wrong

The model didn’t use the skill. Check the file is where this page says. In Claude Code or an editor, start a new session. You can also ask for it by name: “use the playwright-cli skill”.
ModuleNotFoundError. Run the pip install line in the same virtual environment you run main.py from.
An older decimalai was installed. On Python 3.10, the Pydantic AI and ADK extras quietly install an older release. pip show decimalai tells you which one you got.
No agent named …. The name in decimalai init must match the agent exactly. The error suggests the closest match.
No run in the dashboard. Check that DECIMAL_API_KEY is set in the shell that ran your program, then see Troubleshooting.

Your framework

Your own tools, conversations, changing the prompt, and tracing.

Find more skills

Search the registry, read a skill’s results, and start from a pack.

Build a whole agent

The five-part tutorial, from a web page to measured changes in your code.

Write your own skill

Write a skill that triggers at the right times and changes what your agent does.

Start here

Tutorial: a support agent

Use skills

Manage and measure

Publish a skill

More

1. Find a skill

2. Add it where you work

3. See what it changes

Add a key to do more

No agent yet?

If something goes wrong

Next

Your framework

Find more skills

Build a whole agent

Write your own skill

​1. Find a skill

​2. Add it where you work

​3. See what it changes

​Add a key to do more

​No agent yet?

​If something goes wrong

​Next

Your framework

Find more skills

Build a whole agent

Write your own skill

1. Find a skill

2. Add it where you work

3. See what it changes

Add a key to do more

No agent yet?

If something goes wrong

Next