- Home
- Skills
- Trading & Investing
- Trading Bot Go-Live Review
More screenshots
Works with the AI Agents you already use
Trading Bot Go-Live Review
A pre-flight safety audit for any trading bot before it touches real money.
$19
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
- Signals:
strategy.signals()(bot.py:29) - Sizing:
position_size()(risk.py:6) - Risk gate: none. No check runs between sizing and submission.
- Broker submit:
broker.submit_order()(bot.py:33). This is the only submitter, which is good. - Fill ingestion: none. Positions are never read back.
Findings
| # | Severity | Finding | Location |
|---|---|---|---|
| 1 | Critical | A timeout is retried as a new order | bot.py:31-36 |
| 2 | Critical | The same signal can buy again every cycle | bot.py:29-33 |
| 3 | High | Size grows with equity, with no absolute cap or exposure limit | risk.py:3, 7 |
| 4 | High | Any error becomes a permanent, silent halt | bot.py:24-26, 37-38 |
| 5 | Medium | No startup reconciliation of orders and positions | bot.py:22-28 |
| 6 | Medium | Orders are priced from the signal price, with no quote freshness or market-hours check | bot.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
| Section | Pass | Fail |
|---|---|---|
| A. Single order path | 2 | 3 |
| B. Size limits | 0 | 6 |
| D. Order identity | 0 | 5 |
| E. Restart and recovery | 0 | 4 |
| F. Halts | 1 | 4 |
| G. Data and timing | 0 | 4 |
Next steps
- Fix findings 1 and 2 first, since they're the only ones that can multiply orders.
- Add an absolute dollar cap and a halt alert, so you hear about it within minutes if it stops.
- 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
- Provide your trading bot's source code, strategy logic, and configuration files for analysis.
- The agent maps the architecture to ensure exactly one component has the authority to submit orders to the broker.
- It executes a comprehensive safety checklist covering exposure, leverage, order identity, and halt taxonomy.
- It probes for the "five classic failures," including the ambiguous submit and the replay-that-trades bug.
- 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.
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
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 20 days ago
Permissions
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.