pheo-ai/clawhub-consequence-classes

ClawHub Consequence Classes

For every public agent skill, this says what it tells an agent to do — and whether any of those things need a person to approve them, every time.

One row per skill. Join it to OpenClaw/clawhub-security-signals on skill_slug.

The idea, in one analogy

A bank does not decide a wire transfer by asking whether the customer looks like a criminal. It asks a different question: what is this customer established to do here?

A new account holder can deposit a cheque on day one. They cannot wire $500,000 to a new overseas beneficiary on day one. Nothing is wrong with them. They simply have no track record yet, so the limit is low and a person looks at the big things.

As the relationship builds, limits rise on their own. The bank stops asking about routine transfers because it has seen hundreds of them go fine. But some transactions never stop needing a second pair of eyes, no matter how long you have banked there — and everyone understands why.

This dataset is that, for agent actions.

It does not ask whether a skill is dangerous. It asks what class of action the skill instructs an agent to perform — install software, read a credential, delete a directory, run something downloaded from the internet — so that a limit can be set against each class, the way a bank sets one against each kind of transaction.

A skill that runs an installer is doing its job. So is a bank customer wiring money. The point is not suspicion. The point is knowing what kind of action it is, so the right amount of attention goes to it.

What is in it

Column	Meaning
skill_slug	Joins to the source corpus
split	train, validation, test, eval_holdout — same splits as the source
classes	Consequence classes this skill instructs, ;-separated
n_classes	How many distinct classes
max_severity	Severity of the most serious class, 0–100
requires_review	True if any class can never run unattended
shell_blocks	Shell blocks found in the skill
unresolved_blocks	Blocks that failed to classify — counted, never treated as clean

action-classes.json ships alongside as the codebook: all 33 classes with their label, severity, and whether they can ever graduate.

requires_review is the column most people want. It is True when a skill instructs at least one action of a class that no amount of track record unlocks — the wire transfer that always gets a second look.

Across the corpus: 66,192 skills, 25,779 instructing at least one action, 1,413 instructing something that always needs a person. No block failed to classify.

One note if you are comparing against the paper. requires_review counts all thirteen never-graduating classes. The paper's headline figure leaves out secret_change, which fires on any documented .env reference — a correct classification but a weak signal, since nearly every skill needing an API key has one. To get the paper's number:

import json
import pandas as pd

spec = json.load(open("action-classes.json"))
never_graduating = {c["key"] for c in spec if not c["graduates"]}

classes = pd.read_csv("clawhub-consequence-classes.csv")
sets = classes.classes.fillna("").apply(lambda s: set(s.split(";")) - {""})
classes["unearned"] = sets.apply(
    lambda s: bool((s & never_graduating) - {"secret_change"})
)

Joined to the source corpus and restricted to skills every scanner calls clean, that yields 705 skills from 135 publishers — the figure the paper reports.

Using it

from datasets import load_dataset

classes = load_dataset("pheo-ai/clawhub-consequence-classes", split="train")

# Skills that instruct something needing a person every time
needs_a_person = classes.filter(lambda r: r["requires_review"])

Or join to the source corpus to ask your own questions:

import pandas as pd

signals = pd.read_parquet("clawhub-security-signals.parquet")
classes = pd.read_csv("clawhub-consequence-classes.csv")
both = signals.merge(classes, on="skill_slug")

How it was built

Each skill's SKILL.md is read, the fenced shell blocks are pulled out, and each block is classified by a deterministic resolver into exactly one of 33 consequence classes. A class carries a severity from 0 to 100. Classes at or above 75 can never run unattended; the other 20 can, once enough clean, human-approved runs have accumulated.

The resolver reads the command string and nothing else — no model, no network, no lookup. The same command always produces the same class, so any row here can be reproduced exactly.

Reproduce it with:

python research/build_dataset.py

from pheo-ai/open-agent-trust-system.

Limits, stated plainly

These counts are a floor. Only fenced shell content is read. Prose is ignored — "this skill can delete your notes" is a sentence, not an action. A block is skipped unless its first command is a recognised one. The real number for any skill is what is recorded here or higher, never lower.

Skill granularity, not command granularity. The published corpus has newlines collapsed inside code blocks, so individual commands inside one block cannot be separated reliably. A row says this skill instructs at least one action of class X, not how many times.

Unresolved blocks are reported, not hidden. A block that failed to classify is counted in unresolved_blocks. It is not folded in with the clean ones, because a failure to answer and an answer of "harmless" are not the same thing.

No claim about intent. Nothing here says a skill is malicious, vulnerable, or badly made. It says what class of action the skill instructs. Those are different questions with different answers.

Licence and citation

MIT, matching the source corpus. Only the derived column is published here; no content from the source corpus is redistributed.

@misc{oats2026clawhub,
  title  = {Scan the Skill, Govern the Action},
  author = {Pheo},
  year   = {2026},
  note   = {https://github.com/pheo-ai/open-agent-trust-system}
}