I run a Polymarket crash-recovery bot. As of today, it has placed 308 closed trades at an 80.2% win rate. The bot is open source. The 308-trade dataset is open source. The audit tools that prove the numbers are open source. Every claim in this post is verifiable.
This isn't "I built a trading bot, here's a screenshot." This is the full data, the open code, and the honest lessons.
The numbers, with no spin
| Metric | Value |
|---|---|
| Closed trades | 308 |
| Profitable | 247 (80.2%) |
| Date range | March 2026 – April 2026 |
| Median hold time | ~3 hours |
| Average drop_pct at entry | ~22% (from recent local high) |
| Average recovery to | ~85% of pre-crash high |
| Theoretical lifetime P&L | +$33.49 |
| Actual on-chain P&L | -$89.01 |
| Hidden slippage cost | -$122.50 |
Yes — that last number is real. Despite an 80.2% WR, the bot's actual on-chain P&L is negative because of slippage. The DB said +$33; the chain said -$89. I open-sourced the audit tool that surfaced this gap as part of today's release: pnl-truthteller. More on that below.
The bot is profitable on average per-trade entry, but the exit-ladder strategy walked thin order books down on TIMEOUT exits, and that ate the alpha. This is the kind of finding that only shows up when you compare your bot's records against on-chain reality. Most operators never do.
What the bot does
The bot enters Polymarket binary or multi-outcome markets when three conditions hit simultaneously:
- The price has dropped > 20% from a recent local-window high (the "crash" signal).
- The current price is in a sweet-spot range (originally $0.04–$0.30; raised to $0.04–$0.60 today after a backtest showed the wider range had 81.8% WR on a recent slice).
- The orderbook has enough bid-stack depth to absorb the position size within a slippage budget.
It enters at $5 per trade. No leverage. No exotic positioning. Single Polygon proxy wallet, all USDC.
The exit logic is where the alpha gets compressed:
- RECOVERY (235 of 308 trades): price climbs back to ~90% of pre-crash high, sells. Profitable.
- TIMEOUT_48H (62 trades): held 48 hours without recovery. Sells at whatever the bid stack offers. Sometimes profitable, often a small loss.
- TIMEOUT (11 trades): older, shorter-window timeout from earlier in the dataset. Same logic, less generous.
That's it. The bot is ~500 lines of Python. The "edge" is in the trigger filter, not in clever execution.
The edge: why crashes mean-revert on Polymarket
Prediction markets have a structural property that doesn't show up in equity markets: the resolution probability is the price.
When a Polymarket binary contract trades at $0.20, the market is saying "20% chance YES." When it crashes from $0.40 to $0.20 in a few hours due to a news event, two things are usually true:
- The fundamental probability (whatever the actual likelihood is) didn't change by 50%. News events overcorrect.
- Liquidity is asymmetric — there are short-term sellers panicking out, but no equally-fast buyers stepping in. Bid stacks thin out.
The bot's job is to step in as the buyer when both happen. Most of the time, the price recovers within a few hours as cooler sellers reassess. That's a 2-3% win on a $5 position when it works.
I trained a logistic regression and a random forest on the dataset to see if I could predict is_profitable from the available features. Result: ~79.9% cross-validated accuracy on the simple model, basically matching the bot's actual WR. Translation: most of the alpha is in the trigger filter itself, not in feature engineering on top.
The dataset, the loader, and the baseline notebook are at: github.com/LuciferForge/cross-signal-data (pip install cross-signal-data).
What 308 trades teaches you that backtesting doesn't
Lesson 1: Slippage is bigger than you model
I built backtests assuming midpoint fills. Real exits on thin Polymarket books are 3–8% worse than midpoint. Across 302 closed trades, that compounded into the -$122.50 hidden cost noted above.
Detection: build the audit tool first. The bot kept a live_trades.db SQLite logging the raw response from every CLOB POST. The audit replays each closed trade against the chain's actual fills (deduplicated by orderID, because sweep retries log the same fill twice). The math is straightforward; the surprise is how big the gap is.
pip install pnl-truthteller
pnl-truthteller --wallet 0xYourProxyAddress
Read-only, no API key needed. Outputs a Markdown report with by-exit-reason breakdown, worst-10 trades, and dust shares stranded on-chain.
Lesson 2: Category concentration kills you
Three losing streaks in the dataset all came from the same market category in the same time window. Sports markets where the team had already lost the underlying game continued to trade with bid offers from people who hadn't yet updated. Easy to spot in retrospect; harder to filter automatically.
Today's release adds a tiered category blacklist with persistence — markets in losing categories get a 7-day cooldown after a TIMEOUT exit. Whether this moves the WR is a question for the next 30 trades.
Lesson 3: The bid-stack changes faster than your poll interval
A market that looks liquid at signal time can be thin by the time your limit order needs to fill. The fix is a buy-preflight check: before entering, verify the bid stack has at least 5 × shares_needed of capacity within your slippage budget. Skip if not.
Ship this from day one. We didn't, and learned the hard way.
Lesson 4: Per-token loss cooldown
If a specific token already cost you money via TIMEOUT, don't re-enter it for 7 days. Sounds obvious. Wasn't enforced for the first 200 trades. Some markets just have stuck consensus and will eat every entry attempt for the same reason every time. Moving on is cheaper than persistence.
The infrastructure underneath
Five tools shipped today, all built around the bot's actual operational lifecycle:
- polymarket-crash-bot — the bot itself. 308 trades. Open source.
- polymarket-mcp-pro — Polymarket data as MCP tools. Lets Claude/Cursor query live markets natively.
- pnl-truthteller — fill-level P&L audit. Read-only, wallet address only.
- quant-rollout — staged rollout toolkit. Gates, kill switch, veto window. Pure stdlib, zero deps.
- cross-signal-data — the 308-trade labeled dataset. CSV + Python loader + baseline notebook.
- sigil-ta — MCP-native TA runtime. 8 indicators + 2 composite signals + Polymarket Sentiment Divergence.
All MIT. All have tests. All have public CI-ready repos. If they save you a few hours, star them.
The bot also went through Polymarket's V1 → V2 migration today. That has its own writeup with a working code diff and a 12-error troubleshooting guide: polymarket-v2-migration.
The honest accounting
I would be lying if I said the bot is currently a money-making machine. It's break-even-ish in theoretical terms and slightly down once slippage is included. What it IS, with confidence:
- A live, public-audited mean-reversion strategy on prediction markets
- A credible 80.2% trigger-level alpha on a real (not backtest) sample
- A complete data + tooling stack that lets anyone replicate and improve on it
- A textbook case of why "I made money in backtest" ≠ "I made money on-chain"
The reason I ship it open source is because the real value is in the data and the tooling, not in the entry logic. The entry logic is 500 lines anyone can read. The 308-trade labeled dataset and the slippage audit tool are what took months to produce.
If you can do better than 80% on this dataset by adding features the bot doesn't currently log (orderbook depth at entry, market category metadata from gamma-api, time-to-resolution), you've found something worth more than my entry trigger. Go do it.
Resources
- Bot source: github.com/LuciferForge/polymarket-crash-bot
-
Dataset (free, MIT):
pip install cross-signal-data— github · HuggingFace -
Slippage audit:
pip install pnl-truthteller— github -
TA runtime:
pip install sigil-ta— github -
Polymarket data MCP:
pip install polymarket-mcp-pro— github - Free Polymarket data API: api.protodex.io
If you build something with the dataset, send me the link. If you find a feature that pushes the model past 80%, send me the diff. The bot's edge is mine until someone finds a better one — and at that point, I want to know what you found.
LuciferForge is a solo operator running a public-audited Polymarket trading bot. Also runs protodex.io (5,800+ MCP servers indexed) and the free Polymarket data API.
Top comments (0)