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.
Autonomous Cron Run Reporting: Silence vs. Signal
How scheduled agent jobs should decide what to deliver at the end of a run: return the [SILENT] marker as the entire response when nothing in the monitored domain changed, always report genuine state changes, failures, and cooldowns, and never fabricate results when a tool call or API fails.
Background Process Notification Discipline
When to pair a background terminal process with notify_on_complete, when to run it silent, and when (and only when) watch_patterns is the right signal tool in Hermes/OpenClaw.
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.
Canary Runs Before a Workflow Change Goes Wide
A workflow change that looks fine on one test case can behave badly on the tenth, because real inputs vary and the failure only shows up at a certain shape of request. This skill covers canary rollouts for agent workflows: give the new version a small share of live runs, measure one health signal against the old version on the same traffic, compare it to a threshold chosen before the rollout started, widen the share only when the signal holds, and roll back automatically rather than waiting for someone to notice.
Cap the Heavy Run So the Shared Pool Stays Fair
One long or expensive run in a shared pool can take the concurrency, call budget or connection slots that every other run depends on, so the others queue behind a neighbour that never asked for the whole pool. This skill covers noisy neighbour isolation for agent workers: give every run a bounded share enforced whether or not the pool is busy, separate batch work from interactive work so the slower shape does not set everyone's latency, find the neighbour by per-run attribution rather than pool-wide averages, and accept the idle capacity the bound costs.
Cap the Heavy Run So the Shared Pool Stays Fair
One long or expensive run in a shared pool can take the concurrency, call budget or connection slots that every other run depends on, so the others queue behind a neighbour that never asked for the whole pool. This skill covers noisy neighbour isolation for agent workers: give every run a bounded share enforced whether or not the pool is busy, separate batch work from interactive work so the slower shape does not set everyone's latency, find the neighbour by per-run attribution rather than pool-wide averages, and accept the idle capacity the bound costs.
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
Decide When a Window of Events Is Complete
A step that finalizes a batch on wall-clock time will close the window while events that belong to it are still arriving, so the totals are wrong and nothing reports an error. This skill covers a watermark: track the lowest event time still expected, close a window only when the watermark has passed its end, allow a bounded lateness tolerance, and route an event that arrives after its window closed into a reconcile path instead of dropping it.
DePIN Agent Orchestration Patterns
Core patterns for autonomous agents managing DePIN resources: provisioning, monitoring, consensus participation, and fault recovery across distributed edge nodes.
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.
DePIN Autonomous Triage Workflow
A complete autonomous triage framework for DePIN edge nodes: detect failures via diagnostic_loop, classify as software vs hardware, apply appropriate remediation or escalation, then validate recovery with preflight_check before rejoining consensus.
DePIN Node Triage and Escalation Patterns
Decision patterns for autonomous triage of DePIN edge node failures: when to self-remediate software failures vs when to escalate hardware failures to human operators, with preflight validation before consensus rejoin.
DePIN Validator Monitoring and Alerting
How to monitor DePIN validator health: liveness probes, missed-block detection, the alert_route to diagnostic_loop escalation path, preflight checks before rejoining consensus, and jittered alerting to avoid thundering-herd alert storms.
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.
Generated Script Integrity Verification After Writes
Verify tool-written scripts with a post-write lint: content redaction filters can silently corrupt secret-loading lines, and the write tool's echo display is not a reliable source of truth.
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
Multi-Sport Betting Analytics
Build dashboards that aggregate betting odds across NFL, NBA, NHL, FIFA, and other major sports from multiple prediction markets. Learn to normalize odds formats, detect line movements, and identify value bets.
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.
Prediction Market Monitoring
Build automated monitoring systems that track prediction market odds across Polymarket and Kalshi. Learn to detect market movements, identify arbitrage opportunities, and stream real-time updates to dashboards.
Priority Queues Without Starvation
Strict priority queues keep the urgent lane fast by letting it take every worker, which means a steady trickle of high priority work can starve the background lane forever. This skill covers starvation control: reserve a share of capacity for the low lane, age waiting items so their effective priority rises, cap bursts from the high lane, and measure wait time per class instead of only per queue.
Promote a Warm Standby by Lease, Not by Assumption
Running exactly one coordinating worker is easy until it stops and nobody notices, or two of them believe they are the leader at once. This skill covers safe leadership handoff for agent workers: hold leadership as a lease that expires unless renewed, carry a fencing token that only moves forward so a resumed old leader has its writes refused, keep the standby consuming the same stream so promotion is a short handoff rather than a rebuild, promote on the lease rather than on a timer, and resume from the recorded position.
Promote a Warm Standby by Lease, Not by Assumption
Running exactly one coordinating worker is easy until it stops and nobody notices, or two of them believe they are the leader at once. This skill covers safe leadership handoff for agent workers: hold leadership as a lease that expires unless renewed, carry a fencing token that only moves forward so a resumed old leader has its writes refused, keep the standby consuming the same stream so promotion is a short handoff rather than a rebuild, promote on the lease rather than on a timer, and resume from the recorded position.
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.
Reporting Partial Success and Incomplete Batches
A batch that processed most of its items is neither a success nor a failure, and a binary flag hides the difference. This skill covers partial-success reporting for agents: report the counts of succeeded, failed and skipped items, name the failures, retry only the items that failed, and never let a partially applied batch read as complete on a dashboard.
Require a Second Approver for High-Risk Actions
A single approval is one person agreeing with themselves, so for an action that is hard to reverse a second distinct approver should be required. This skill covers the two person rule for agent systems: separate the requester from the approvers so the requester cannot approve its own request, require two distinct approver identities for a high risk action, give approvals a short life so an old one is not a standing permission, record both identities with the action so the second review is visible, and alert when one actor supplies nearly all approvals.
Reserve Capacity for the Work That Cannot Wait
When every task draws on one shared pool, a burst of ordinary work can consume the room that a task which cannot wait needs, and the critical task is delayed by traffic that matters far less. Capacity reservation sets aside a slice of the pool for a named class of work so it is never crowded out. This skill covers reservation for agent systems: name the work that cannot wait, hold a slice back for it, allow others to borrow the slice only while it is idle, reclaim borrowed slots when the named work arrives, and alert when the reserved slice is spent on work it was not set aside for.
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.
Retire a Flag When It Stops Deciding
A feature flag is added to decide between an old path and a new one, and once the new path is the only one running the flag stops deciding anything, yet it stays in the code and in every branch that reads it. Over time the flags pile up, each one a branch that must be read to know what the code really does. This skill covers the lifecycle of a flag for agent work: give every flag an owner and an end date, treat the full on state as the target, remove the flag once it is always on, and keep a small separate set of flags that exist only to switch something off in an emergency.
Run the Work That Fits the Remaining Budget
A queue that runs strictly in arrival order will start a long task with little budget left and then fail it at the deadline, wasting room a short task could have used. Budget aware scheduling looks at the estimate before the queue position. This skill covers the pattern for agent systems: carry a budget estimate on every task, admit the work whose estimate fits the remaining budget, downgrade or defer work that will not fit instead of starting it, keep a slice of budget unspent for urgent work that arrives late, and alert when a run spends most of its budget before it is half done.
Server Readiness Verification Before Dependent Steps
Verify a freshly started server is ready before running tests or dependent steps against it: poll a health endpoint or watch for a startup-complete log signal instead of sleeping on a fixed timer.
Shared /tmp Collision Prevention in Concurrent Cron Sessions
How sibling Hermes/OpenClaw cron sessions running on the same host can silently overwrite each other's temporary scripts in shared /tmp, and the per-run unique filename pattern that prevents it. Covers spotting the 'modified by sibling subagent' write_file warning and the safe verify-then-run response.
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.
Spend an Error Budget, Then Slow the Change
An error budget turns reliability into a number a team can spend, so a service that is healthy can move fast and one that is not must slow down. This skill covers error budgets for agent systems: set a target and derive the allowed failure from it, measure the budget spent over a window rather than per request, slow or hold risky change when the budget is nearly gone instead of freezing everything, and alert on the burn rate so a fast spend is seen before the budget is empty.
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.