More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Trading Bot Go-Live Review

    1

    A pre-flight safety audit for any trading bot before it touches real money.

    $19

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Trading Bot Go-Live Review

    Trading Bot Go-Live Review

    Example session with this skill installed

    Review my trading bot in bot.py and risk.py before I switch it from paper to live. Is it ready?

    • Read your context and instructions
    • Compiled the trading bot go-live

    Verdict: NO-GO. The strategy logic is cleanly separated, but the execution layer has two Critical defects that can place duplicate orders, plus a halt that can freeze the bot silently. All four fixes are small.

    Money path

    1. Signals: strategy.signals() (bot.py:29)
    2. Sizing: position_size() (risk.py:6)
    3. Risk gate: none. No check runs between sizing and submission.
    4. Broker submit: broker.submit_order() (bot.py:33). This is the only submitter, which is good.
    5. Fill ingestion: none. Positions are never read back.

    Findings

    #SeverityFindingLocation
    1CriticalA timeout is retried as a new orderbot.py:31-36
    2CriticalThe same signal can buy again every cyclebot.py:29-33
    3HighSize grows with equity, with no absolute cap or exposure limitrisk.py:3, 7
    4HighAny error becomes a permanent, silent haltbot.py:24-26, 37-38
    5MediumNo startup reconciliation of orders and positionsbot.py:22-28
    6MediumOrders are priced from the signal price, with no quote freshness or market-hours checkbot.py:33

    1. A timeout is retried as a new order (Critical).
    Scenario: the broker accepts the order, but the response times out. The loop retries up to 3 times with no client order ID, so one signal can become

    three filled orders at three times the intended size.
    Fix: write a durable intent record with a unique ID before submitting, pass it as client_order_id, and after a timeout look the order up by that ID instead of resubmitting.

    2. The same signal can buy again every cycle (Critical).
    Scenario: if strategy.signals() still reports the breakout on the next 60-second loop, the bot buys again, and keeps buying, because nothing records that the signal was already acted on or checks for an existing position.
    Fix: give each signal a stable ID and skip any ID with an existing intent. Also skip symbols that already have a position or an open order.

    3. Size grows with equity, with no absolute cap (High).
    Scenario: 25% of equity per position, with no per-symbol, gross or absolute dollar cap. A deposit, or finding #2, quietly scales exposure. On a margin account, repeated buys can exceed 100% of equity.
    Fix: add a hard capital cap independent of the balance, per-symbol and gross limits that include pending orders, and a startup check that the account is a cash account or has a 1x multiplier.

    4. Any error becomes a permanent, silent halt (High).
    Scenario: one HTTP 503 from the broker is caught by except Exception, written to halt.json, and from then on the loop only sleeps. It never retries, and nobody is notified, so the bot can sit idle for days while you believe it's trading.
    Fix: classify errors. Broker 429/5xx errors and timeouts should retry. Only integrity failures, such as an unknown order or a ledger and broker mismatch, should halt. Every halt should send a notification.

    5. No startup reconciliation (Medium). After a crash, existing positions and open orders are never compared with what the bot believes it holds.

    6. No quote freshness or market-hours check (Medium). Limit orders reuse signal.price, which can be stale by the time the order is placed.

    Checklist summary

    SectionPassFail
    A. Single order path23
    B. Size limits06
    D. Order identity05
    E. Restart and recovery04
    F. Halts14
    G. Data and timing04

    Next steps

    1. Fix findings 1 and 2 first, since they're the only ones that can multiply orders.
    2. Add an absolute dollar cap and a halt alert, so you hear about it within minutes if it stops.
    3. Re-run this review, then go live with a small capped amount before scaling up.

    This review covers engineering safety only. It does not judge whether the strategy is profitable and is not investment advice.

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

    About this skill

    Trading bots often fail not because the strategy is wrong, but because the engineering is brittle. A single unhandled 503 error or an ambiguous order submission can wipe out an account regardless of how good your alpha is. This skill provides a rigorous pre-flight safety audit for algorithmic and AI-assisted trading systems before they touch live capital.

    What it does

    • Map money paths by tracing the flow from signal generation and model output to the final broker execution point.
    • Enforce safety limits by auditing per-order, per-symbol, and gross exposure caps that operate independently of strategy logic.
    • Detect execution defects such as duplicate orders, ambiguous submission outcomes, and silent process halts.
    • Audit recovery logic to ensure the bot handles crashes, restarts, and warm-up replays without triggering unintended trades.
    • Verify data integrity by checking for stale quotes, look-ahead bias, and instrument-specific traps like option expiry or settlement rules.

    How it works

    1. Provide your trading bot's source code, strategy logic, and configuration files for analysis.
    2. The agent maps the architecture to ensure exactly one component has the authority to submit orders to the broker.
    3. It executes a comprehensive safety checklist covering exposure, leverage, order identity, and halt taxonomy.
    4. It probes for the "five classic failures," including the ambiguous submit and the replay-that-trades bug.
    5. You receive a severity-ranked findings report with file:line references and a clear Go / No-Go verdict.

    Frameworks & tools

    Works with any algorithmic trading stack including Python (Pandas, Backtrader, CCXT), Node.js, or C++ based systems connecting to brokers via REST or WebSockets.

    Why this beats prompting it yourself

    Generic prompts often focus on code style or strategy theory rather than the low-level edge cases that cause catastrophic loss. This skill follows a specialized audit methodology designed to find "invisible" defects like race conditions during fill polling and unintended leverage expansion.

    Use cases

    • Reviewing a new bot before switching from paper trading to live capital.
    • Auditing a strategy after major changes to the order execution or risk management logic.
    • Verifying an AI-assisted bot to ensure LLM outputs are gated by deterministic safety checks.
    • Performing a post-mortem on a bot that experienced unexpected behavior in production.

    Known limitations

    Does not judge strategy profitability or provide investment advice. Requires access to the full execution and risk management code to be effective.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Trading & Investing.

    Does not evaluate strategy alpha or profitability. Does not provide financial or investment advice. Requires source code for execution logic and risk management modules.

    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

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 20 days ago

    Permissions

    Read Files
    Terminal / Shell

    Read Files: the agent reads your bot's source code to review it. Terminal/Shell: only used to run your bot's existing test suite, if you have one. No network access, no API keys, and no account connections. The skill never places orders or touches your broker.

    Listed20 days ago

    What's inside

    Frequently Asked Questions

    This review focuses on the 'engineering plumbing' of your bot—such as handling API timeouts, preventing duplicate orders, and ensuring risk caps are strictly enforced—rather than testing if your strategy is profitable.

    The review is framework-agnostic: it works with any language your AI agent can read (Python, TypeScript/Node.js, Go, C++ and others) and any broker or exchange, as long as you can provide the source code for the order-execution and risk modules.

    A Markdown report (from the included template): a map of your bot's money path, severity-ranked findings (Critical/High/Medium/Low) each with the file and line, a concrete failure scenario and the smallest fix, a checklist pass/fail summary, and a final GO / GO WITH CONDITIONS / NO-GO verdict.

    Yes. One of the first checks is whether any language-model output can reach the order-submission code without passing through deterministic checks (fixed schemas, value limits, allow-listed symbols). If an LLM's output can place a trade unchecked, that is reported as a Critical finding. It doesn't evaluate the quality of the LLM's trading ideas.

    None beyond installing the skill. Open your bot's project in your AI agent and ask it to review the bot before going live; the agent reads the code itself, maps the money path and runs the checks. No extra software, accounts or API keys are needed.

    The audit requires access to your execution and risk management logic; if your code is split across multiple files, you should provide all relevant files to ensure the agent can trace the full 'money path.'

    New in Trading & Investing