Runtime permissions for agent extensions

Let the skill ask.
Let runtime decide.

Agent skills and plugins can inherit the authority of the harness around them. SkopeRail is a concept for declaring a skill’s capabilities, enforcing policy at runtime, and attesting what happened—across agent harnesses.

CONCEPT PROTOTYPE · NO PRODUCTION INTEGRATIONS CLAIMED
Cross-harness by design · integration targets
Claude CodeCursorOpenClawExtensible adapters
targets, not shipped integrations
The control gap

Scanning tells you what a file looks like.
Runtime decides what it can do.

Static and behavioral scanning remain valuable. The thesis here is complementary: even when a skill is risky, mistaken, or changes after review, it should receive only the capabilities that policy grants—and every decision should leave verifiable evidence.

Before execution · inspect

Assess the artifact.

Review provenance, content, dependencies, and known indicators. A scanner verdict is one signal—not an authorization token.

At execution · constrain

Enforce the declared scope.

Translate a reviewed capability declaration into policy at the action boundary. Undeclared file, network, process, and tool access should fail closed.

Proposed system

One policy path.
Evidence at every run.

A small, portable contract between an extension and its host: say what the skill needs, mediate what it attempts, and record exactly which artifact and policy produced the decision.

01 / DECLARE

Make capability explicit.

List the resources and actions a skill needs: scoped files, destinations, processes, tools, and sensitive-data boundaries.

02 / ENFORCE

Decide at the boundary.

Evaluate each attempted action against org policy at runtime—not only when the package is uploaded or installed.

03 / ATTEST

Prove what ran.

Bind the skill digest, declared scope, harness adapter, policy version, and allow/deny outcome into a continuous audit record.

Capability contract

A skill should ship a request—not a blank check.

Manifest format is an early design question. The useful invariant is simpler: scope must be machine-readable, reviewable, tied to an immutable artifact, and enforced by the runtime that executes the action.

ILLUSTRATIVE YAML · NOT A PRODUCT SPEC
skoperail.policy.yamlEXAMPLE / DRAFT
# A human-reviewed request, not a grant by itself
skill: release-notes
artifact:
  version: 2.1.0
  digest: sha256:…
requests:
  files.read: ./changelog/**
  files.write: ./drafts/release-notes.md
  network: none
  process.spawn: none
  tools: [git.status]
decision: policy-controlled at runtime
Why now

Evidence says scanning alone is not a boundary.

The opportunity is not “replace scanners.” It is to pair review with enforceable least privilege and portable evidence—while being precise about what a prototype can and cannot prove.

1,184+

A Cloud Security Alliance research note summarizes reports of more than 1,184 malicious skills in OpenClaw’s ClawHub marketplace during 2026. This is a research-reported historical count, not a current prevalence estimate.

4 tests

Trail of Bits built four malicious skills to test scanners; its report says no single scanner caught all four, and some caught none.

Market signal

Palo Alto Networks completed its Koi acquisition on April 14, 2026, and described integrating agentic-endpoint security into its portfolio. The press release did not disclose a deal value.

People behind the project

Tibor & Radim are standing behind this project.

SkopeRail is an early-stage effort focused on runtime permissions and continuous attestation for agent skills and plugins. The product model and integrations shown here are still a concept.

Founding thesis

Move trust from the package to the permission boundary.

SkopeRail is a working name for an early product concept. The cross-harness adapters, runtime enforcement, and attestation workflow shown here are proposed—not shipped. The next step is validating the capability model with agent-runtime and security teams.

Back to the model ↑