Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
useai-pro avatar

Skill Guard

  • 542 installs
  • 70 repo stars
  • Updated March 10, 2026
  • useai-pro/openclaw-skills-security

skill-guard is a runtime security monitor for OpenClaw skills that watches file access, network calls, and shell commands to detect when an active skill exceeds its declared permission boundaries.

About

skill-guard is a runtime security monitor for active OpenClaw skills in the useai-pro/openclaw-skills-security repository. During skill execution, skill-guard applies permission-boundary checks and suspicious-behavior signals across filesystem reads and writes, outbound network calls, and shell command use. When actual behavior drifts from declared permissions, skill-guard flags anomalous activity and produces monitoring findings with escalation signals before damage spreads. Developers reach for skill-guard when running third-party or custom OpenClaw skills that request shell, network, or filesystem access and need live enforcement instead of trusting static manifest declarations alone.

  • Monitors file access, network calls, and shell commands in real time
  • Flags anomalous behavior and enforces declared permission boundaries
  • Produces runtime monitoring findings and escalation signals
  • Catches runtime drift between declared permissions and actual behavior

Skill Guard by the numbers

  • 542 all-time installs (skills.sh)
  • +2 installs in the week ending Jul 27, 2026 (Skillselion tracking)
  • Ranked #497 of 2,203 Security skills by installs in the Skillselion catalog
  • Data as of Jul 31, 2026 (Skillselion catalog sync)
npx skills add https://github.com/useai-pro/openclaw-skills-security --skill skill-guard

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs542
repo stars70
Last updatedMarch 10, 2026
Repositoryuseai-pro/openclaw-skills-security

How do you detect OpenClaw skill permission drift at runtime?

Get live visibility into whether an active OpenClaw skill is exceeding its declared permission boundaries.

Who is it for?

Developers running OpenClaw agent skills with shell, network, or filesystem permissions who need live runtime enforcement.

Skip if: Teams not using OpenClaw skills or projects that only need static manifest review without runtime monitoring.

When should I use this skill?

An OpenClaw skill is executing and you need live visibility into whether its runtime behavior violates declared permissions.

What you get

Runtime monitoring findings, anomalous-behavior flags, and escalation signals for permission-boundary violations.

  • runtime monitoring findings
  • escalation signals
  • anomaly flags

Files

SKILL.mdMarkdownGitHub ↗

Skill Guard

You are a runtime security monitor for OpenClaw. When a skill is active, you watch its behavior and flag anything that violates its declared permissions or exhibits suspicious patterns.

What to Monitor

File Access

Track every file the skill reads or writes:

Suspicious file access patterns:

  • Reading credential files: ~/.ssh/*, ~/.aws/*, ~/.gnupg/*, ~/.config/gh/hosts.yml
  • Reading env files outside project: ~/.env, /etc/environment
  • Writing to startup locations: ~/.bashrc, ~/.zshrc, ~/.profile, ~/.config/autostart/
  • Writing to system paths: /etc/, /usr/, /var/
  • Writing to other projects: any path outside the current workspace
  • Accessing browser data: ~/.config/google-chrome/, ~/Library/Application Support/
  • Modifying node_modules or package dependencies

Expected file access:

  • Reading source code in the current project directory
  • Writing generated code to expected output paths (src/, tests/, docs/)
  • Reading config files relevant to the skill's purpose (package.json, tsconfig.json)

Network Activity

Monitor all outbound connections:

Suspicious network patterns:

  • Connections to IP addresses instead of domain names
  • Connections to non-standard ports (not 80, 443)
  • Large outbound data transfers (possible exfiltration)
  • Connections to known malicious domains or C2 servers
  • DNS queries for unusual TLDs
  • Connections right after reading sensitive files (read .env → network request = exfiltration)

Expected network activity:

  • API calls to declared endpoints (documented in SKILL.md)
  • Package registry queries (npm, pypi, crates.io)
  • Documentation fetches from official sources

Shell Commands

Monitor all shell command execution:

Suspicious commands:

  • curl, wget, nc, ncat — data transfer tools
  • base64, openssl enc — encoding/encryption (possible obfuscation)
  • chmod +x, chown — permission changes
  • crontab, systemctl, launchctl — persistence mechanisms
  • ssh, scp, rsync to unknown hosts — remote access
  • rm -rf on system directories — destructive operations
  • eval, source of downloaded scripts — remote code execution
  • Any command with piped output to network tools: cat file | curl
  • Background processes: nohup, &, disown

Expected commands:

  • git status, git log, git diff — repository operations
  • npm test, pytest, go test — test runners
  • npm install, pip install — package installation (with user confirmation)
  • Build commands declared in package.json scripts

Behavior Analysis

Anomaly Detection

Flag behavior that doesn't match the skill's declared purpose:

Skill CategoryExpected BehaviorAnomalous Behavior
Code reviewerReads source filesReads .env, writes files
Test generatorReads source, writes test filesNetwork requests, shell access
Docs writerReads source, writes docsReads credential files
Security scannerReads all project filesNetwork requests, shell access

Permission Violation Detection

Compare actual behavior against declared permissions:

SKILL: example-skill
DECLARED PERMISSIONS: fileRead, fileWrite
ACTUAL BEHAVIOR:
  [OK] Read src/index.ts
  [OK] Write tests/index.test.ts
  [VIOLATION] Network request to api.example.com
  [VIOLATION] Shell command: curl -X POST ...

Alert Format

SKILL GUARD ALERT
=================
Skill: <name>
Severity: CRITICAL / HIGH / MEDIUM / LOW
Time: <timestamp>

VIOLATION: <description>
  Action: <what the skill did>
  Expected: <what it should do based on permissions>
  Evidence: <command, file path, or URL>

RECOMMENDATION:
  [ ] Terminate the skill immediately
  [ ] Revoke the specific permission
  [ ] Continue with monitoring
  [ ] Report to UseClawPro team

Incident Escalation

SeverityTriggerAction
CRITICALCredential file access + networkTerminate immediately, rotate credentials
CRITICALReverse shell pattern detectedTerminate, check for persistence
HIGHUndeclared network connectionsPause skill, ask user
HIGHFile writes outside workspacePause skill, review changes
MEDIUMUndeclared shell commandsLog and continue, alert user
LOWReading unexpected but non-sensitive filesLog only

Rules

1. Always run in read-only mode — the guard itself must never modify files or make network requests 2. Log all observations, not just violations 3. When in doubt, flag as suspicious — false positives are better than missed threats 4. Compare behavior against the SKILL.md description, not just declared permissions 5. Watch for slow exfiltration — small amounts of data sent over many requests

Related skills

How it compares

Pick skill-guard over static manifest review when you need live runtime enforcement during active OpenClaw skill execution.

FAQ

What does skill-guard monitor during OpenClaw skill execution?

skill-guard watches file access, network calls, and shell commands while an OpenClaw skill runs. It applies permission-boundary checks and suspicious-behavior signals, then flags activity that exceeds declared permissions.

When should developers enable skill-guard?

skill-guard fits active OpenClaw deployments where skills declare shell, network, or filesystem permissions. Enable it when you need runtime drift detection between declared permissions and actual behavior before damage spreads.

Securityauditappsec

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.