All Skills
350 skills across 18 categories
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.
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 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.
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.
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.
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.
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.
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.