Works with the AI Agents you already use
Claude Code
Cursor
Codex CLI
Muse
Dots+21 moreClaude CodeCursorCodex CLIMuseDots
Manus
Grok
Grok Bot+18 agentsMulti Agent Cross Platform State Lock Auditor
Audits distributed state, locks, and race conditions across multi-agent systems and heterogeneous platforms.
$20
Multi Agent Cross Platform State Lock Auditor
Example session with this skill installed
Audit our Redis-based lock logic in worker.py and scheduler.js. We see occasional duplicate tasks when the network is slow. Here is the code and the Redis config.
- Read your context and instructions
- Compiled the multi agent cross
I have audited the coordination logic between worker.py and scheduler.js. The analysis identifies a critical race condition during lease expiry.
Distributed State Lock Audit Report
Executive Verdict: Critical Unsafe
The system is vulnerable to a "stale-owner write" scenario (FS-02). If worker.py pauses for longer than the 30s Redis TTL, the scheduler.js can reassign the lock. When the original worker resumes, it proceeds to commit its task without checking if it still owns the lock, leading to duplicate execution.
Coordination Map
| Actor | Resource | Lock Mechanism | Invariant |
|---|---|---|---|
worker.py | Task DB | Redis SETNX (30s TTL) | Only one worker processes Task ID per window. |
scheduler.js | Task Queue | Redis SETNX (30s TTL) | Tasks are only dispatched if no active lock exists. |
Finding: FS-02 Stale-Owner Write
- Severity: Critical | Confidence: High
- Evidence:
worker.pylines 45-82 show no check of the lock token before the final DB update. - Root Cause: Reliance on TTL for mutual exclusion without a fencing token or conditional write.
- Impact: Duplicate side effects in the Task DB when network latency exceeds 30s.
Remediation
- Implement Fencing Tokens: Increment a version number in the database on each lock acquisition.
Conditional Writes: Update worker.py to use a WHERE version = :expected_version clause in the final SQL commit.
3. Atomic Release: Use a Lua script for lock release to ensure a worker only deletes its own lock.
# Remediation Example: Conditional Update
def commit_task(task_id, fencing_token):
# Ensure write only happens if we still hold the current version
result = db.execute(
"UPDATE tasks SET status = 'complete' WHERE id = ? AND version = ?",
(task_id, fencing_token)
)
if result.rowcount == 0:
raise StaleLockException("Lock lost prior to commit")
Next steps
- Implement the fencing token logic in the Task DB schema.
- Deploy the Lua-based atomic release script to prevent cross-worker lock deletion.
- Run the provided Failure Injection Test Plan to verify the fix under simulated network lag.
Connects securely to your tools. The creator never sees your data.
About this skill
Concurrency is hard. Distributed systems are harder. When multiple agents or services share state, "good enough" locking leads to silent data corruption, race conditions, and split-brain scenarios. This skill audits your architecture, code, and logs to find where your coordination logic fails under stress.
What it does
- Coordination mapping creates a formal trace of every actor, shared resource, and write path to identify hidden contention.
- Lock correctness analysis evaluates atomic acquisition, unique owner tokens, fencing mechanisms, and lease renewal logic.
- Cross-platform semantic review identifies risks in filesystem locks, database isolation levels, and queue delivery across different environments.
- Failure scenario modeling simulates process crashes, network partitions, clock skew, and stale-owner writes (FS-01 to FS-15).
- Remediation planning provides specific fixes for detected race conditions and deadlocks with targeted verification tests.
How it works
- Intake where the user provides architecture, code, and platform details.
- Analysis of lock models and state invariants using the provided checklists and failure scenarios.
- Drafting of the audit report using the severity model to weight risks.
- Verification via a generated test plan for reproducing specific interleaving failures.
Frameworks & tools
This skill is framework-agnostic. It analyzes systems involving Redis, Postgres, S3, SQS, etcd, and local filesystems across Linux, macOS, and Windows environments.
Why this beats prompting it yourself
Generic prompts miss the subtle "stale-writer" problem where a process resumes after a lease expires. This skill uses a structured failure matrix and fencing-token verification to catch bugs that standard code reviews overlook.
Use cases
- Audit a Python worker and a Node.js agent sharing a Redis-based lock.
- Evaluate idempotency and retry logic in a distributed task queue.
- Analyze a system for potential split-brain behavior during network partitions.
- Design a failure-injection test plan for a new microservice.
Known limitations
This produces analysis and planning only. It cannot access production, run real migrations, or provide formal mathematical verification. Findings depend on user-supplied evidence.
Produces analysis only. Cannot access production, run migrations, or provide formal verification. Findings depend on user-supplied evidence.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed today