Browse the registry

The registry is a public marketplace of agent skills. Anyone with an account can publish to it, and DecimalAI publishes there on the same terms as everyone else. Each skill’s page shows its evidence: how it did in a benchmark run with and without the skill, how it does in real use, and whether it passed its safety checks. You can search the registry and read any skill, including its full SKILL.md, with no account.

Search and browse

No key or account needed:

decimalai skills search "browser automation"

It prints each skill’s summary and test results, and the command that adds it.

Open app.decimal.ai/skills. Narrow the list by search text, source, category, skill type or pack, then choose a sort:

Sort	Ranks by
Clear results (the default)	SkillScore order, showing only maintained skills that passed safety checks and passed at least 1 in 5 more test cases than the model alone. Show all or a search shows everything.
Highest SkillScore	Evaluated quality, across every skill. See SkillScore.
Biggest lift	Verified benchmark lift: with the skill versus without it.
Most popular	All-time times used, with distinct users as the tiebreak.
Most installed	How many agents have the skill set up now.
Recently added	Creation date.

Each card shows the skill’s identifier (the name you add it by), its source, its safety chip once reviewed, its type and its SkillScore. It also shows whichever of these the skill has: benchmark lift, lifetime live pass rate, lifetime users and lifetime times used.The leaderboard is a different view: the top 50 by weight of evidence, with a category filter. Its column headers re-sort those 50 rows only, so sorting it by lift doesn’t give you the top 50 by lift. Biggest lift above does.

The Python client needs an API key even to search. The Terminal and cURL routes don’t.

from decimalai import SkillRouter

router = SkillRouter()  # key from decimalai.init() or DECIMAL_API_KEY

results = router.search("code review security", sort="recommended", limit=20)
for skill in results:
    score = (skill.get("effectiveness") or {}).get("skill_score")  # 0 to 1; pages show 0 to 100
    print(skill["url_slug"], score, skill["total_users"], skill["total_uses"])

sort also takes lift, popular, installs, recent, top_rated and efficiency. Filter with category=, tags= or badge=.

No key needed:

curl -s "https://api.decimal.ai/api/v1/registry/skills?q=code+review&sort=recommended&limit=10"

Add the registry to any MCP client once, and finding a skill becomes a question you ask your agent. It needs no API key:

claude mcp add decimalai -- uvx decimalai-mcp

Find me a measured skill for code-review security, and show me its
benchmark evidence and safety scan before I add anything.

There are three read-only tools: search_skills, get_skill and get_leaderboard. They never write files. Once you’ve picked a skill, add it.

The DecimalAI plugin searches from inside a session, with no key and nothing to pip install:

/decimalai:search code review security

Setup and the install command are on the Claude Code page.

Preview a skill from code

preview reads a public skill’s body and metadata and changes nothing in your workspace: no copy, no link. It returns None when no public skill has exactly that name.

from decimalai import SkillRouter

router = SkillRouter()  # key from decimalai.init() or DECIMAL_API_KEY

snapshot = router.preview("pdf")
if snapshot:
    print(snapshot["body_markdown"][:500])

How to read a skill page

Every public skill has a page at app.decimal.ai/skills/<url_slug>. The part above the tabs is its scorecard: what the skill does, where it came from, whether it is safe and what it measurably changes. Choosing a framework in Use this skill changes the steps, not the evidence.

The header

The header gives the category, the author, the title and the identifier, followed by a line on what the skill does. Under that come the SkillScore, the type chips, any pack tags and a Last verified date. Beside them are three facts:

Source: the repository or publisher it came from.
License: the license it declares, or Not recorded.
Safety checks: N of 3 passed: one verdict each for Code scan, Intent and Content. How skills are vetted says what each one looks for.

The source says where it came from, not whether it’s good

On the card	In the API (`skill_badge`)	Means
Community	`community`	Authored on DecimalAI and published by its author. DecimalAI’s own skills carry it too.
GitHub	`imported`	Synced from a public GitHub repository.
★ (the Featured filter)	`featured`	A `community` skill that a weekly job promoted on its own numbers: its SkillScore, how often it was forked and how recently it was created. The job moves it back to `community` when it stops qualifying.

Nobody hand-picks any of these, so none of them replaces reading the evidence.

The type chips

A classified skill carries chips on two axes, plus how it fires. An unclassified skill shows no chip.

Chip	Means	What to check
Capability	The base model can’t do this yet.	With Public, this is the one pairing that expires, because a future model may learn it. Check Last verified and the verification history: a big lift measured two model generations ago may be zero now.
Preference	The base model can do this. The skill steers the form.	Its number is labeled conformance, not lift. It rarely fades with new models. It fails by firing at the wrong time, so check trigger health.
Public / Private	A standard a model may learn, or house knowledge it never will.
Automatic / On-demand / Automatic + on-demand	Whether the model loads it by itself when a task matches, or only when called by name.	The When it activates card repeats this in a sentence, and Not for lists what the skill rules out. Check that it doesn’t overlap another skill on your agent.

