GitHub - ArchieIndian/openclaw-superpowers: 44 plug-and-play skills for OpenClaw — self-modifying AI agent with cron scheduling, security guardrails, persistent memory, knowledge graphs, and MCP health monitoring. Your agent teaches itself new behaviors during conversation.

56 ready-to-use skills that make your AI agent autonomous, self-healing, and self-improving.

A plug-and-play skill library for OpenClaw — the open-source AI agent runtime. Gives your agent structured thinking, security guardrails, persistent memory, cron scheduling, self-recovery, and the ability to write its own new skills during conversation.

Built for developers who want their AI agent to run autonomously 24/7, not just respond to prompts in a chat window.

Inspired by obra/superpowers. Extended for agents that never sleep.

Why this exists

Most AI agent frameworks give you a chatbot that forgets everything between sessions. OpenClaw is different — it runs persistently, handles multi-hour tasks, and has native cron scheduling. But out of the box, it doesn't know how to use those capabilities well.

openclaw-superpowers bridges that gap. Install 56 skills in one command, and your agent immediately knows how to:

• Think before it acts — brainstorming, planning, and systematic debugging skills prevent the "dive in and break things" failure mode
• Protect itself — 6 security skills detect prompt injection, block dangerous actions, audit installed code, and scan for leaked credentials
• Run unattended — 12 cron-scheduled skills handle memory cleanup, health checks, budget tracking, and community monitoring while you sleep
• Recover from failures — self-recovery, loop-breaking, and task handoff skills keep long-running work alive across crashes and restarts
• Never forget — DAG-based memory compaction, integrity checking, context scoring, and SQLite session persistence ensure the agent preserves critical information even in month-long conversations
• Improve itself — the agent can write new skills during normal conversation using create-skill, encoding your preferences as permanent behaviors

The self-modifying agent

This is what makes openclaw-superpowers different from every other plugin library:

"Every time I do a code review, check for security issues first."

Your agent invokes create-skill, writes a new SKILL.md, and that behavior is live — immediately, permanently, no restart needed. The agent encodes your preferences as durable skills. You describe what you want. It teaches itself.

The community-skill-radar skill takes this further: it scans Reddit every 3 days for pain points and feature requests from the OpenClaw community, scores them by signal strength, and writes a prioritized PROPOSALS.md — so the agent (or you) always knows what to build next.

Quickstart

git clone https://github.com/ArchieIndian/openclaw-superpowers ~/.openclaw/extensions/superpowers
cd ~/.openclaw/extensions/superpowers && ./install.sh
openclaw gateway restart

install.sh symlinks all 56 skills, creates state directories for stateful skills, and registers cron jobs — everything in one step. That's it. Your agent now has superpowers.

Important: install does not force behavior

Installing these skills does not guarantee that OpenClaw will follow using-superpowers or any other skill on every turn.

Why:

• SOUL.md and AGENTS.md are prompt inputs, not hard enforcement.
• Skills are exposed as available capabilities, and the model decides whether to read and apply them.
• Changes to installed skills are safest to validate in a fresh OpenClaw session.

For best results:

1. Start a new OpenClaw session after installation.

2. Verify the skill is eligible:

   openclaw skills list --eligible
   openclaw skills info using-superpowers

3. Put mandatory operating rules in AGENTS.md, not only SOUL.md.

4. Keep AGENTS.md and SOUL.md concise so they are less likely to be truncated.

If you need deterministic behavior:

• Move critical workflow rules into AGENTS.md.
• Use OpenClaw hooks or plugins to enforce behavior at runtime.
• Do not rely on SOUL.md alone to force deterministic skill execution.

Skills included

Core (17 skills)

Methodology skills that work in any AI agent runtime. Adapted from obra/superpowers plus new additions for skill quality assurance.

OpenClaw-Native (38 skills)

Skills that require OpenClaw's persistent runtime — cron scheduling, session state, or long-running execution. These are the skills that make a 24/7 autonomous agent actually work reliably.

Community (1 skill)

Skills written by agents and contributors. Any agent can add a community skill via create-skill.

Security & guardrails

Six skills form a defense-in-depth security layer for autonomous agents:

How it compares

Architecture

~/.openclaw/extensions/superpowers/
├── skills/
│   ├── core/                    # 17 methodology skills (any runtime)
│   │   ├── brainstorming/
│   │   │   └── SKILL.md
│   │   ├── create-skill/
│   │   │   ├── SKILL.md
│   │   │   └── TEMPLATE.md
│   │   └── ...
│   ├── openclaw-native/         # 38 persistent-runtime skills
│   │   ├── memory-graph-builder/
│   │   │   ├── SKILL.md             # Skill definition + YAML frontmatter
│   │   │   ├── STATE_SCHEMA.yaml    # State shape (committed, versioned)
│   │   │   ├── graph.py             # Companion script
│   │   │   └── example-state.yaml   # Annotated example
│   │   └── ...
│   └── community/               # Agent-written and contributed skills
├── scripts/
│   └── validate-skills.sh       # CI validation
├── tests/
│   └── test-runner.sh
└── install.sh                   # One-command setup

State model: Each stateful skill commits a STATE_SCHEMA.yaml defining the shape of its runtime data. At install time, install.sh creates ~/.openclaw/skill-state/<skill-name>/state.yaml on your machine. The schema is portable and versioned; the runtime state is local-only and never committed.

Companion scripts

Skills marked with a script ship a small executable alongside their SKILL.md:

• 25 Python scripts (run.py, audit.py, check.py, guard.py, bridge.py, onboard.py, sync.py, doctor.py, loadout.py, governor.py, detect.py, test.py, radar.py, graph.py, optimize.py, compact.py, intercept.py, score.py, integrity.py, persist.py, recall.py, advise.py, gate.py) — run directly to manipulate state, generate reports, or trigger actions. No extra dependencies; pyyaml is optional but recommended.
• vet.sh — Pure bash scanner; runs on any system with grep.
• Every script supports --help and --format json. Dry-run mode available on scripts that make changes.
• See the example-state.yaml in each skill directory for sample state and a commented walkthrough of cron behaviour.

Use cases

Solo developer with a persistent AI agent

Install superpowers, and your agent handles memory cleanup, security audits, and daily briefings on autopilot. You focus on building; the agent maintains itself.

Team running multiple OpenClaw agents

Use multi-agent-coordinator for fleet health checks, skill-loadout-manager to keep system prompts lean per agent role, and heartbeat-governor to prevent runaway cron costs.

Open-source maintainer

community-skill-radar scans Reddit for pain points automatically. skill-vetting catches malicious community contributions before they're installed. installed-skill-auditor detects post-install tampering.

Security-conscious deployment

Six defense-in-depth skills: pre-install vetting, runtime injection detection, destructive action gates, post-install drift detection, credential scanning, and silent failure diagnosis.

Contributing

1. Open a Skill Proposal issue — or just ask your agent to write one using create-skill
2. Run ./scripts/validate-skills.sh
3. Submit a PR — CI validates automatically
4. Community skills may be promoted to core over time

Credits

• openclaw/openclaw — the open-source AI agent runtime
• obra/superpowers — Jesse Vincent's skills framework; core skills adapted under MIT license
• OpenLobster — inspiration for memory graph, config encryption auditing, tool-description scoring, and MCP health monitoring
• lossless-claw — inspiration for DAG-based memory compaction, session persistence, sub-agent recall, and delegation grants