Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Timed Out? Check Before You Resend

    1

    Use when a send, upload or submit timed out and you can't tell if it went through. Checks the evidence against the original request, then gives a status and one safe next step, without sending twice.

    Free

    Security scanned
    Timed Out? Check Before You Resend

    Timed Out? Check Before You Resend

    Example session with this skill installed

    Reconcile the status for Request REQ-992. Target: partner-api-01. Sent at 10:05 UTC. Log shows a 502 Bad Gateway at 10:05:02, but the DB shows a partial record created at 10:05:01.

    • Read your context and instructions
    • Compiled the timed out check

    I have analyzed the provided logs and database records for Request REQ-992. While the transport layer reported a failure, the database state indicates the request was processed by the target system.

    Delivery Reconciliation Record: REQ-992

    FieldDetails
    Original RequestID: REQ-992 | Target: partner-api-01 | Submit Time: 10:05:00 UTC
    FingerprintNot provided (using ID matching only)
    Last Observation10:05:02 UTC | Entry Point: API Gateway | Status: 502 Bad Gateway
    ConclusionAccepted
    BasisDatabase record creation at 10:05:01 UTC confirms the application layer received and persisted the intent before the gateway timed out.
    GapsLack of byte fingerprint prevents verification that the DB record content exactly matches REQ-992, though timestamps align.

    Analysis
    The 502 Bad Gateway error is a downstream timeout. Because the database entry exists with a timestamp preceding the error, the request reached the backend. Resending now would likely cause a duplicate entry or a 409 Conflict.

    Next steps

    1. Do not resend REQ-992.
    2. Query the database for the specific record created at 10:05:01 UTC to verify the payload content.
    3. Update the local request status to 'Accepted' and close the reconciliation task.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    When a message, document, or API request enters a "pending" or "unknown" state, resending blindly often causes duplicate records or idempotent errors. This skill reconciles messy delivery evidence to determine the actual status of a previous submission without risking a re-transmission. It focuses on identifying specific submission fingerprints to separate successful deliveries from silent failures.

    What it does

    • Status reconciliation identifies whether a request was accepted, sent, delivered, or read based on available logs.
    • Fingerprint matching uses targets, timestamps, and byte-level evidence to verify if a record belongs to the original intent.
    • Gap analysis explicitly flags what evidence is missing and what cannot be attributed to the request.
    • Idempotency protection prevents accidental re-submissions by strictly forbidding the replaying of intents.
    • Conflict resolution handles diverging evidence, such as timeouts or post-acceptance errors, without assuming failure.

    How it works

    1. Analyze input by reviewing the original request identifier, target, and content fingerprint.
    2. Scan observations for query times, entry points, and channel-specific status definitions.
    3. Determine conclusion by mapping evidence to a specific outcome like "accepted" or "outcome unknown."
    4. Draft reconciliation record including the basis for the conclusion and any necessary next steps.

    Frameworks & tools

    This skill is platform-agnostic and works with any messaging API, email log, or database audit trail. It is designed for environments where idempotency is not guaranteed at the transport layer.

    Why this beats prompting it yourself

    Standard prompts often hallucinate a "success" state when logs are ambiguous or suggest resending as a first step. This skill enforces strict boundary rules that prevent duplicate transactions and force a distinction between "not found" and "definitely not sent."

    Use cases

    • Reconciling stuck webhooks where the response was a 504 but the data might have landed.
    • Auditing email delivery logs when a recipient claims non-receipt despite a "Sent" status.
    • Investigating distributed system failures where a transaction ID appears in some logs but not others.

    Known limitations

    Does not perform active network queries or actual re-transmissions. It relies entirely on provided evidence and requires a byte-level fingerprint or specific identifier to guarantee identity.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for LLM Ops.

    Does not execute live API calls or re-sends. Requires existing log evidence and identifiers to function. Cannot resolve status if no logs or timestamps are provided.

    How to use

    1. 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. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    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

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 7 days ago

    • Free with an Agensi account

    Permissions

    No special permissions declared or detected

    Listed7 days ago
    Updated6 days ago

    What's inside

    Frequently Asked Questions

    This skill is designed to prevent duplicate transactions and 'ghost' submissions by cross-referencing messy log data to verify if a 'pending' request actually reached its destination before you attempt to resend it.

    The skill is platform-agnostic and works with any AI agent that can process text-based logs, including those built on OpenAI, Anthropic, or LangChain frameworks, provided you can feed it your system's audit trails.

    No, the skill is strictly an analytical layer; it evaluates provided evidence to determine status but never performs active network requests or re-transmissions to ensure zero risk of accidental duplication.

    You will receive the core logic configuration, a set of strict boundary rules for evidence evaluation, and a guide on how to format your log data for the most accurate reconciliation results.

    While it doesn't require specific software, you must provide it with 'fingerprint' data—such as timestamps, unique identifiers, or byte-level content snippets—to allow the skill to accurately match logs to the original intent.

    New in LLM Ops

    Free