All Skills
350 skills across 18 categories
A Moderation Gate Before the Agent Acts
An agent that both reads untrusted content and acts on it needs a moderation step between the two, or a hostile input becomes a hostile action. This skill covers placing a classification gate on the ingest and egress paths, deciding when to block versus flag, and recording the decision so a reviewer can see why the agent stopped.
A Write Is Not Done Until a Majority Agrees
A write that is acknowledged from a single copy looks finished the moment that copy answers, and it can be lost when that one copy fails before the change spreads. A quorum write instead waits for a majority of the copies to record the change before it is called done, trading a little latency for the promise that the write survives the loss of any single copy. This skill covers quorum acknowledgement for agent state: choose the quorum size, count distinct copies rather than replies, treat a partial quorum as a failure, and read the quorum back so a caller that was told the write succeeded can find it.
Agent Context Budget Enforcement
Enforce per-session context budgets in multi-agent pipelines to prevent token bloat from accumulating tool outputs, ensuring reliable reasoning across long-running autonomous tasks.
Agent DePIN Resilience Patterns
Resilience patterns for AI agents operating in decentralized physical infrastructure (DePIN) networks, including circuit breakers, adaptive retry, and degradation strategies for unreliable edge nodes
Agent Lease Ownership & Fencing Tokens
Coordinate two workers over one shared resource without a permanent lock. Covers time-boxed leases that expire on their own, monotonic fencing tokens that let the resource reject a stale writer, clock-skew pitfalls, renewal and expiry handling, and why a crashed agent run makes a plain boolean lock unsafe.
Agent Memory Architecture
Learn how to design and implement robust memory systems for AI agents
Agent Memory Architecture Patterns
How to design durable, queryable memory systems for autonomous agents — covering working memory, episodic storage, semantic search, and memory lifecycle management
Agent Merkle Data Verification
How AI agents can use Merkle proof techniques to verify data integrity in distributed systems, combining cryptographic anchoring patterns with agent decision-making workflows.
Agent Security Finding Triage
Triage automated security findings from an agent code review by severity, decide the correct merge gate for each level, and handle hardcoded secrets and dependency CVEs in the right order.
Apply Config Live Without a Restart
A config change that needs a restart means every change carries the cost and the risk of a full stop and start, so small fixes get batched into risky windows and the running state is thrown away each time. Hot reload reads the config again while the agent keeps running, but only safely if the new values are checked before they take effect and the old ones are kept for a return. This skill covers live config reload for agents: read and validate before applying, apply only the keys that changed, keep the previous values so a bad change is one step back, and watch the agent on the new values before treating the change as done.
Attach a Freshness Bound to a Reused Answer
A stored answer saves a call, but nothing says how old it may be before it misleads, so a value that has changed since it was stored is served as if it were current. This skill covers freshness bounds for agent answers: give every stored answer a bound on its age, serve it inside that bound and fetch again outside it, let the bound differ by how fast the answer changes, and prefer a fresh answer over a stale one when both are available. A bound is a promise about the oldest an answer may be, not a guess about when it will change.
Autonomous Agent Safety Patterns
Core safety patterns for autonomous AI agents: sandboxed execution, human-in-the-loop approval gates, rollback strategies, and preventing destructive runaway actions.
Autonomous Coding Agent
Build an AI agent that writes, tests, and deploys code
Backfill the Window a Stopped Consumer Missed
When a consumer is stopped or a step is skipped, the producer carries on and a window of work is never read. The gap is invisible, because live counters only ever count what arrived. This skill covers backfilling a missed window for agent runs: find the last processed position and the first unprocessed one before replaying, replay in position order because order is part of the meaning, make the replay idempotent because it overlaps already-applied work, and confirm the position reaches the head with no hole behind it.
Backfill the Window a Stopped Consumer Missed
When a consumer is stopped or a step is skipped, the producer carries on and a window of work is never read. The gap is invisible, because live counters only ever count what arrived. This skill covers backfilling a missed window for agent runs: find the last processed position and the first unprocessed one before replaying, replay in position order because order is part of the meaning, make the replay idempotent because it overlaps already-applied work, and confirm the position reaches the head with no hole behind it.
Bound Metric Cardinality Before Labels Explode
Every label you attach to a metric multiplies the number of separate series the system must track, and a single label that takes a different value on every request turns one metric into one series per call. The cost is quiet: storage grows, queries slow down, and the dashboard that used to load at once starts to time out. This skill covers bounding cardinality for agent telemetry: find the label that varies per request, bucket or drop it, set a budget on the number of series one metric may carry, and alert when the count grows faster than the work does. The goal is a metric that stays readable, not a label set that records everything.
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.
Catching Runs That Succeed at Doing Nothing
A run that crashes is easy to notice; a run that exits cleanly while producing empty, stale, or wrong output is a gray failure. This skill covers progress invariants, output sanity checks, and post-run assertions that turn a silent non-result into a loud, actionable one.
Change a Shape in Two Deployments
A shape shared between an agent and its callers cannot be changed in one step, because the moment the writer uses the new shape the readers that have not moved yet are reading something they do not understand. Expand and contract splits the change across two deployments with a period in between. First the shape is expanded so both the old and the new form are accepted and written; once every reader and writer is on the expanded version, the old form is removed. This skill covers the sequence for agent tools and stored records: expand before you switch, backfill what is already stored, switch the readers, and only then contract away the old form.
Change a Shared Record Shape Without Breaking Old Readers
Two runs that share a record may disagree about its shape, and a change made for a new reader can break an old one that still reads the previous shape. The break is not in the writer, which keeps producing valid records, but in the reader that no longer understands them. This skill covers schema evolution for agent data: add fields rather than rename them, make every reader ignore fields it does not know, remove a field only after no reader reads it, and keep the writer able to produce the previous shape.
Check a Tool Reply Against the Shape You Expect
A tool that used to return a field can start omitting it, renaming it or nesting it differently, and the call still returns success. The run then reads a missing value as empty and continues, so the failure surfaces far from the tool. This skill covers contract checks for agent tool calls: state the fields each call depends on, test the reply against that shape before using it, raise at the call when the shape changes, and treat a changed shape as a version change rather than an accident.
Choose a Chunk Size Before You Retrieve
Chunk size decides what a retriever can ever find. Too large and the answer is diluted by irrelevant text; too small and the answer is split across pieces that never appear together. This skill covers picking a chunk size from the shape of the documents, adding overlap between neighbours, and keeping a source pointer so any retrieved chunk can be traced back.
Compare and Set So Writes Do Not Get Lost
Two runs read the same record, both change one field, and both write the whole record back. The second write erases the first change and nothing reports an error, so the lost update is only found later when a value is missing. This skill covers the guard: carry a version or revision with the record, write only when the version still matches what was read, re-read and retry on a mismatch, and never read, modify and write in one unguarded step when more than one writer can reach the row.
Cut a Tool Over Between Two Live Versions
A tool version is replaced while work is in flight, and a single deploy that stops the old version and starts the new one leaves a window with no working version and no way back. This skill covers the blue green shape for agent tools: bring the new version up beside the running one, warm it, move traffic across in one step, compare the two on the same signal, and keep the running version alive so that going back is another single step rather than a rebuild. The switch is only safe when both versions can serve at once and the cutover is one action, not a sequence of half steps.
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 & Infrastructure Consulting
Integrate autonomous agents with decentralized physical infrastructure networks.
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 Diagnostics Playbook
A structured playbook for AI agents to autonomously monitor, diagnose, and remediate DePIN node failures. Covers the full alert-to-recovery lifecycle: alert routing via OpenClaw, parallel diagnostic loops, software remediation strategies, hardware escalation protocols, and post-remediation pre-flight verification before consensus rejoining.
DePIN Autonomous Node Diagnostics
Learn how AI agents autonomously monitor, diagnose, and self-heal DePIN nodes to maximize uptime and rewards. This skill covers the full lifecycle: alert routing via OpenClaw, diagnostic loop execution (log checks, connectivity, hardware status), autonomous remediation strategies (restart, config fix), and hardware provisioning using configuration templates and pre-flight verification scripts.
DePIN Autonomous Node Recovery Workflow
A complete end-to-end workflow for autonomous DePIN edge node failure detection, diagnosis, remediation, and consensus re-entry using AI agents.
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 Connectivity Management
Managing non-terrestrial network (NTN) and D2D connectivity for autonomous agents.
DePIN Connectivity Management
Managing non-terrestrial network (NTN) satellite links, gossip-based peer sync, partition behavior, and latency optimization for distributed DePIN edge nodes.
DePIN Consensus Participation
Configuring agents to participate in and validate decentralized consensus mechanisms.
DePIN Consensus Participation Patterns
Advanced patterns for validator nodes participating in DePIN consensus mechanisms, covering Byzantine fault tolerance, reward optimization, slashing avoidance, and NTN connectivity for remote nodes.
DePIN Consensus Resilience
Hardening agent-driven consensus participation against network-level and Byzantine attacks in DePIN networks.
DePIN Consensus Resilience Patterns
Patterns for maintaining validator consensus participation under adverse conditions: network partitions, leader failures, Byzantine fault scenarios, and safe recovery from missed blocks without triggering slashing.
DePIN Data Anchoring Patterns
Techniques for anchoring off-chain sensor and edge data to on-chain proofs in DePIN networks, covering merkle commitments, batch anchoring, and verification workflows.
DePIN Distributed Recovery Coordination
Advanced patterns for coordinating circuit breaker recovery across a fleet of DePIN edge nodes. Covers jitter-based staggering, consensus-driven recovery gating, probe_success_threshold tuning, and multi-tier failure isolation to prevent cascading failures and thundering herd storms when large-scale outages resolve.
DePIN Edge Computing
Deploying SLMs and agentic workloads on DePIN edge nodes.
DePIN Edge Computing Patterns
Core patterns for deploying and operating edge computing nodes in DePIN networks: local processing, data sovereignty, connectivity management, and integration with gossip protocols for eventual consistency.
DePIN Edge Governance Patterns
Patterns for governing decentralized physical infrastructure at the edge: combining on-chain governance with local autonomy, handling network partitions during governance votes, edge node veto rights, and two-tier governance architectures where edge clusters self-govern within globally set parameters.
DePIN Edge Network Diagnostics
Performing automated diagnostics on DePIN edge nodes using autonomous AI agents.
DePIN Edge Network Governance
Managing decentralized governance for edge-heavy DePIN networks via agentic participation.
DePIN Edge Network Security
Hardening DePIN edge nodes against physical and network-level attacks via agent-driven monitoring.
DePIN Edge Node Governance & Security Integration
How DePIN edge nodes participate in governance while maintaining security: combining TEE-based attestation with governance voting, ensuring physically distributed hardware can safely participate in on-chain decisions, and applying security hardening to governance infrastructure at the edge.
DePIN Edge Node Pre-Flight Validation
Comprehensive pre-flight validation for DePIN edge nodes before rejoining consensus, covering parallel diagnostic loops across logs, connectivity, and hardware, plus autonomous software remediation gates.
DePIN Edge Node Resilience Patterns
Comprehensive resilience patterns for DePIN edge nodes including multi-layer circuit breakers, adaptive jitter recovery, probe-based health verification, and distributed failure isolation to maintain network uptime during partial outages.
DePIN Edge Node Secure Governance Integration
How to integrate hardware security (TEEs, secure boot) with DePIN governance participation to prevent vote manipulation and Sybil attacks at the edge.
DePIN Edge Operations: Autonomous Diagnostic Workflow
A practical guide to autonomous DePIN edge node diagnostics: alert routing via OpenClaw, parallel diagnostic loops covering logs/connectivity/hardware, software remediation strategies, and pre-consensus pre-flight checks.
DePIN Full Edge Stack: Security, Governance, and Connectivity
Comprehensive guide covering the complete DePIN edge node stack: TEE-based security, two-tier governance, NTN connectivity, and gossip-based consistency — from initialization to production operation.
DePIN Gossip Protocol and Partition Recovery
How DePIN edge nodes maintain eventual consistency via gossip protocols, handle network partitions with vector clocks, and use data anchoring for tamper-proof auditability
DePIN Infrastructure Provisioning
Automating the deployment of physical infrastructure via agent-driven scripts.
DePIN Infrastructure Provisioning Workflow
Step-by-step workflow for provisioning DePIN edge nodes: initial setup, security configuration, connectivity verification, consensus enrollment, and production readiness validation.
DePIN Latency Optimization
Optimizing edge-to-agent latency in decentralized infrastructure networks.
DePIN Latency Optimization Patterns
Advanced patterns for minimizing latency in decentralized physical infrastructure networks, covering edge caching, routing optimization, consensus fast-path techniques, and real-time telemetry aggregation.
DePIN Network Governance
Using autonomous agents to participate in decentralized governance for physical infrastructure networks.
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 Recovery Escalation Decision Logic
How to implement autonomous triage logic that correctly differentiates between software failures (agent-remediable) and hardware failures (human-escalation required) in DePIN edge node recovery workflows.
DePIN Resource Orchestration
Orchestrating agentic tasks across multiple DePIN providers and hardware types.
DePIN Sovereign Data Mesh Architecture
How to design decentralized data anchoring and connectivity patterns for DePIN nodes
DePIN Sovereign Data Mesh Architecture
Design and implement sovereign data mesh patterns for DePIN edge networks. Covers data anchoring, peer gossip protocols, partition handling, and ensuring data sovereignty without central authority.
DePIN Sustainability Management
Managing the environmental impact and energy efficiency of DePIN agent workloads.
DePIN Validator Consensus Safety Patterns
Patterns for maintaining safe consensus participation in DePIN validator networks: double-signing prevention, remote signing with tmkms, and governance-aware key rotation.
DePIN Validator Double-Sign Prevention
Techniques for preventing double-signing slashing events in DePIN validator networks. Covers tmkms single-signer enforcement, HSM-backed key isolation, priv_validator_laddr configuration, and operational checklists for safe validator migrations and key rotations that prevent Byzantine fault accusations.
DePIN Validator Key Rotation with Governance Coordination
How to safely rotate validator consensus keys in DePIN networks using governance-approved maintenance windows: HSM key generation, on-chain registration sequencing, tmkms config migration, and zero-downtime handoff procedures.
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.
DePIN Validator Slashing Defense
Understand and prevent the three major slashing conditions in DePIN consensus networks: double-signing, prolonged downtime, and equivocation. Covers BFT quorum thresholds, penalty severity, and operational safeguards.
DevOps Monitoring & Alerts
Monitor infrastructure and receive alerts via chat
Enforce a Hard Quota Before the Pool Fills
A shared pool serves many tenants, and one tenant that runs far more work than the rest can fill it and push every other tenant behind. A quota sets the share each tenant may hold. This skill covers quota enforcement for agent systems: set a hard cap per tenant rather than a soft one that only warns, check the cap before admitting work rather than trimming after, count the work in flight as well as the work queued, return a clear refusal so the caller can back off, and alert when one tenant sits at its cap for a long stretch.
Gate a Change on an Eval Delta, Not a Vibe
Before a prompt or model change ships, run a fixed set of tasks and compare the score against the current version. A gate blocks a change that improves the demo but regresses the set. Covers a frozen eval set, a pre-agreed metric and threshold, and the rollback path.
Hard-Tech AI Ethics
Ethical considerations for deploying autonomous agents in critical physical and infrastructure-heavy systems.
Hard-Tech AI Strategic Planning
Developing long-term roadmaps for AI integration in physical and infrastructure-heavy industries.
Hedge a Slow Request Instead of Waiting on the Tail
Most calls to a tool return quickly, but a small share stall, and a caller that waits on each call in turn pays the whole stall. Hedging sends a second copy of a particular call to a different route after that call has been slow for a set time, then takes the first answer and cancels or ignores the other. This skill covers hedging for agent tool calls: pick the delay from the normal response time, cap how much extra work hedging may add, cancel the losing copy, and keep the step from turning one slow call into a storm of duplicates.
Hermes Deployment Backends
Deploy Hermes across Docker sandboxes, SSH remote targets, and serverless Modal — and know when to pick which
Hold a Warm Pool So a Burst Skips Cold Start
The first task a worker handles after it is created waits for the worker to come up, load what it needs and reach a ready state, and that wait is paid again for every new worker. When work arrives in a burst, a pool that starts workers only after the work lands makes every task in the burst wait for the same slow step. This skill covers holding a small pool of warm workers so the first task is fast, keeping replacements coming before the warm set drops, and retiring warm workers that stay idle so the floor does not become a standing cost.
Injection-Resistant Tool Invocation
Verify that tool calls are triggered by legitimate user intent rather than injected data, and validate parameters before execution
Keep a Session on One Worker
When work for one session is spread across several workers, each worker holds only part of the state and the session starts to behave as if it has no memory of its own recent turns. Session affinity routes every request that carries the same session key to the same worker while other sessions spread freely. This skill covers sticky routing for agent work: choose the session key, route by it, keep the session on one worker until it ends, and define what happens when that worker goes away so a session can move without losing its place. Affinity is a promise about where a session lives, not a guarantee that it lives forever.
Keep an Append-Only Log of What a Run Did
A run that stores only its current state cannot explain why the state is what it is, and a run that failed leaves nothing to replay. This skill covers an append-only event log for agent runs: record each step as an immutable event carrying the run identifier and a sequence number, rebuild current state by folding the events in order, never edit a past event but append a correcting one instead, and use the log to replay a run in a test environment when a step needs investigating.
Keep Data in the Region It Belongs To
An agent that fans out to services in several regions can quietly move data across a boundary it is not allowed to cross. This skill covers pinning a run to the region where its data may live, routing tool calls to that region, and refusing a cross-region fallback that would leak data even when it would improve availability.
Keep Order Per Key While Many Keys Run at Once
Parallel work lifts throughput but breaks any order the caller was relying on, so two events for one account can finish out of turn and the later one loses. This skill covers ordered fan out for agent work: split a stream by a key, let different keys run at once, keep the events for any one key in a single line, and slow or block a key rather than let its events cross. Order is only kept inside a key, so the key must be the thing that must not be reordered, such as an account, a file or a session.
Market Correlation Analysis
Analyze relationships between asset prices (stocks, crypto), prediction market odds, and real-world events. Detect alpha signals through correlation heatmaps, time-series analysis, and anomaly detection.
Move a Session Between Models Without Losing Its Place
A session that moves from one model to another carries more than the last message. The two models may read the same transcript differently, accept different token limits, emit tool calls in different shapes, and expect different system framing. A handoff treats the move as a translation rather than a swap: it picks a turn boundary, rewrites the carried state into the new model's shape, keeps the transcript so the session keeps its history, and confirms the new model can continue the turn before the old one is released. Done this way the session does not notice the change; done carelessly it answers as if it had lost the last few turns.
Move a Session to Another Region Without a Gap
When a region degrades, sessions must move to a healthy one, but a move that copies state without fencing can leave two regions both believing they own the same session. This skill covers cross region failover for agent sessions: carry the session state to the target first, confirm the target can serve the turn, give the new owner a fence token the old one cannot hold, reject any delayed message from the old region, drain the old region so in flight turns finish, and alert on regional health so a move starts before the failure is total.
Move Work Between Workers Without Losing a Job
A worker that leaves while holding a job leaves the job owned by nobody, and a worker that joins while jobs are being moved can receive the same job twice. Both are quiet, because the queue looks healthy in each case. This skill covers graceful rebalance for agent workers: drain a leaving worker before it stops, hand back the jobs it still holds, place those jobs before accepting new ones, and confirm every job is owned exactly once after the move.
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.
Negotiate What a Tool Supports When You Connect
An agent and a tool can be joined while each supports a different set of features, and a caller that assumes a feature is present breaks in a way that looks like a crash rather than a mismatch. This skill covers capability negotiation for agent tools: state the features and limits each side supports at connect time, agree on the common set before work starts, fall back cleanly when a feature is missing, and re check the agreement when either side is updated. The agreement is a promise about what may be called, not a guess drawn from a version string.
Orbital Data Center Operations
Managing thermodynamic constraints and data persistence for agents in orbital environments.
Orbital Edge Data Lifecycle
Managing the data lifecycle for agents in orbit, from collection to immutable anchoring.
Orbital Hardware Orchestration
Orchestrating specialized hardware (FPGA, TPU) for agent workloads in orbital data centers.
Orbital Network Handoff
Optimizing agent session handoff between orbital data centers during LEO satellite transit.
Orbital Network Handoff (v2)
Strategies for seamless agent session migration between LEO satellite data centers.
Orbital Network Resilience
Strategies for maintaining agent connectivity during solar flares and LEO transit outages.
PR & Code Review Automation
Automate pull request notifications and code review 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.
Prepare Then Commit, So Side Effects Stay Together
An agent that calls several tools which each change something can leave the effect half applied when one call fails after another succeeded, and the run ends with a state no part of the plan intended. This skill covers a prepare then commit pattern: a first phase that checks preconditions and takes a claim without changing anything, a durable record of the decision to commit, a second phase that applies every change or none, and a recovery path that reads the record after a crash to decide whether to finish or reverse.
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.
Radio Frequency AI Integration
Strategies for integrating autonomous agents with RF combat and resilience systems.
Read One Consistent Snapshot While the Run Writes
A run that reads several records to make one decision can land on either side of a concurrent write, so the decision is taken from an older value and a newer one at the same time. Nothing errors, because each value is valid on its own. This skill covers consistent snapshot reads for agent runs: pin a read point when the decision starts, read every input as of that point, discard a snapshot that predates a write the decision depends on instead of patching one field, and retry the whole read rather than mixing versions.
Read One Consistent Snapshot While the Run Writes
A run that reads several records to make one decision can land on either side of a concurrent write, so the decision is taken from an older value and a newer one at the same time. Nothing errors, because each value is valid on its own. This skill covers consistent snapshot reads for agent runs: pin a read point when the decision starts, read every input as of that point, discard a snapshot that predates a write the decision depends on instead of patching one field, and retry the whole read rather than mixing versions.
Record the Intent Before the Effect
A write-ahead intent log records what a run is about to do, and why, before it does it. If the process stops midway, the record is the only thing that tells recovery whether the action half happened or never started, which decides whether to finish, undo or escalate. This skill covers the pattern for agent systems: append the intent and flush it before the effect, give every intent a unique id and an outcome slot, mark the outcome after the effect, scan unfinished intents on start, make replay idempotent, and never act on an intent already marked done.
Rehearse a Change on Mirrored Traffic Before Switching
A new version can pass every test and still fail on the first real request, because the test never carried the shape of live input. This skill covers shadow traffic for agent runs: send a copy of live requests to the candidate version without letting its replies reach the user, compare both answers on the same input, ignore differences that are only formatting, and switch the live path only once the two agree on the traffic the candidate has actually seen.
Rehearse Failure with Injected Faults
A system that has never failed on purpose is a system whose failure behaviour is untested. This skill covers fault injection for agent systems: inject one fault at a time in a place that can be reversed, start in a low risk environment before a live one, watch the recovery path rather than only the fault itself, bound the impact so a rehearsal cannot cause the harm it was meant to reveal, and record what was injected so a real incident can be told apart from a drill.
Replay a Failing Run from Its Transcript Alone
A run fails once and produces a plausible answer the next time, so the failure cannot be studied. What changed between attempts was the clock, a random value and live tool responses. This skill covers deterministic replay for debugging agent runs: record everything a step can read, including inputs, seed, tool responses and clock readings, return the recorded response during replay instead of a fresh one, keep the transcript immutable, and read a run that will not reproduce as pointing at the recording rather than at the bug.
Replay a Failing Run from Its Transcript Alone
A run fails once and produces a plausible answer the next time, so the failure cannot be studied. What changed between attempts was the clock, a random value and live tool responses. This skill covers deterministic replay for debugging agent runs: record everything a step can read, including inputs, seed, tool responses and clock readings, return the recorded response during replay instead of a fresh one, keep the transcript immutable, and read a run that will not reproduce as pointing at the recording rather than at the bug.
Replay Old Work Without Starving Live Work
After a gap a consumer must replay a backlog, but an unthrottled replay competes with live traffic for the same pool and can push live work behind old work, so the catch-up causes a second incident. This skill covers throttled backfill for agent work: give replay a share of capacity rather than the whole pool, pause replay when live lag grows and resume when it falls, checkpoint the position after each batch so a stopped replay continues instead of restarting, and alert when the backlog is not shrinking so a replay that cannot keep up is seen early.
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.
Rerank Retrieved Candidates Before You Use Them
A first-stage retriever optimises for recall and returns many loosely relevant items; feeding them all to the model wastes context and invites the wrong one to win. This skill covers a rerank pass that scores each candidate against the actual question, trims the list to a context budget, and keeps the raw candidate set for audit.
Research Report Generation
Automate research gathering and report creation
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.
Restore to a Point in Time You Trust
A snapshot is only useful if you know what it contains and can restore it without taking the live system down. This skill covers point in time restore for agent state: capture a snapshot that includes the records the agent depends on, verify a restore into a scratch place before touching the live one, restore to a named point rather than whatever is latest, and keep the restore path exercised so it does not rot and fail when it is finally needed.
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.
Retire a Tenant Without Leaving Data Behind
When a tenant leaves, the hard part is not the deletion but the enumeration, because a tenant's data is spread across run records, schedules, credentials, caches, logs and derived copies, and a single missed store becomes a retention problem that surfaces much later. This skill covers offboarding: list every store keyed by the tenant identifier before deleting anything, revoke credentials first so nothing can write again, delete source data before derived copies, and verify each store is empty rather than trusting the deletion call.
Retire a Tool Call Over a Window Instead of Deleting It
Removing a tool call the moment a replacement arrives breaks every run that still uses the old one, and the breakage appears in those runs rather than at the removal. This skill covers deprecation windows for agent tools: mark the old call as deprecated while it still works, warn the callers that still use it, keep the old path alive for a stated period, and remove it only once no live run depends on it.
Rotate a Secret Without Breaking the Work
A secret that never changes is a secret that only has to leak once to end the game, but a rotation done carelessly drops every run that is mid flight. This skill covers credential rotation for agent systems: accept two versions of a secret at once during the changeover so old and new callers both work, rotate on a schedule rather than only after an incident, keep the new secret out of logs and replies, retire the old version only after the new one is proven, and alert when a secret ages past its rotation date.
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.
Safe Tool Invocation
Verify tool calls are safe before execution, reject injected instructions in tool parameters
Sample the Trace by Outcome, Not at Random
Uniform sampling keeps a fixed share of runs and throws away the rest, which works until the runs you most need to see, the slow ones and the failed ones, are as rare as everything else and get discarded with the routine traffic. Tail based sampling decides after the run has finished, keeping every run that failed or ran slow and sampling the ordinary ones lightly. This skill covers outcome based sampling for agent traces: pick the outcome signals first, keep all of the rare bad ones, sample the common good ones, and account for the sampling rate when a count is read from the data so a sample is never mistaken for the whole.
Sample Verbose Logs Without Losing the Signal
Logging every step of every run produces so much text that the one line which explains a failure is buried, and the cost of storing and searching it grows with the traffic. Sampling keeps a share of the routine lines and discards the rest, but a rule that treats all lines alike will throw away the error lines at the same rate as the noise. This skill covers sampling logs for agent runs: choose the rate for routine lines, always keep errors and warnings, keep the lines around a kept error so it stays readable, carry the run id on every line, and scale any count read from the data by the rate.
Second Brain / Knowledge Management
Build a personal knowledge management system via chat
Size the Connection Pool Before It Runs Dry
A connection pool is a fixed set of reusable links to a service, and every worker that holds one while it waits on a slow call takes it out of circulation. When enough workers do this the pool empties, new work waits for a link rather than for a server, and the delay looks like a slow backend. This skill covers keeping a pool healthy for agent work: size it above peak use with headroom, set a hold limit shorter than the slowest call, always return a link even on failure, and watch the number of waiters so an empty pool is seen before work starts to fail.
Sovereign Data Anchoring
Strategies for anchoring agent-generated data to immutable ledgers for auditability and sovereignty.
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.
Stop a Low-Priority Task Holding the Lock
Priority inversion is a wait that has nothing to do with load: a high-priority task is blocked on a shared resource held by a low-priority task that has been scheduled out, so the important work sits idle while the unimportant work is simply not running. It is easy to misread as a slow backend or a busy pool. This skill covers the pattern for agent systems: keep critical sections short, never hold a lock across a slow call, give every wait a timeout, raise the holder to the waiter's priority for the time it holds the resource, and alert when a high-priority wait is held by a lower-priority task longer than usual.
Validator HSM Key Lifecycle Management
Best practices for managing the full lifecycle of validator consensus keys using Hardware Security Modules (HSMs) including generation, rotation, backup, and retirement of keys in a DePIN validator context. Covers tmkms workflows, governance coordination, and zero-downtime rotation procedures.
Verifying Inbound Webhook Signatures
Verify the authenticity of inbound webhook payloads before acting on them: HMAC over the raw body, constant-time comparison, replay windows, and fast acknowledged async processing.
Version Workflows for In-Flight Runs
A workflow definition that changes while runs are still executing leaves those runs reading a shape that no longer exists, so a step is skipped or a field is missing exactly when the run is halfway done. This skill covers workflow versioning: record the version each run started with, apply a new definition only to new runs, finish in-flight runs on the definition they began with, and change the state shape only through an explicit branch.
Wait for Every Branch Before Joining a Fan-Out
A run that splits work across several branches and joins as answers start arriving can decide on a partial set and never notice the branch that was slow, and that branch may carry the answer that changes the decision. This skill covers the gather barrier for fan-out agent work: define the full set of branches before starting, wait for each to report success or failure, record which are missing, and never present a partial set as a complete one.