All Skills
350 skills across 18 categories
Agent Adaptive Retry Logic
Strategies for AI agents to handle tool call failures, API errors, and transient faults using adaptive retry patterns including exponential backoff, circuit breakers, and graceful degradation to maintain task progress without wasting context budget on infinite retry loops.
Agent Circuit Breaker Pattern
Master the circuit breaker design pattern for AI agents: how to detect cascading failures, open/close the breaker based on failure thresholds, and implement half-open state to test service recovery.
Agent Circuit Breaker Recovery Strategies
Advanced recovery strategies for circuit breaker patterns in AI agent systems. Covers exponential backoff in open state, probe request strategies in half-open state, partial traffic routing, fallback response caching, and metrics-driven threshold tuning for production agent pipelines.
Agent Circuit Breaker State Machine
Understand and implement the three-state circuit breaker pattern (open, half-open, closed) for AI agent pipelines. Learn how state transitions are triggered by failure thresholds and consecutive-success requirements, enabling automatic recovery from service degradation without manual intervention.
Agent Context Budget Management
Strategies for managing token context budgets in multi-step AI agent pipelines — preventing overflow, summarizing aggressively, and structuring subagent delegation for optimal performance.
Agent Context Budget Patterns
Practical patterns for enforcing O(1) context pipelines in multi-agent systems: proactive pruning, subagent output contracts, and session budget management to prevent reasoning degradation in long-running autonomous tasks.
Agent Context Compression Techniques
Advanced techniques for compressing and managing AI agent context windows to enable long-running tasks without losing coherence.
Agent Context Compression: Implementation Patterns
Concrete implementation patterns for compressing AI agent context windows in production systems. Covers rolling summarization, structured state management, hierarchical delegation, and semantic deduplication strategies that keep long-running agents coherent without token bloat.
Agent Context Window Management
Best practices for managing context windows in large language model agents, including proactive summarization, token budgeting, and semantic memory retrieval strategies.
Agent Context Window Management: Practical Patterns
Practical strategies for managing context windows in long-running AI agents. Covers O(1) growth patterns, hierarchical delegation, phase-based compression checkpointing, and semantic deduplication to keep agents coherent over extended tasks without hitting token limits.
Agent Cross-Platform Session Design
Design session isolation and context synchronization strategies for AI agents deployed across multiple chat platforms (Telegram, Slack, Discord, WhatsApp). Covers when to share vs isolate sessions, platform adapter roles, and user ID mapping.
Agent Data Retention & Purge Policy
Design and operate a retention policy for agent data. Classify transcripts, tool outputs, remembered facts and logs by lifespan, summarise before you delete, honour deletion requests with the memory tools, and schedule idempotent purge jobs instead of keeping every payload forever.
Agent Degradation Recovery Patterns
Strategies for AI agent pipelines to detect degraded state, recover from partial failures, and restore full functionality. Covers health probes, circuit breakers, recovery scheduling, and re-hydration of stale cached data after upstream services come back online.
Agent Dry-Run Testing Workflow
How to use OpenClaw's --dry-run flag to validate autonomous agent behavior before live deployment — inspect planned tool call sequences, catch unexpected operations, and iterate safely.
Agent Error Classification and Recovery Strategy
Teaches agents to classify errors as transient vs permanent and choose the right recovery strategy: retry with backoff, circuit break, or graceful degradation.
Agent Execution Trace Comparison
How to systematically compare dry-run predicted tool calls against live agent execution traces to catch prompt regressions and unintended behavior before they cause production incidents.
Agent Fault Isolation Patterns
Design patterns for isolating faults in multi-agent systems: bulkhead partitioning to prevent cascading failures, timeout hierarchies aligned with context budgets, and retry budgets shared across the agent call tree. Ensures one failing subagent cannot exhaust the orchestrator context or token allowance.
Agent Graceful Degradation Patterns
Design patterns for AI agents to gracefully degrade functionality when upstream services fail, context budgets are exhausted, or subagent pools are saturated. Covers fallback chains, partial result synthesis, and communicating degraded state to the orchestrator without aborting entire pipelines.
Agent Health Probe Design
Design effective health probes for AI agent pipelines: lightweight service checks, probe scheduling, consecutive-success thresholds, and integration with circuit breaker patterns to enable automatic recovery without cascading failures.
Agent Log Audit Patterns
Systematic patterns for auditing autonomous agent logs after deployment — verifying tool call sequences match expectations, detecting unauthorized operations, and establishing a post-deployment verification baseline.
Agent Memory Lifecycle Management
Complete lifecycle management for agent memory systems — when to add facts, how to search effectively, when to summarize, and how to prevent context overflow in production agents.
Agent Memory Retrieval in Practice
Practical patterns for implementing two-tier memory systems in AI agents — semantic search, working vs long-term storage, context overflow prevention, and OpenClaw memory commands.
Agent Memory Retrieval Patterns
Patterns for designing efficient memory retrieval in AI agents — covering semantic search, working memory vs long-term storage, and context-aware recall strategies.
Agent Orchestrator Context Design
Learn how to design orchestrator agents that maintain lean context windows by enforcing structured summarization contracts with subagents, managing memory compression triggers, and architecting O(1) context pipelines.
Agent Output Token Reservation Strategy
How to properly reserve token budget for model output in AI agents to prevent truncated responses and reasoning failures
Agent Phase Boundary Orchestration
Design explicit phase boundaries in multi-step agent workflows: when to cut phases, how to structure state handoffs, and how to maintain task continuity across context resets.
Agent Phase Boundary Protocol
Defines the standard protocol for managing data handoffs between phases in multi-phase AI agent pipelines. Covers compression triggers, summary structures, and state continuity patterns to prevent context bloat and maintain agent coherence across long-running tasks.
Agent Phase Checkpoint Compression
A pattern for compressing agent context at phase boundaries in multi-phase tasks. After each phase checkpoint is confirmed successful, the phase's working history is summarized into a compact structured state, enabling O(1) memory growth across arbitrarily long multi-phase agent workflows.
Agent Phase Handoff Patterns
Practical patterns for compressing and passing state between phases in multi-phase agent pipelines. Covers when to compress context, what to include in handoff summaries, and how to structure state objects to minimize context window growth while preserving continuity across phases.
Agent Phase State Handoff
Techniques for cleanly handing off compressed state between phases in multi-phase agent pipelines, ensuring context efficiency and continuity without data loss.
Agent Pipeline Compression Triggers
When and how to trigger context compression in multi-phase agent pipelines: phase boundary detection, anomaly-aware state transitions, and preventing context exhaustion in long-running workflows.
Agent Pipeline Phase Design
How to structure multi-phase AI agent pipelines with clean handoffs, context-aware summarization, and early exit conditions to maximize efficiency and prevent context overflow.
Agent Pipeline State Handoff Design
How to design efficient state handoff objects between phases in multi-phase AI agent pipelines. Covers compression triggers, what to include in summaries, anomaly forwarding, and the single-update-in-place pattern to prevent context window exhaustion in long-running agent tasks.
Agent Promotion Gate Automation
Automate the sandbox-to-production promotion pipeline with scripted trace comparison, approval gates, and rollback triggers to enforce safe agent deployments.
Agent Resilience Patterns
Combine circuit breakers, adaptive retry with exponential backoff, and graceful degradation to build AI agents that survive transient failures without wasting context budget or causing cascading outages.
Agent Result Summarization Patterns
Learn how to efficiently summarize subagent outputs and intermediate results to maintain lean context in orchestrator agents. Covers summary formats, when to compress, and how to return actionable data from subagents.
Agent Sandbox Promotion Gates
How to define and enforce promotion gates that must pass before an agent moves from sandbox to production — covering trace comparison, approval gates, and rollback triggers.
Agent State Minimization Patterns
Techniques for keeping agent context lean across long-running workflows: structured handoff objects, phase compression, and anomaly forwarding to prevent context bloat.
Agent Subagent Delegation Patterns
Learn when and how to delegate tasks to specialized subagents in OpenClaw — covering spawn patterns, context isolation, result aggregation, and efficiency tradeoffs of monolithic vs. multi-agent architectures.
Agent Token Budget Management
Master techniques for managing token budgets in LLM-based agents, including context compression, dynamic allocation, and overflow handling strategies to prevent silent truncation.
Agent Tool Call Rate Limiting
Learn how to implement and manage rate limiting for AI agent tool calls to prevent API quota exhaustion, respect upstream service limits, and maintain stable agent operation under load. Covers token bucket patterns, backoff strategies, and per-tool rate limit configuration.
Agent Trace Diff Workflow
A systematic workflow for comparing agent dry-run predictions against live sandbox execution to catch behavioral regressions before production deployment.
Agent Version Safety Workflow
A systematic workflow for safely deploying new versions of autonomous agents — combining dry-run validation, sandbox approval gates, and post-deployment log verification to catch regressions before they cause real-world harm.
Agent Workflow Optimization Patterns
Learn the three core patterns for optimizing agentic workflows: subagent delegation, aggressive summarization, and early exit logic to minimize token costs and reduce latency.
Agent Workflow Optimization: Delegate, Summarize, Exit Early
Master the three core patterns for optimizing agentic workflows: subagent delegation for specialized tasks, aggressive summarization to manage context budgets, and early exit logic to prevent unnecessary token burn.
Automated Rollback Triggers for Agent Deployments
Configure and use automatic rollback mechanisms to instantly recover from production incidents caused by misbehaving agent deployments.
Autonomous Agent Safety Deployment Checklist
A practical pre-flight checklist for deploying autonomous AI agents safely: sandbox isolation, approval gates, early exit logic, and dry-run validation before going live.
Autonomous Agent Workflow Optimization
Strategies for reducing latency and token consumption in complex multi-step agent workflows.
Backpressure and Admission Control
When a downstream service slows down, an agent that keeps enqueuing work turns a slowdown into an outage. Bound how much work is in flight, dedupe repeated triggers into a single window, give automatic fixes a cooldown and a daily run cap, and downgrade alerts instead of suppressing them so the signal survives the storm.
Bounding Subagent Delegation Depth
An agent that can spawn subagents can also spawn subagents that spawn more subagents. Without an explicit depth limit this fan-out grows without bound: latency and cost multiply, a single flaky subtask can be retried at every level, and two agents can even delegate to each other in a cycle. This skill covers bounding delegation depth: keep a maximum spawn depth in the orchestration layer, block delegation once a leaf is reached, stamp each task with an ancestor chain to detect cycles, and choose a limit low enough to stay affordable but high enough that decomposition still works.
Caching Stable Prompt Prefixes for Agents
A provider can reuse the unchanged front of a prompt across calls, which cuts both cost and latency when an agent sends the same instructions, tool schemas and older history on every turn. The catch is that a cache is keyed on the exact prefix, so one changing value near the top throws everything behind it away. This skill covers ordering a prompt so the stable parts come first, the things that commonly break a cache, and how to confirm the cache is actually being used rather than assuming it.
Config Attestation for Agent Runtimes
Cryptographic verification of runtime configuration before agent tool execution. Uses BLAKE3 content-addressed hash manifests to ensure config integrity at load time.
Config Attestation Integrity Gates
Using BLAKE3 content-addressed hash manifests to gate agent tool execution on verified configuration integrity, preventing mid-run config drift from compromising autonomous agent behavior.
Containing Task Scope Creep
An agent asked to fix one thing will often fix three, and the extra work is invisible until the diff is reviewed. Scope creep raises review cost, hides the real change among incidental edits, and can break things the task never mentioned. This skill covers keeping the goal bound: restate the deliverable before acting, park unrelated improvements as notes instead of changes, cap the number of files or steps a single task may touch, and surface anything extra as a proposal rather than doing it silently.
Cost Ceiling and Kill-Switch for Agent Loops
How to give an autonomous agent loop a hard cost and iteration ceiling so a bad condition cannot drive unbounded tool calls or spend before a human notices. Covers choosing the ceiling, enforcing it in the runner rather than the prompt, stopping cleanly at the bound with a partial result, and the difference between a cost ceiling and a per-run budget.
Deadline and Cancellation Propagation for Agents
Propagate remaining-time budgets and cancellation signals through nested agent, tool, and subagent calls, so abandoned work stops cleanly instead of burning budget in the background. Covers derived timeouts, monotonic clocks, partial results, and why a cancelled call must never be retried.
DePIN Adaptive Jitter & Backoff Strategies
Learn how to implement adaptive jitter and exponential backoff in DePIN node networks to prevent thundering-herd recovery failures and improve overall network resilience.
DePIN Agent Diagnostic Loop
Teaches AI agents how to implement autonomous diagnostic loops for DePIN infrastructure: health polling, fault classification, remediation triggers, and trust-score-aware escalation paths. Covers the full observe-classify-act-verify cycle used in production DePIN monitoring agents.
DePIN Circuit Breaker Jitter Tuning
Techniques for tuning circuit breaker recovery delay jitter in DePIN agent deployments to prevent thundering herd problems when many edge nodes recover simultaneously. Covers jitter strategies, half-open state management, and probe_success_threshold configuration.
DePIN Data Proof Verification
How verifiers prove a specific sensor reading belongs to an on-chain anchored batch using merkle proofs, sibling hashes, and root recomputation in O(log n) time.
DePIN Edge Node Security Hardening
Security hardening techniques for edge nodes in Decentralized Physical Infrastructure Networks, covering Trusted Execution Environments, secure boot, firmware attestation, and physical tamper resistance for IoT-class DePIN hardware.
DePIN Governance Mechanisms
Understanding on-chain and off-chain governance mechanisms for Decentralized Physical Infrastructure Networks, including voting systems, proposal lifecycles, token-weighted delegation, and governance attack vectors.
DePIN Node Health Monitoring
Monitor and alert on DePIN edge node health metrics including uptime, consensus participation rate, reward accumulation, and hardware security status. Implement automated recovery workflows for common failure modes.
DePIN Parallel Data Mesh Architecture
Learn how DePIN (Decentralized Physical Infrastructure Network) nodes can be organized into parallel data mesh architectures for high-throughput, resilient data aggregation. Covers mesh topology design, gossip-based state synchronization, fault-tolerant data routing, and partition handling strategies used in production DePIN deployments. Explores CAP theorem trade-offs and vector clock usage for causal ordering without centralized clocks.
DePIN Reward Optimization
Using autonomous agents to optimize node uptime and maximize token rewards in DePIN networks.
DePIN Thundering Herd Prevention
Understand and prevent thundering herd failures in DePIN edge node networks. Covers jitter-based staggering, probe_success_threshold tuning, and distributed recovery coordination to ensure that simultaneous node failures do not create cascading recovery storms.
DePIN Validator Failover Without Slashing
Safe hot-standby failover patterns for DePIN validators that prevent double-signing slashes during node transitions. Covers sequential key handoff, remote signers, and downtime vs slash tradeoffs.
DePIN Validator Key Management & HSM Security
How to securely manage validator signing keys using Hardware Security Modules (HSMs) and Trusted Execution Environments (TEEs) to prevent double-signing, key theft, and unauthorized attestations in DePIN consensus networks.
DePIN Validator Partition Recovery
How to safely detect and recover from network partitions in DePIN validator operations, including quorum checks, signing halt procedures, and safe restart protocols to avoid slashing.
DePIN Validator Security Hardening
Comprehensive security hardening for DePIN validators: combining safe failover patterns with HSM/TEE key management to prevent double-signing slashes, key theft, and unauthorized attestations.
DePIN Validator tmkms Operations & Remote Signing
Practical operations guide for deploying and managing tmkms (Tendermint Key Management System) as a remote signer for DePIN validators, covering HSM integration, single-sign guarantees, and safe failover procedures.
Detecting a Self-Repeating Agent Loop
How to notice that an autonomous agent has stopped making progress and is repeating itself, and what to do about it. Covers hashing each action or state signature to spot repeats, distinguishing a true runaway loop from legitimate polling or retries, and the safe reactions: change approach, escalate, or stop with a partial result.
Detecting Poisoned Tool Descriptions
A tool's name and description are written by whoever publishes the tool, and an agent usually reads them as guidance rather than as untrusted data. A description that contains instructions, hidden directives, or claims about other tools can steer the agent before it ever makes a call. This skill covers treating tool metadata as untrusted input: read descriptions as data rather than orders, keep a reviewed allowlist of tools, watch for descriptions that reference other tools or ask for secrets, and re-check metadata when a server updates it.
Flagging Unverified Claims Before Reporting
An agent can state a fluent, plausible claim that it never actually checked. The fix is not to forbid confident language but to separate what came back from a tool or a named source from what the model inferred, and to label the difference in the report. This skill covers asking for a source before treating a claim as fact, marking uncited statements as unverified, and abstaining when a claim cannot be supported at all.
Gate Irreversible Actions Behind Confirmation
How an autonomous agent should handle irreversible or high-blast-radius operations: estimating blast radius, previewing with a dry run, requiring explicit confirmation for the destructive step, scoping approval to exactly one action, and leaving an audit trail. So autonomy never means acting irreversibly on an unverified assumption.
Give Each Run Only the Credentials It Needs
Handing a long lived broad credential down the call chain means one leak, one log line or one over helpful tool grants access to everything the credential can reach, and the damage has no boundary. This skill covers scoped credentials: mint a short lived token per run, bind it to one resource and one action, give it an expiry that matches the run, hold the master credential only where tokens are issued, and log every issuance so a token can be traced back to the run that used it.
Guardrails for Autonomous Agent Loops
How to bound a proactive or autonomous agent loop so it stays useful instead of becoming noise or a runaway. Covers the four guards that make an unattended loop safe: a frequency cap on how often it may act, a cooldown/dedup gate so the same condition is not re-reported, quiet hours for anything that notifies a human, and a hard budget/kill-switch that stops the loop if it exceeds a cost or iteration ceiling.
Human-AI Interface Design
Designing intuitive and contextual interfaces for human-agent collaboration beyond traditional UIs.
Invalidate Cached Tool Results on Change
Cache tool results without serving stale answers. Covers why a time-based expiry alone is not enough, how to build an invalidation key from the tool name plus normalized arguments plus the version of the underlying resource, request coalescing so a cold key does not stampede the upstream service, what to do when the cache backend itself is down, and how to log invalidations so cache-versus-source drift can be audited later.
Keeping the System Prompt From Leaking
A system prompt and the internal rules around it are confidential, but an agent can be talked into reproducing them directly, or leak them indirectly through summaries, translations or echoed tool output. Instructing the model to stay quiet is not a control, because the same channel that carries the instruction also carries the request to break it. This skill covers treating the prompt as a secret, filtering both directions, and recognizing the indirect paths that bypass a refusal.
Let Records Expire on a Clock You Control
State that never expires grows until it is a problem, but a record that vanishes earlier than its reader expects breaks work that depended on it. This skill covers expiry for agent records: give every kind of record a time to live that matches how long anything actually needs it, expire on a clock the system controls rather than on a reader, sweep expired records on a schedule, and alert when the sweep falls behind so growth is seen before the store fills.
Local Memory Management
Configuring and optimizing local vector stores (SQLite-vec, LanceDB) for private agent memory.
Orchestrator-Subagent Output Contracts
Design and enforce structured summarization contracts between orchestrators and subagents to maintain O(1) context pipelines in multi-agent systems.
Pagination Loop Guards for Agents
Drain paginated APIs safely: bounded loops, stalled-cursor detection, correct end-of-data signals, cursor persistence for resume, and rate-limit friendly pacing between pages.
Preventing Deadlock Between Agents
Two agents that each wait on something the other holds will wait forever, and nothing in either local view looks wrong. Deadlock between agents usually involves a shared resource, a lock, or a handoff where each side is blocked on the other. This skill covers the classic conditions for deadlock, acquiring shared resources in a consistent order, using timeouts and leases so a held resource is released, and detecting a stalled pair instead of retrying forever.
Preventing Persistent Context Poisoning
A prompt injection becomes context poisoning when the injected content survives the turn that introduced it. Untrusted text that gets written into memory, folded into a summary, or cached as a reusable artifact can re-enter the context window later wearing the agent's own voice, and from then on it is treated as trusted. This skill covers the persistent form of the problem: mark the provenance of content as it enters, keep untrusted material untrusted when it is recalled, refuse to promote instructions found in tool output into memory, and make summaries preserve where claims came from so unverified statements are not laundered into facts.
Repairing a Failed Plan Mid-Run
When a step in a plan fails, the cheapest wrong move is to retry the whole plan and hope. The useful move is to repair it: re-read the failure, decide which steps are still valid, and replan only the broken tail. This skill covers plan repair for agents, including separating recoverable from terminal failures, preserving completed work, bounding how many repairs a run may attempt, and refusing to silently substitute a different goal for the one requested.
Resolving Conflicting Stored Memories
An agent that keeps notes across runs accumulates facts from different times and sources, and some of them will contradict each other. Choosing silently, usually by overwriting with the newest write, quietly loses the older entry even when it was the correct one. This skill covers storing provenance and time with each memory, preferring the newest verified fact while keeping the superseded one, and surfacing a conflict instead of guessing.
Revoking a Leaked Agent Credential
Scheduled rotation replaces a credential on a timetable; revocation kills one right now because it may already be in the wrong hands. The two are different jobs and the urgent one comes first. This skill covers the revocation sequence: stop the leak, revoke the credential at the source, sweep every place it was copied, and confirm the old value is genuinely refused before declaring the incident closed.
Routing Between Many Similar Tools
Once an agent has dozens of tools, many of them overlap, and the hard part stops being whether a tool exists and becomes which one to use. Picking the wrong near-duplicate wastes calls, and a large flat tool list makes the choice harder for the model. This skill covers routing between similar tools: describe the difference in each tool's contract, narrow the candidate set before choosing, prefer the narrowest tool that fits, and fail clearly when two tools both fit.
Self-Consistency Voting for Uncertain Answers
A single sampled answer hides how stable it is. Self-consistency asks the same question several times and compares the results: when the samples agree, confidence is real, and when they scatter, the task is uncertain regardless of how fluent any one answer looked. This skill covers running several independent samples, voting on the agreeing answer, treating disagreement as a signal to abstain or escalate, and not confusing a majority for the truth when every sample is wrong in the same way.
Speculative Tool Execution with Safe Rollback
An agent can sometimes guess the next tool call and start it before the plan is confirmed, hiding latency when the guess is right. The technique is only safe when the speculative action can be discarded without side effects: reads and idempotent calls are fine, while writes, spending and messages are not. This skill covers choosing what may be run speculatively, discarding a result whose premise changed, and keeping the confirmation step for anything irreversible.
Token-Aware Task Decomposition
Break large agentic tasks into smaller chunks to prevent context window overflow and maintain reasoning quality. Covers subagent delegation, aggressive summarization, and early exit patterns.
Token-Aware Task Decomposition for Agents
Learn strategies for breaking large agentic tasks into smaller chunks to prevent context window overflow, reduce latency, and enable focused reasoning — including subagent delegation, aggressive summarization, and early exit logic.
Token-Aware Task Decomposition Patterns
Techniques for breaking long-running agent tasks into context-bounded phases with clean state handoffs, preventing context overflow while maintaining task continuity.
Tombstones So Deletions Stay Deleted
Deleting a record and stopping there leaves nothing to say the record ever existed, so a replay, a replica sync or a queued write from before the delete can quietly bring it back. This skill covers tombstones: write a delete marker carrying the id and the deletion time, refuse any write older than the marker, expire the marker only after the retention window has passed, and report resurrection attempts instead of hiding them.
Treating Tool and Document Output as Untrusted Data
Why every byte an agent reads from a tool result, web page, file, or message is untrusted data rather than instruction: how to spot embedded directives, avoid the confused-deputy trap, tag content provenance, and refuse PII or credential disclosure even when the request is framed inside content.
Uncertainty, Abstention, and Escalation
How an agent should act when it is not sure. Recognize genuine low confidence, then choose deliberately among four responses: act, abstain, ask, or escalate. The choice should be calibrated to the stakes and reversibility of the action, so an irreversible step is gated on high confidence while a reversible one can proceed with the uncertainty surfaced. Covers why a confident error propagates further than an explicit 'I don't know', and how to avoid the failure modes of guessing under uncertainty and of abstaining on everything.
Validating Tool Parameters Before Execution
Why an agent must validate every tool argument against a strict schema or allowlist before invoking a tool: preventing parameter injection, path traversal, SSRF and destructive side effects when arguments originate from untrusted content.