What it changes

This card reports one benchmark run, for one model and one version of the skill. A skill’s headline reads like this:

Passed 9 of 12 test cases with the skill, and 4 of 12 without it.

(Those numbers are an illustration.) Under it are two bars, the checks the skill passed that the model alone missed, and how every case came out: fixed, passed either way, still failing and broke. Broke counts cases that passed without the skill and failed with it, so read it first. Then come Pass-rate lift in points, and the change in Tokens, Agent turns and, when recorded, Response time. Those last three describe resource use, not a dollar price. The context line names the model, the date and the skill version. A skill measured on several models has a Model picker, and each model has its own numbers. Read the notices under the card. Lift withheld means the run had too few comparable cases, errored too much or wasn’t graded comparably, so no lift is claimed. Another notice says when the run measured an earlier version of the skill.

In real use

Quality appears only once there are at least ten qualifying results over the skill’s lifetime: the share of evaluated runs that passed, and the average AI rating out of 10.
Adoption shows Users and Times used, both over the skill’s lifetime.

No number on the page counts installs. Users and Times used count people and uses, so a skill can score high on them with few installs, and the other way round. Installs appear in two other places:

The Most installed sort ranks by how many agents have the skill set up now. The API calls that number install_agents.
The API’s install_count counts how many times the skill was forked and never goes down, so don’t read it as adoption.

None of these feeds the SkillScore. SkillScore has the exact definitions.

Three numbers, three questions

Number	Question it answers	Where it comes from
Lift	Did this skill improve an agent, with versus without?	The skillevaluation benchmark, on its model and its cases.
SkillScore	Does it work overall?	0 to 100, blended from a verified benchmark, live task evaluations and AI ratings.
Safety	Is it safe to load?	The safety checks, folded into one band. The chip on a card reads Screened (`passed` in the API), Caution or Blocked.

Keep them apart. A high SkillScore with an old re-test may rest on old evidence, and a strong benchmark says nothing about safety.

Verified and unverified evidence

Benchmark results reach DecimalAI in two ways, and they don’t count equally:

Verified runs were accepted by DecimalAI. The platform either ran both sides on its own key, re-graded outputs the publisher produced elsewhere (replay in the verification history), or re-graded them and re-ran a sample of the cases itself (spot-checked). Only verified runs reach the public page, rankings, registry cards and the SkillScore.
Unverified · local import runs were pushed from someone’s own skillevaluation run. Only the skill’s own organization sees them, and they never rank.

Because only verified runs count, the run shown can be older than the skill’s newest version. The page says so when it is. Verified runs has the details.

The tabs

The tabs are Overview, Benchmark, Contents, Activity, Versions and Ratings. Overview has one recorded before and after, a preview of the SKILL.md, and the safety and source details. Benchmark has the full report, case by case, and the SkillScore breakdown. Two more panels live there:

Trigger health appears when the eval suite has trigger cases. It answers whether the skill fires when it should and stays quiet when it shouldn’t. Menu selection, False-fire rate and Router recall come from the eval suite. Delivered when offered comes from production traffic. A dash means not measured, not zero. A skill that helps but never fires is broken in a way its lift can’t show.
Verification history reads Verified on a model, re-tested on a date. Lift depends on the model, so this tells fresh evidence from stale.

A quick check before you add a skill: safety passed (read the findings on Caution), lift measured on the current version, a recent re-test if it’s Capability and Public, healthy trigger numbers if it’s Automatic, and a Not for line that doesn’t collide with another skill on your agent.

Add a skill

Route	What it needs	What changes
`decimalai skills add`, project not connected	The CLI. No account for a public skill.	Files in your project
`decimalai skills add`, project connected or with `--to-agent`	The CLI and an API key	The agent on DecimalAI. No files.
The dashboard	Sign-in and the Editor role	The agent on DecimalAI
The SDK	An API key	The agent on DecimalAI
A copied file	Nothing	One file, wherever you put it

These routes respond differently when the author publishes a new version. Update, pin or fork a skill compares them.

`decimalai skills add`

This command has two behaviours, and which one you get depends on the project. Flags are in the CLI reference. Not connected to DecimalAI, it writes files:

$ decimalai skills add pdf
  ✓ added pdf v1 as .agents/skills/pdf

That writes three things to commit:

.agents/skills/pdf/: the skill’s SKILL.md and bundled files.
.decimal/skills.toml: the list of skills the project wants.
.decimal/skills.lock: the exact bytes that were written.

