Agent skill

Self Improving Intent Security Agent

by LeoYeAI in LeoYeAI/openclaw-master-skills

Documentation-first skill and workflow toolkit for intent-based security.

MITAuto-check passedDevOps & Cloud

Install Self Improving Intent Security Agent

skills CLI
$ npx skills add LeoYeAI/openclaw-master-skills --skill self-improving-intent-security-agent -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install LeoYeAI/openclaw-master-skills self-improving-intent-security-agent --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/self-improving-intent-security-agent .claude/skills/self-improving-intent-security-agent && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
self-improving-intent-security-agent
GitHub stars
2.2k
Token cost
~4.8k tokens
SKILL.md length
1,222 words
Files
40 (incl. scripts, references, assets)
Skills in repo
972
Repo updated
First seen
Licence
MIT

At a glance

Documentation-first skill and workflow toolkit for intent-based security.

  • Works in 9 steps: Capture the user request in… → Translate it into a structured intent in… → Record allowed and blocked actions in… → …
  • Prototyping intent validation workflows
  • SKILL.md covers Install, Scope Clarification, Quick Reference and Setup, plus 10 more sections
  • Calls npx

What it does

Self Improving Intent Security Agent is an agent skill from LeoYeAI/openclaw-master-skills. Documentation-first skill and workflow toolkit for intent-based security. Provides templates, examples, and local helper scripts for capturing intent, reviewing actions, documenting rollbacks, and recording learnings. Use when: (1) designing or prototyping intent validation workflows, (2) documenting high-risk operations, (3) creating audit trails and rollback records, (4) building your own runtime enforcement layer.

Its SKILL.md is about 4.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 43 other files, including scripts, reference files and assets (for example `CLAUDE.md`, `DEVELOPMENT_CONTEXT.md` and `PUBLISHING.md`).

It sits in DevOps & Cloud, covering Prototyping. The repository describes itself as: 🧠 Curated collection of 1209+ best OpenClaw skills — weekly updated by MyClaw.ai. The licence is MIT.

When your agent uses it

  • Prototyping intent validation workflows
  • Documenting high-risk operations
  • Creating audit trails and rollback records
  • Building your own runtime enforcement layer

Example prompts

  • “/self-improving-intent-security-agent”

Requirements

  • Node.js

Workflow steps

9 steps, taken from the first numbered list in SKILL.md.

  1. Capture the user request in conversation.md
  2. Translate it into a structured intent in .agent/intents/
  3. Record allowed and blocked actions in .agent/audit/
  4. Log suspicious behavior in .agent/violations/ANOMALIES.md
  5. Log hard validation failures in .agent/violations/
  6. Record recovery steps in .agent/audit/ROLLBACKS.md
  7. Extract reusable learnings in .agent/learnings/
  8. Promote stable improvements into .agent/learnings/STRATEGIES.md
  9. Summarize the run in report.md

What it can do on your machine

Read from SKILL.md and the folder at commit e5199b5. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/, which the agent can run.

    Shell commands in SKILL.md call:

    • npx

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use npx, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Self Improving Intent Security Agent loads about 4.8k tokens when it runs, and up to ~22k if it reads all its reference files. Until then it costs about 114 tokens; SKILL.md has 1,222 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~114
When it runs · the whole SKILL.md, loaded when a task matches
~4.8k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~22k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from LeoYeAI/openclaw-master-skills at commit e5199b5, republished under its MIT licence (© LeoYeAI). 1,222 words, ~4,752 tokens.

