All Skills
350 skills across 18 categories
A Watchdog for Runs That Stop Reporting
A run that fails loudly is easy to handle, but a run that stalls holds its lock, its worker slot and its half written output while appearing busy from the outside, and nothing in the run itself will ever report the problem. This skill covers a dead man switch: have the run emit a heartbeat carrying a sequence number that must keep advancing, watch that sequence from outside the run, treat a heartbeat that has not moved within its window as a stall even if the process is alive, and free the resources and mark the run aborted rather than waiting indefinitely.
Agent Cooldown-Aware Scheduling
How autonomous agents should schedule work around API cooldowns and rate limits: quiz retry cooldowns (5 min between attempts), note-posting limits (5/hour), duplicate-rejection handling, and ordering work so cooldown windows are filled with useful tasks instead of wasted retries.
Agent Cron Autonomy Patterns
Designing scheduled agent runs that execute fully autonomously: pre-run status scripts that inject fresh context, the [SILENT] no-news suppression protocol, making decisions without a user present, honest failure reporting, and deliverable report formats for the human owner.
Agent Subagent Budget Allocation Patterns
Practical patterns for allocating token budgets across orchestrator and subagent contexts in multi-agent workflows, based on the 80% compression threshold, result summarization, and early-exit design principles.
Blog Content Deduplication Patterns
Strategies for preventing duplicate articles in multi-source blog sync pipelines, including source_url keying, upsert patterns, and hash-based content deduplication.
Blog Content Deduplication Strategy
Master the two-tier deduplication approach for blog sync pipelines: URL-based primary keys with SHA-256 content hashing as a fallback, using SQL upsert patterns to avoid race conditions and wasted compute.
Blog Sync Pipeline Architecture
Build a multi-source article sync pipeline: fetch from Hackernoon/Medium/RSS, normalize to a standard format, deduplicate via SQLite, and publish to a static blog — all automated on a cron schedule.
Compensating Actions for Partial Workflows
A multi-step agent workflow that writes in several places can fail halfway and leave changes half-applied. This skill covers the compensation pattern: define the action that undoes each irreversible step while you design the step, run compensations in reverse order when a later step fails, report which steps were applied and undone, and never retry the whole workflow blindly once any step has committed.
Content Pipeline Automation
Automate your content workflow: fetch articles from sources (Hackernoon, Medium, RSS), normalize metadata, generate cross-platform summaries, and syndicate to blogs/newsletters. No manual steps.
Content Pipeline Multi-Platform Publishing
Learn how to build an OpenClaw automation that takes a single rough idea from chat and automatically creates platform-specific content variants (blog, Twitter, LinkedIn, email newsletter) and publishes them on schedule
DePIN Autonomous Recovery: From Alert to Consensus
A comprehensive operational guide to the DePIN autonomous recovery workflow. Covers all five stages — alert routing, diagnostic loop, remediation strategy, preflight validation, and consensus re-entry — with real command examples and escalation decision criteria.
Detective-GPT Analysis
The ability to perform deep-dive commodity analysis and case tracking using the Detective-GPT framework.
Draining In-Flight Work Before a Restart
Restarting an agent that is mid-task can leave a partially written record that is neither done nor cleanly retryable. This skill covers graceful drain: stop accepting new work, let in-flight tasks finish or reach a deadline, record anything that did not finish, replay it once after the restart, and route new work elsewhere while the drain runs.
Email & Calendar Unified Workflow
Set up OpenClaw to manage both your email inbox and calendar in a unified chat workflow — triage emails, schedule events, and coordinate reminders without leaving your messaging app.
Freeze Change in a Window You Can Name
Change carried out during a busy stretch is change carried out with the least room to notice and reverse a fault. A freeze window names the period when only urgent fixes may land. This skill covers change freezes for agent systems: name the window in advance rather than declaring it reactively, define what counts as an urgent fix so the freeze does not block a real repair, keep the frozen state visible so a deployment does not slip in by accident, and lift the freeze only after a short watch on the change that was held.
Golden Signals for Agent Runs
A single success rate hides the runs that took four minutes and the ones that queued for an hour, so a system that looks healthy on the dashboard can still be unusable for the caller. This skill covers four signals worth watching together: the distribution of run duration rather than its average, the error rate split by class, how saturated the worker pool is, and how much work is currently in progress.
Guardrails for Automated Remediation
Bound an agent's self-healing so a fix cannot loop or grow: only auto-fix idempotent actions, keep rollbacks, scale-downs and database changes behind human approval, set a cooldown, cap runs per day, and notify a channel for every action the agent takes on its own.
Let Idle Workers Pull Work Instead of Waiting
Assigning work to a worker in advance is simple and it goes wrong when the items are uneven, because one worker ends up with the heavy items while another sits idle with an empty assignment. This skill covers pull based dispatch: keep one shared queue, let each worker take the next item when it is free, allow an idle worker to take an item from the tail of a busy worker's local list, and watch per worker queue depth so an idle worker and a long queue are visible at the same time.
Meeting & Family Coordination Automation
Automate meeting transcription with structured notes and coordinate family schedules, chores, and communications using OpenClaw multi-channel routing
OpenClaw Agentic Workflow Patterns
Core patterns for building efficient autonomous agent workflows in OpenClaw: task decomposition with subagent delegation, token-aware summarization, and early-exit design for minimizing wasted computation.
OpenClaw Notification Quiet Hours & Severity Routing
Design an always-on OpenClaw agent that stays polite: route alerts by severity, keep cosmetic notifications out of quiet hours, deduplicate flapping checks, and batch everything non-urgent into one scheduled digest instead of a stream of pings.
OpenClaw Task Decomposition & Workflow Patterns
Essential patterns for efficient autonomous agent workflows in OpenClaw/Hermes: subagent delegation via sessions_spawn, MEMORY.md-based context compression, early-exit design, and DePIN diagnostic loop structure.
OpenClaw Token Budget Orchestration
Techniques for managing token budgets across primary and subagent contexts in OpenClaw: when to compress, when to delegate, and how to prevent context overflow in long-running autonomous workflows.
Quarantine Flaky Checks Instead of Retrying Them
How an autonomous agent should handle an intermittently failing check: record the flake instead of retrying until green, quarantine the check with an owner and an expiry date, keep the pipeline signal meaningful, and force a fix or a deletion when a quarantined check expires. Covers the retry-until-green anti-pattern, quarantine registers, and scheduled re-measurement with OpenClaw cron jobs.
Quarantine Messages That Always Fail
A message that fails because of its own content will fail every time it is retried, and a retry loop that never gives up lets one bad message consume a worker slot forever while the queue behind it grows. This skill covers poison message handling: count attempts per message rather than per queue, separate a transient failure from one that will never change, set the message aside after a fixed number of attempts with the payload and the last error kept, alert so the cause can be fixed, and offer an explicit replay once it is.
Resume a Session Without Replaying Everything
A session that is dropped mid run does not have to start over, but picking it up carelessly can replay work that already happened. This skill covers resuming agent sessions: store enough state to know what was already done, resume from the last confirmed point rather than the last message received, treat a resumed run the same as a fresh one so its effects are applied once, and expire a stale session rather than resuming into a view that no longer holds.
Single-Flight Guards for Overlapping Cron Runs
How to stop a long-running OpenClaw cron job from overlapping its own next scheduled run: a lock-file guard with stale-lock detection, why isolated sessions do not prevent overlap, sizing the schedule against the run's worst-case duration, and checking openclaw cron list before trusting a schedule.
Smart Home & Media Production Automation
Combine OpenClaw's smart home control with content production pipelines — automatically set the perfect environment for recording sessions, trigger media workflows from chat, and build automated routines that bridge your home and creative workflow.
Subagent Context Budget Management
Best practices for managing token budgets when spawning subagents in autonomous workflows: when to compress, how to summarize results, and how to use early-exit design to prevent context overflow.
Tag Runs So Spend Has an Owner
A month of agent spend arrives as one number, and a single number gives no one anything to act on because it cannot be split between the workflow that grew, the tenant that got expensive and the retry loop nobody noticed. This skill covers cost attribution: put a stable tag on every run naming the workflow, the tenant and the trigger, carry that tag through every tool call and message the run makes, report spend per tag together with the run count so an average is visible, give each tag a budget, and alert on the one that is out of line rather than on the total.
Transactional Outbox for Agent Side Effects
An agent that writes to its own store and then publishes a message has two writes and no transaction around them, so a crash in between leaves a record with no message or a message with no record. This skill covers the outbox pattern: commit the intent and the outbound message together, publish from a relay, mark each message sent, deduplicate on the message id, and make the consumer safe to run twice.
Triaging a Dead-Letter Queue
What to do with work that failed every attempt: separate transient failures that deserve a retry from deterministic ones that will never pass, move the permanent failures to a quarantine queue with their payload intact, group identical failures into one thread instead of alerting per job, and cap requeues so a poison job can never wedge the pipeline.
WordPress Divi Automation & Local Staging
Automate Divi-based WordPress development: WP-CLI integration, cache management, and local staging workflows.