agent_config() with no key offers the skills on that list, and a framework’s own loader reads the folder. In CI and Docker, decimalai skills install --frozen restores exactly those bytes. Skills on disk covers the files and commands. Connected, it adds to the agent on DecimalAI and writes none. A project is connected when it has .decimal/link.toml. The first agent_config() run with an API key writes that file and copies the project’s list onto the agent once. After that, the agent’s skills live on DecimalAI:

$ decimalai skills add pdf
  ✓ added pdf to agent 'support' on DecimalAI (v1, following the latest)
  • .decimal/skills.toml is unchanged: agent 'support' gets its skills from DecimalAI (this project is connected: .decimal/link.toml).

It needs DECIMAL_API_KEY. A project connected for more than one agent has to say which, with --to-agent. --to-agent does the same in any project:

decimalai skills add pdf --to-agent support

It needs a key as well. An agent name DecimalAI hasn’t seen is created. Three rules apply either way:

Safety. A Blocked skill is refused. Caution or not yet reviewed asks on a terminal, and without one it is refused unless you pass --yes.
Versions. pdf follows the latest, and pdf@3 pins version 3. See the four ways to pin.
A skill you wrote. Give the folder name of .agents/skills/<name>/. Not connected, it is listed in .decimal/skills.toml under [authored]. Connected, it is uploaded to your organization, not published, and added to the agent.

The same file-writing engine works from Python, for a notebook or a setup script. A refusal comes back in the result instead of raising:

from decimalai import skillpkg

result = skillpkg.add("pdf")
if result.exit_code:
    raise SystemExit(result.problems)

From the dashboard

On the skill’s page, the Manage it in DecimalAI card has Add to an agent (Manage installation once it’s installed). Under Install linked:

Apply to: All current and future agents, or Selected agents.
Version: Follow latest safe version, or a pinned version.
Click Install linked skill.

With DECIMAL_API_KEY set, agent_config() in that agent’s code then gets the skill, with no command to run and no redeploy. New agent with this skill, in the same dialog, opens the create form with the skill selected. You can also start from the agent. On its Prompt & skills page, Add skill opens a picker with a registry search, and the change goes through Review & apply. See Prompt, skills and versions.

From the SDK

from decimalai import SkillRouter

router = SkillRouter()  # key from decimalai.init() or DECIMAL_API_KEY

router.use("pdf")                                           # every agent in the workspace
router.use("pdf", scope="agent", agents=["support-agent"])  # named agents only

# One agent, by skill id. An agent DecimalAI hasn't seen is created.
skill = router.preview("pdf")
router.assign_skill("support-agent", skill["skill_id"])

For a skill you own, see Which agents get a new skill.

Files, with no SDK

The Use this skill card on every skill page has the steps for your framework, with no account: Command line, In Python, Inside Claude Code or Copy the file, as that framework allows. The plain fetch is one line:

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

A copied file is yours to manage. No list or lock records it, so agent_config() leaves it out and nothing pins or updates it. It also stops at SKILL.md, so a skill’s other files don’t come with it. Cursor and other tools has every route. In Claude Code, the plugin also writes the bundled files: see Claude Code.

Skill packs

A pack starts an agent for a role. It has a starter prompt and up to eight starter skills, picked for that role from the registry. Skills give an agent instructions, not tools, so a pack connects nothing for you. The prompt has blanks in angle brackets, such as <product>, for what only you know. There are 32 packs. A pack’s id is the last part of its page’s URL, app.decimal.ai/skills/packs/<id>.

All pack ids

ai-engineer, clinical-healthcare, coding, customer-success, data-analyst, data-engineer, design-ux-review, devops-sre, doc-ops, finance-accounting, finserv-compliance, frontend-ui-engineer, government-public-sector, hr-people-ops, insurance-claims, knowledge-management-notes, legal-contracts, marketing-content, personal-assistant, procurement, product-management, project-management, qa-test-engineer, real-estate-property, recruiting, research, sales-gtm, security-appsec, support, translation-localization, tutoring-education, writing-editing.An id the server doesn’t know gets an error that lists them all.

Review the pack

Open the pack gallery and pick a role. The pack’s page shows the starter skills grouped by the step of the work they cover, the starter prompt, and add-ons. A recorded before and after appears when one is available. It measures one skill on one case, so it doesn’t speak for the whole pack.

Create the agent

The form at agents/new?pack=<id>, for example agents/new?pack=support, opens with the prompt filled in and the starter skills ticked. Or use the CLI:

decimalai agents create my-agent --pack support

This needs an API key. The agent’s starter skills are linked, not copied, so they follow their authors’ updates.

Generate the code

decimalai init my-agent
python agent.py

decimalai init looks the agent up by name and writes an agent.py that reads its prompt and skills from your workspace. It writes LangChain code unless you pass --framework. The Quickstart has the install line and keys.