Download SKILL.mdSave it as .claude/skills/self-improving-intent-security-agent/SKILL.md (or your agent's skills folder). This skill also uses 39 other files; get the full folder from GitHub.
name
self-improving-intent-security-agent
description
Documentation-first skill and workflow toolkit for intent-based security. Provides templates, examples, and local helper scripts for capturing intent, reviewing actions, documenting rollbacks, and recording learnings. Use when: (1) designing or prototyping intent validation workflows, (2) documenting high-risk operations, (3) creating audit trails and rollback records, (4) building your own runtime enforcement layer.

Self-Improving Intent Security Agent

Install

bash
npx skills add nishantapatil3/self-improving-intent-security-agent

Use this skill to structure and document intent validation workflows. It does not ship a production runtime engine that automatically intercepts agent actions; instead, it provides templates, examples, and local scripts that help you build, simulate, or document that workflow.

Scope Clarification

  • This package includes markdown templates, examples, and helper shell scripts
  • The helper shell scripts operate on local files only
  • Automatic enforcement, anomaly detection, rollback execution, and learning application must be implemented by the host agent or surrounding system

Quick Reference

SituationAction
Starting autonomous taskCapture intent specification (goal, constraints, expected behavior)
Before each actionValidate against intent, check authorization
Action violates intentDocument the violation and follow the rollback workflow
Unusual behavior detectedLog an anomaly, assess severity, and decide whether to halt or roll back
Task completesAnalyze outcome, extract patterns, update strategies
High-risk operationRequire human approval before execution
Need transparencyReview audit log with full action history
Strategy improvesA/B test new approach, adopt if better
Recurring violationPromote to permanent constraint in CLAUDE.md

Setup

Create .agent/ directory in project root:

bash
mkdir -p .agent/{intents,violations,learnings,audit}

Copy templates from assets/ or create files with headers. Review the included shell scripts before running them if you want to understand exactly what they do.

For a complete conversation-driven working folder, scaffold a run pack:

bash
./scripts/scaffold-run.sh examples/my-demo customer_feedback medium

This creates:

  • conversation.md for the user/agent transcript
  • report.md for the final summary
  • a local .agent/ tree with intent, audit, violation, rollback, learning, and strategy files

Intent Specification Format

Before executing autonomous tasks, capture structured intent:

markdown
## [INT-YYYYMMDD-XXX] task_name

**Created**: ISO-8601 timestamp
**Risk Level**: low | medium | high
**Status**: active | completed | violated

### Goal
What you want to achieve (single clear objective)

### Constraints
- Boundary 1 (e.g., "Only modify files in ./src")
- Boundary 2 (e.g., "Do not make network calls")
- Boundary 3 (e.g., "Preserve existing test coverage")

### Expected Behavior
- Pattern 1 (e.g., "Read files before modifying")
- Pattern 2 (e.g., "Run tests after changes")
- Pattern 3 (e.g., "Create backups of modified files")

### Context
- Relevant files: path/to/file.ext
- Environment: development | staging | production
- Previous attempts: INT-20250115-001 (if retry)

---

Save to .agent/intents/INT-YYYYMMDD-XXX.md.

Validation Workflow

Conversation-Driven Workflow

Use this when you want the skill to document not just the intent, but the full user and agent interaction over time.

  1. Capture the user request in conversation.md
  2. Translate it into a structured intent in .agent/intents/
  3. Record allowed and blocked actions in .agent/audit/
  4. Log suspicious behavior in .agent/violations/ANOMALIES.md
  5. Log hard validation failures in .agent/violations/
  6. Record recovery steps in .agent/audit/ROLLBACKS.md
  7. Extract reusable learnings in .agent/learnings/
  8. Promote stable improvements into .agent/learnings/STRATEGIES.md
  9. Summarize the run in report.md
Good Fit
  • High-risk or privacy-sensitive tasks
  • Tasks where you need a human-readable transcript
  • Demos and evaluations
  • Incident reviews and postmortems
Example

See examples/customer-feedback-demo/ for a full run showing:

  • intent capture
  • per-action validation
  • anomaly detection
  • blocked violation
  • rollback
  • learning promotion
Pre-Execution Validation

Before each action, validate:

  1. Goal Alignment: Does this action serve the stated goal?
  2. Constraint Check: Does it respect all boundaries?
  3. Behavior Match: Does it fit expected patterns?
  4. Authorization: Do we have permission for this?

If ANY check fails → block action, log violation.

Example Validation
yaml
Intent: "Process customer feedback files"
Constraints: ["Only read ./feedback", "No file modifications"]

Action: "delete ./feedback/temp.txt"
Validation:
  - Goal Alignment: ❌ Deleting isn't "processing"
  - Constraint Check: ❌ Violates "no modifications"
  - Behavior Match: ❌ Not expected for this task
  - Authorization: ✓ (but blocked by other checks)

Result: BLOCKED → Log violation → Consider rollback

Logging Violations

When validation fails, log to .agent/violations/:

markdown
## [VIO-YYYYMMDD-XXX] violation_type

**Logged**: ISO-8601 timestamp
**Severity**: low | medium | high | critical
**Intent**: INT-20250115-001
**Status**: pending_review

### What Happened
Action that was attempted

### Validation Failures
- Goal Alignment: [reason]
- Constraint Check: [which constraint violated]
- Behavior Match: [how it deviated]

### Action Taken
- [ ] Action blocked
- [ ] Checkpoint rollback
- [ ] Alert sent
- [ ] Execution halted

### Root Cause
Why the agent attempted this (if analyzable)

### Prevention
How to prevent this in the future

### Metadata
- Related Intent: INT-20250115-001
- Action Type: file_delete | api_call | command_execution
- Risk Level: high
- See Also: VIO-20250110-002 (if recurring)

---

Anomaly Detection

Monitor execution for behavioral anomalies:

Anomaly Types
TypeDescriptionResponse
Goal DriftActions diverging from stated goalHalt, request clarification
Capability MisuseUsing tools inappropriatelyRollback to checkpoint
Side EffectsUnexpected consequences detectedLog warning, continue with monitoring
Resource ExceededCPU/memory/time limits breachedThrottle or halt
Pattern DeviationBehavior differs from expectedLog for analysis
Anomaly Logging

Log to .agent/violations/ANOMALIES.md:

markdown
## [ANO-YYYYMMDD-XXX] anomaly_type

**Detected**: ISO-8601 timestamp
**Severity**: low | medium | high
**Intent**: INT-20250115-001

### Anomaly Details
What unusual behavior was detected

### Evidence
- Metric that triggered alert
- Baseline vs. actual values
- Timeline of deviation

### Assessment
Why this is anomalous

### Response Taken
- [ ] Continued with monitoring
- [ ] Applied constraints
- [ ] Rolled back
- [ ] Halted execution

---

Learning Workflow

After task completion, log learnings to .agent/learnings/:

markdown
## [LRN-YYYYMMDD-XXX] category

**Logged**: ISO-8601 timestamp
**Intent**: INT-20250115-001
**Outcome**: success | failure | partial

### What Was Learned
Pattern or insight discovered

### Evidence
- Success rate: 95%
- Execution time: 2.3s
- Actions taken: 15
- Checkpoints: 3

### Strategy Impact
How this affects future executions

### Application Scope
- Tasks: file_processing, data_transformation
- Risk Levels: low, medium
- Conditions: when X and Y are true

### Safety Check
- Complexity: low | medium | high
- Performance: baseline_comparison
- Risk: assessment

### Metadata
- Category: pattern | optimization | error_handling | security
- Confidence: low | medium | high
- Sample Size: N tasks observed
- Pattern-Key: file.batch_processing (if recurring)

---

Rollback Operations

Creating Checkpoints

Before risky operations:

typescript
const checkpoint = await agent.checkpoint.create({
  intent: currentIntent,
  reason: "Before bulk file operations"
});
Rollback on Violation

Automatic rollback when intent violated:

typescript
// Happens automatically, but can also trigger manually:
await agent.rollback.restore(checkpointId, {
  reason: "Detected constraint violation",
  notify: true
});
Rollback Log

Track in .agent/audit/ROLLBACKS.md:

markdown
## [RBK-YYYYMMDD-XXX] checkpoint_id

**Executed**: ISO-8601 timestamp
**Intent**: INT-20250115-001
**Trigger**: automatic | manual

### Reason
Why rollback was necessary

### Actions Reversed
- Action 1 (reversed successfully)
- Action 2 (reversed successfully)
- Action 3 (reversal failed - manual intervention needed)

### Checkpoint Restored
- Checkpoint: CHK-20250115-001
- Created: 2025-01-15T10:00:00Z
- Actions since checkpoint: 15

### Status
- [ ] Fully restored
- [ ] Partially restored (see notes)
- [ ] Manual intervention required

---

Strategy Evolution

When agent learns better approaches:

A/B Testing
  1. Baseline: Current strategy (90% of tasks)
  2. Candidate: New strategy (10% of tasks)
  3. Measure: Compare success rate, time, resource usage
  4. Validate: Safety checks pass
  5. Adopt: Roll out if candidate is 10%+ better
  6. Rollback: Revert if candidate degrades performance
Strategy Log

Track in .agent/learnings/STRATEGIES.md:

markdown
## [STR-YYYYMMDD-XXX] strategy_name

**Created**: ISO-8601 timestamp
**Domain**: file_processing | api_interaction | error_handling
**Status**: testing | adopted | rejected | superseded

### Approach
What this strategy does differently

### Performance
- Baseline: 85% success, 3.2s avg
- Candidate: 92% success, 2.1s avg
- Improvement: +7% success, -34% time

### A/B Test Results
- Test Tasks: 50
- Candidate Used: 5 tasks
- Wins: 4, Losses: 1, Ties: 0

### Safety Validation
- Complexity: within limits (complexity: 45/100)
- Permissions: no expansion
- Risk: acceptable (no high-risk changes)

### Adoption Decision
- [ ] Adopt (outperforms baseline)
- [ ] Reject (underperforms baseline)
- [ ] Extend testing (inconclusive)

---

Promoting to Permanent Memory

When learnings are broadly applicable, promote to project files:

Promotion Targets
TargetWhat Belongs There
CLAUDE.mdIntent patterns, common constraints for this project
AGENTS.mdAgent-specific workflows, validation rules
.github/copilot-instructions.mdSecurity guidelines, constraint templates
SECURITY.mdSecurity-critical constraints and validation rules
When to Promote

Promote when:

  • Violation occurs 3+ times (recurring constraint)
  • Learning applies across multiple task types
  • Strategy is adopted and proven (success rate 90%+)
  • Security pattern prevents entire class of violations
Promotion Examples

Violation (recurring):

VIO-20250115-001: Attempted to modify files outside ./src VIO-20250118-002: Attempted to modify files outside ./src VIO-20250120-003: Attempted to modify files outside ./src

Promote to CLAUDE.md:

markdown
## File Modification Constraints
- Only modify files within `./src` directory
- Other directories are read-only unless explicitly authorized

Learning (proven strategy):

LRN-20250115-005: Batch processing with checkpoints every 10 files Results: 95% success, 40% faster, easy rollback on failures

Promote to AGENTS.md:

markdown
## File Processing Strategy
- Use batch processing (10 files per batch)
- Create checkpoint before each batch
- Enables fast rollback on errors

Configuration

Show full SKILL.md (505 more words)Show less
Environment Variables

Important: All environment variables are optional. The skill works with sensible defaults without any configuration.

Security Note: This skill does NOT require any credentials or secrets. All data stays local in the .agent/ directory. No data is transmitted externally.

bash
# Paths (optional - defaults shown)
export AGENT_INTENT_PATH=".agent/intents"       # Default: .agent/intents
export AGENT_AUDIT_PATH=".agent/audit"          # Default: .agent/audit

# Security Settings (optional tuning)
export AGENT_RISK_THRESHOLD="medium"            # low | medium | high
export AGENT_AUTO_ROLLBACK="true"               # true | false
export AGENT_ANOMALY_THRESHOLD="0.8"            # 0.0 - 1.0

# Learning Settings (optional tuning)
export AGENT_LEARNING_ENABLED="true"            # true | false
export AGENT_MIN_SAMPLE_SIZE="10"               # Min observations before adopting
export AGENT_AB_TEST_RATIO="0.1"                # 10% of tasks for A/B testing

# Monitoring (optional tuning)
export AGENT_METRICS_INTERVAL="1000"            # Metrics collection (ms)
export AGENT_AUDIT_LEVEL="detailed"             # minimal | standard | detailed
Configuration File

Create .agent/config.json:

json
{
  "security": {
    "requireApproval": ["file_delete", "api_write", "command_execution"],
    "autoRollback": true,
    "anomalyThreshold": 0.8,
    "maxPermissionScope": "read-write"
  },
  "learning": {
    "enabled": true,
    "minSampleSize": 10,
    "abTestRatio": 0.1,
    "maxStrategyComplexity": 100
  },
  "monitoring": {
    "metricsInterval": 1000,
    "auditLevel": "detailed",
    "retentionDays": 90
  }
}

ID Generation

Format: TYPE-YYYYMMDD-XXX

  • INT: Intent specification
  • VIO: Violation (failed validation)
  • ANO: Anomaly (behavioral deviation)
  • LRN: Learning (insight from execution)
  • STR: Strategy (new approach)
  • RBK: Rollback operation
  • CHK: Checkpoint

Examples: INT-20250115-001, VIO-20250115-A3F, LRN-20250115-002

Priority Guidelines

Priority/SeverityWhen to Use
criticalImmediate security risk, data loss, system compromise
highIntent violation, unauthorized action, goal drift
mediumAnomaly detected, suboptimal strategy, warning condition
lowMinor deviation, optimization opportunity, observation

Best Practices

Intent Specification
  1. Be specific - Vague goals lead to validation failures
  2. List all constraints - Implicit boundaries often get violated
  3. Define expected behavior - Helps catch deviations early
  4. Set correct risk level - Triggers appropriate approval gates
Validation
  1. Validate early - Before execution, not after
  2. Fail safe - Block on doubt, don't assume permission
  3. Log all violations - Even if they seem minor
  4. Review regularly - Patterns emerge over time
Learning
  1. Let it learn - Requires sample size to be effective
  2. Monitor A/B tests - Don't adopt blindly
  3. Safety first - Reject strategies that reduce safety
  4. Promote proven patterns - Turn learnings into permanent rules
Audit
  1. Keep detailed logs - Debugging requires context
  2. Archive old logs - Retention policies prevent bloat
  3. Review anomalies - Often reveal edge cases
  4. Share learnings - Team benefits from documented patterns

Detection Triggers

Automatically apply intent security when:

High-Risk Operations:

  • File deletion or bulk modifications
  • API calls with write permissions
  • Command execution with elevated privileges
  • Database modifications
  • Deployment operations

Autonomous Workflows:

  • Multi-step task sequences
  • Background job execution
  • Scheduled automation
  • Agent-initiated operations

Learning Opportunities:

  • Task completes successfully
  • Failure with identifiable cause
  • User provides correction
  • Better approach discovered

Hook Integration (Optional)

Enable automatic intent validation through agent hooks.

Setup (Claude Code / Codex)

Create .claude/settings.json:

json
{
  "hooks": {
    "UserPromptSubmit": [{
      "matcher": "",
      "hooks": [{
        "type": "command",
        "command": "./skills/self-improving-intent-security-agent/scripts/intent-capture.sh"
      }]
    }],
    "PostToolUse": [{
      "matcher": "Bash|Edit|Write",
      "hooks": [{
        "type": "command",
        "command": "./skills/self-improving-intent-security-agent/scripts/action-validator.sh"
      }]
    }]
  }
}
Available Hook Scripts
ScriptHook TypePurpose
scripts/intent-capture.shUserPromptSubmitPrompts for intent specification
scripts/action-validator.shPostToolUseValidates actions against intent
scripts/learning-capture.shTaskCompleteCaptures learnings after tasks

See references/hooks-setup.md for detailed configuration.

Quick Commands

bash
# Initialize agent structure
mkdir -p .agent/{intents,violations,learnings,audit}

# Count active intents
grep -h "Status**: active" .agent/intents/*.md | wc -l

# List high-severity violations
grep -B5 "Severity**: high" .agent/violations/*.md | grep "^## \["

# Find learnings for file processing
grep -l "Domain**: file_processing" .agent/learnings/*.md

# Review recent rollbacks
ls -lt .agent/audit/ROLLBACKS.md | head -5

# Check strategy adoption rate
grep "Status**: adopted" .agent/learnings/STRATEGIES.md | wc -l

Examples

See examples/README.md for detailed usage examples:

  • Basic intent specification and validation
  • Handling violations and rollbacks
  • Learning from task outcomes
  • Strategy evolution through A/B testing
  • Security monitoring and anomaly detection

References

Multi-Agent Support

Works with Claude Code, Codex CLI, GitHub Copilot, and OpenClaw. See references/multi-agent.md for agent-specific configurations.

Safety Guarantees

✓ Intent Alignment - Every action validated against goal ✓ Permission Boundaries - Cannot exceed authorized scope ✓ Reversibility - Checkpoint-based rollback ✓ Auditability - Complete action history ✓ Bounded Learning - Safety-constrained improvements ✓ Human Oversight - Approval gates for high-risk operations

License

MIT


Note: This skill provides strong safety mechanisms but requires proper configuration and usage. Always:

  • Define clear, specific intents
  • Review violation logs regularly
  • Monitor learning effectiveness
  • Keep approval gates enabled for high-risk operations
  • Test in non-production environments first

Intent-based security is a powerful approach, but human judgment remains essential.

© LeoYeAI, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 39 other files (scripts, references, assets) in skills/self-improving-intent-security-agent of LeoYeAI/openclaw-master-skills.

  • SKILL.md
  • CLAUDE.md
  • DEVELOPMENT_CONTEXT.md
  • PUBLISHING.md
  • README.md
  • _meta.json
  • assets/ANOMALIES.md
  • assets/CONVERSATION-TEMPLATE.md
  • assets/INTENT-TEMPLATE.md
  • assets/LEARNINGS.md
  • assets/ROLLBACKS.md
  • assets/STRATEGIES.md
  • assets/VIOLATIONS.md
  • docs/_config.yml
  • docs/demo/index.md
  • docs/demo/walkthrough.md
  • docs/guide/index.md
  • … and 23 more

Open the folder on GitHubat commit e5199b5

Compare with similar skills

Self Improving Intent Security Agent next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Self Improving Intent Security Agent compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Self Improving Intent Security Agent this skillLeoYeAI/openclaw-master-skills2.2k—~4.8kAutomated safety check: PassMIT
Monitor CInrwl/nx29k6 repos~4.7kAutomated safety check: PassMIT
Terraform and OpenTofu Guideagentscope-ai/QwenPaw35k6 repos~4.2kAutomated safety check: PassApache-2.0
Vercel Optimize Auditvercel-labs/agent-skills32k9 repos~4.3kAutomated safety check: PassNone
Openclaw Live Updateropenclaw/openclaw392k—~3.7kAutomated safety check: PassMIT
Analyze GitHub Action Logswithastro/astro63k1 repos~1.3kAutomated safety check: PassCustom licence

Similar skills

  • Monitor CI

    nrwl/nx

    Monitor Nx Cloud CI pipeline and handle self-healing fixes. An agent skill from nrwl/nx.

    29k GitHub starsUsed in 6 repos~4.7k tokens
    DevOps & CloudAuto-check passed
  • Terraform and OpenTofu Guide

    agentscope-ai/QwenPaw

    Guidance for writing and testing Terraform and OpenTofu code: module structure, naming, test approaches, CI/CD workflows, state handling and security scanning.

    35k GitHub starsUsed in 6 repos~4.2k tokens
    DevOps & CloudAuto-check passed
  • Vercel Optimize Audit

    vercel-labs/agent-skills

    Official

    Runs a metrics-first audit of a deployed Vercel project, gating investigations on real signals to produce ranked, citation-backed cost and performance recommendations.

    32k GitHub starsUsed in 9 repos~4.3k tokens
    DevOps & CloudAuto-check passed
  • Openclaw Live Updater

    openclaw/openclaw

    Maintain the canonical live OpenClaw main checkout, macOS LaunchAgent-managed Gateway, local macOS app, exact-head main CI, and recurring full release validation.

    392k GitHub stars~3.7k tokensUpdated today
    DevOps & CloudAuto-check passed
  • Official

    Analyze recent GitHub Actions workflow runs to identify patterns, mistakes, and improvements.

    63k GitHub starsUsed in 1 repo~1.3k tokens
    DevOps & CloudAuto-check passed
  • Builds single-file interactive HTML prototypes rendered with the real LobeHub UI components and written as production-style React, so they can later be split into files.

    83k GitHub stars~1.6k tokensUpdated today
    Frontend & DesignAuto-check passed

More from LeoYeAI/openclaw-master-skills

All 972 skills in this repo
  • DevOps Pipeline Management

    LeoYeAI/openclaw-master-skills

    Manages pipelines on a DevOps quality and efficiency platform through its OpenAPI: list workspaces and templates, create, update, run and cancel pipelines, and read run records.

    2.2k GitHub stars~4.2k tokensUpdated 2 mo ago
    Auto-check: notes
  • Feishu Document Collaboration

    LeoYeAI/openclaw-master-skills

    Patches OpenClaw's Feishu extension so an edited document triggers an isolated agent session that reads the doc and replies inline, turning it into a live chat space.

    2.2k GitHub stars~2k tokensUpdated 2 mo ago
    Auto-check passed
  • Files Memory System

    LeoYeAI/openclaw-master-skills

    Multi-context memory management system for OpenClaw agents with group-isolated storage, global shared memory, workspace organization, and group-specific skills isolation.

    2.2k GitHub stars~3.8k tokensUpdated 2 mo ago
    Auto-check passed
  • GEO-Claw AI Visibility Agent

    LeoYeAI/openclaw-master-skills

    Runs a brand's AI-search visibility work end to end: diagnosing how AI platforms represent it, repositioning it, producing AI-optimized content and monitoring ongoing mentions.

    2.2k GitHub stars~4.7k tokensUpdated 2 mo ago
    Auto-check passed
  • Google Workspace CLI

    LeoYeAI/openclaw-master-skills

    Installs and authenticates the gws CLI, then automates Gmail, Drive, Sheets, Calendar, Docs, Chat and Tasks with ready-made recipes, persona bundles and security audits.

    2.2k GitHub stars~2.6k tokensUpdated 2 mo ago
    Auto-check: notes
  • HealthFit Health Advisors

    LeoYeAI/openclaw-master-skills

    Runs four advisor roles, a fitness coach, nutritionist, data analyst and TCM practitioner, to build a health profile and track workouts, diet and wellness over time.

    2.2k GitHub stars~4.4k tokensUpdated 2 mo ago
    Auto-check passed

Categories

Questions about Self Improving Intent Security Agent

What does Self Improving Intent Security Agent do?

Documentation-first skill and workflow toolkit for intent-based security. Self Improving Intent Security Agent is an agent skill from LeoYeAI/openclaw-master-skills. Documentation-first skill and workflow toolkit for intent-based security.

When should I use Self Improving Intent Security Agent?

Self Improving Intent Security Agent fits situations like: prototyping intent validation workflows; documenting high-risk operations; creating audit trails and rollback records; building your own runtime enforcement layer.

How do I install Self Improving Intent Security Agent in Claude Code?

Run `npx skills add LeoYeAI/openclaw-master-skills --skill self-improving-intent-security-agent -a claude-code`. Or copy the skill folder (skills/self-improving-intent-security-agent in LeoYeAI/openclaw-master-skills) into .claude/skills/self-improving-intent-security-agent in your project. Claude Code loads it when a task matches its description.

How do I install Self Improving Intent Security Agent in Codex?

Run `npx skills add LeoYeAI/openclaw-master-skills --skill self-improving-intent-security-agent -a codex`. Or copy the skill folder (skills/self-improving-intent-security-agent in LeoYeAI/openclaw-master-skills) into .agents/skills/self-improving-intent-security-agent in your project. Codex loads it when a task matches its description.

Can I use Self Improving Intent Security Agent in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add LeoYeAI/openclaw-master-skills --skill self-improving-intent-security-agent -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/self-improving-intent-security-agent, .gemini/skills/self-improving-intent-security-agent, .github/skills/self-improving-intent-security-agent and .opencode/skills/self-improving-intent-security-agent in your project.

What does Self Improving Intent Security Agent need to run?

Going by SKILL.md and its folder, Self Improving Intent Security Agent needs the command-line tools its instructions call (npx). Our summary lists: Node.js.

Does Self Improving Intent Security Agent access the network?

SKILL.md contains no URLs. Its commands use npx, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Self Improving Intent Security Agent safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Self Improving Intent Security Agent use?

Self Improving Intent Security Agent is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Self Improving Intent Security Agent use?

About 4.8k tokens (SKILL.md is roughly 19k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 17k tokens, read only when the agent opens those files.

What are the alternatives to Self Improving Intent Security Agent?

Skills that share tags, products or a category with Self Improving Intent Security Agent: Monitor CI (nrwl/nx, 29k stars), Terraform and OpenTofu Guide (agentscope-ai/QwenPaw, 35k stars), Vercel Optimize Audit (vercel-labs/agent-skills, 32k stars) and Openclaw Live Updater (openclaw/openclaw, 392k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Self Improving Intent Security Agent?

LeoYeAI (a GitHub user) maintains it in LeoYeAI/openclaw-master-skills, which has 2,159 GitHub stars. The repository holds 972 skills in this directory. The repository was last updated on July 20, 2026.

Source: LeoYeAI/openclaw-master-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.