Already have an agent? On a pack’s page, choose it under Have an agent already?, or run decimalai agents apply-pack my-agent support. Both show the change first: the starter prompt becomes the agent’s next prompt version, and the starter skills are added. See the CLI reference.

The Support starter project

Support is the one pack with a generated project. It’s a shortcut: the tutorial builds the same kind of agent step by step, and is the better place to start. It drafts replies only: tools for refunds or account deletion aren’t connected. There are three ways to run it, and none needs another first.

Way	DecimalAI account	Model access	You get
Download it	None	Your OpenAI key	A frozen local project that sends nothing to DecimalAI
Connect your code	Sign-in and a key	Your model provider’s key	An SDK project, with its runs in your workspace
Try a live sample	Sign-in	Ours, while trial capacity lasts	An ungraded answer, and up to three attempts

Download it. The Support builder lets you review the prompt and skills, then Download agent project. The CLI gets the same project:

decimalai starter support --project ./my-support-agent --name my-support-agent
cd my-support-agent
python3 agent.py --check-setup
export OPENAI_API_KEY="your-provider-key"
python3 agent.py --task 'Draft a reply to a customer who reports a duplicate charge.'
python3 agent.py --checks

It needs Python 3.10 or later and no pip dependencies. Its prompt and skills are frozen into the project, and it gives the model their full text, with no agent_config() involved. To change them, generate the project again. --check-setup checks the files with no model call. --checks makes four paid calls: two sample tasks and two judge calls. Connect your code. On the Support pack’s page, choose Connecting your own code? Create a connected agent, and name the agent. The project’s checks need three of its starter skills, so keep them selected: billing-dispute-resolution, support-reply-format and account-deletion-verification-policy. Then:

python -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade "decimalai[langchain,evals]"
export DECIMAL_API_KEY="your-workspace-key"
decimalai init my-support-agent --project ./my-support-agent
cd my-support-agent
python -m pip install -r requirements.txt
cp .env.example .env

Fill in your DecimalAI and model-provider keys in .env, then run the agent and its checks. Both make real model calls and send their runs to your workspace:

python agent.py 'Draft a reply: a customer sees a pending $29 authorization and a separate settled $29 charge.'
python check_agent.py

The check runs the same agent on two sample cases, an authorization hold and an unavailable account deletion. It confirms the skill bodies reached the model, grades the answers with a model judge, and matches the runs in your workspace. Exit code 0 means those two cases passed, not that the agent is good in general. If only the run confirmation was slow, python check_agent.py --resume retries it with no new model calls. See Support project with checks. Try a live sample. In the builder, choose Save and try live, then pick a sample scenario and Run live sample. It runs on our servers, when trial capacity is available. A live sample doesn’t test your machine, your code or your tools. Test the whole agent as well. A benchmark tests one skill. When you change an agent’s skills, rerun a fixed set of full tasks and compare, since two skills can interfere in ways neither one’s benchmark shows. Evaluations has the tools.

How effectiveness is computed

A published skill earns a SkillScore from 0 to 100 by blending the quality evidence it has: a verified benchmark, live task evaluations and AI ratings. Usage, installs and stars are not inputs, so a popular skill can’t outrank one that works just by being popular. A skill with no eligible evidence shows New. SkillScore has the weights, the evidence floors, and what’s public versus private to your team.

Forking and updates: Update, pin or fork a skill.
Publishing your own skill: Publish a skill.
Running a loader and DecimalAI together: Don’t deliver a skill two ways.
How many skills you can own and link: Pricing.
The SDK and the API: Skills in the SDK and the skill router contract.

Start here

Tutorial: a support agent

Use skills

Manage and measure

Publish a skill

More

Browse the registry

Search and browse

Preview a skill from code

How to read a skill page

The header

The source says where it came from, not whether it’s good

The type chips

What it changes

In real use

Three numbers, three questions

Verified and unverified evidence

The tabs

Add a skill

`decimalai skills add`

From the dashboard

From the SDK

Files, with no SDK

Skill packs

The Support starter project

How effectiveness is computed

​Search and browse

​Preview a skill from code

​How to read a skill page

​The header

​The source says where it came from, not whether it’s good

​The type chips

​What it changes

​In real use

​Three numbers, three questions

​Verified and unverified evidence

​The tabs

​Add a skill

​decimalai skills add

​From the dashboard

​From the SDK

​Files, with no SDK

​Skill packs

​The Support starter project

​How effectiveness is computed

​Related

Search and browse

Preview a skill from code

How to read a skill page

The header

The source says where it came from, not whether it’s good

The type chips

What it changes

In real use

Three numbers, three questions

Verified and unverified evidence

The tabs

Add a skill

`decimalai skills add`

From the dashboard

From the SDK

Files, with no SDK

Skill packs

The Support starter project

How effectiveness is computed

Related