Can You HFT Prediction Markets? We Pointed an Autonomous Agent at Polymarket and Kalshi
Two exchanges price the same World Cup, and their numbers don't match. The gap looks like free money. We dug into whether you can actually high-frequency-arbitrage it — and then ran an autonomous agent on the problem to see what an LLM in the loop is really good for. Spoiler: it's not the microsecond fill.
TL;DR
- 📈 The cross-venue gap is real but tiny: France ~50 bps, Spain ~60 bps — half a cent on a $1 contract.
- ⚡ Only one venue can HFT.Kalshi acks in ~10 ms over FIX; Polymarket settles on-chain in ~2 s. Cross-venue HFT arbitrage is structurally impossible.
- 🧱 Four frictions — two currencies, fees on both legs, the latency gap, and non-identical contracts — eat the spread before you start.
- 🤖 So we ran polyclaw, an autonomous OpenClaw agent. Its edge isn't speed — it's always-on hedge discovery and net-of-cost monitoring.
The dream: free money between two order books
Kalshi and Polymarket list the same World Cup outcomes. France to win trades at ~19.3% on Kalshi and ~19.8% on Polymarket; Spain shows a ~60 bps gap. On a $1 contract that half-cent looks trivial — until you multiply by Kalshi's ~$4.5B of weekly volume. That's when people start whispering “risk-free arbitrage.” So can you actually capture it at speed?
Can you actually HFT prediction markets?
High-frequency arbitrage needs both legs to fire near-instantly. The two venues are built on completely different rails, and that asymmetry is the whole story.
| Kalshi | Polymarket | |
|---|---|---|
| Market data | FIX + WebSocket | REST + WebSocket (Gamma / CLOB) |
| Execution | Native matching engine | Off-chain CLOB + on-chain settlement (Polygon) |
| Round-trip latency | ~10 ms (co-located) | ~2 s on-chain; 10+ s split→CLOB flow |
| Order types | Full (incl. advanced) | Limit only |
| Settlement | USD over bank rails | USDC.e via CTF split/merge on-chain |
| HFT-capable? | ✅ Yes | ❌ No |
Kalshi is a real, CFTC-regulated exchange: a FIX gateway, co-location, ~10 ms round-trips. You can genuinely run latency-sensitive strategies there. Polymarket can't match it by design — orders match off-chain but settle on Polygon, every position needs an on-chain CTF split before the CLOB leg, the CLOB POST endpoint sits behind Cloudflare (so bots eat residential-proxy retry loops), and there are only limit orders. End to end, that's 10+ seconds per trade.
One venue runs in milliseconds, the other in seconds. You can't fire both legs and call it locked — so a true risk-free cross-exchange HFT arb between them is structurally impossible, not just hard.
The four frictions
| Friction | Why it eats the spread |
|---|---|
| Two currencies | Kalshi settles in USD on bank rails; Polymarket in USDC on-chain. You pre-fund both venues and eat the FX/ramp cost. |
| Fees on both legs | Kalshi taker fees + Polymarket spread + Polygon gas. Two legs means paying twice — often more than the 50 bps spread itself. |
| Settlement latency | ~10 ms vs ~2 s is a 200x gap. The mispricing closes before your on-chain leg clears. |
| Non-identical contracts | Kalshi's match-level book vs Polymarket's tournament market aren't always the same instrument. Mismatched resolution turns 'arb' into directional risk. |
Net the half-cent against all four and it's gone. The realistic game isn't risk-free arbitrage — it's latency / statistical arbitrage: spot a transient mispricing, be pre-funded on both sides, and act before it closes, accepting real execution risk.
Reality check.Genuine sub-10ms execution needs co-located servers and direct exchange connectivity — not an AI agent in a container. Anyone selling “risk-free HFT arbitrage” between these two is hand-waving the frictions above. Treat the cross-venue spread as a research signal, not free money. None of this is financial advice.
The experiment: an autonomous agent on the problem
If milliseconds are off the table, what is an agent good for here? We ran polyclaw, a trading-enabled Polymarket skill for OpenClaw — the same agent runtime BrainClaw is built on. The stack is deliberately boring: a Chainstack Polygon node for RPC, an OpenRouter LLM for analysis, and the Polymarket CLOB for execution.
It does four things, none of which is HFT:
| Capability | How it works |
|---|---|
| Browse markets | Pulls trending/searched markets and live prices via the Gamma API. |
| Trade | Split + CLOB: split $100 USDC.e → 100 YES + 100 NO, sell the unwanted side (~$0.30) to recover ~$27, net ~$73 for 100 YES. |
| Track positions | Local P&L tracking against live prices. |
| Discover hedges | LLM contrapositive logic finds covering portfolios — only logically necessary implications, graded into coverage tiers (T1 95%+, T2 90–95%, T3 85–90%). |
That last one is the interesting part. Instead of racing for a fill, the agent reads pairs of markets and asks: does “X wins” logically imply “Y loses”? If so, YES-on-X + NO-on-Y is a covering portfolio. It rejects correlations and “likely” relationships — only necessary implications count. That's analysis, running on a slow, patient clock the on-chain rails can actually support.
What an always-on agent is actually for
This is the real lesson, and it's the opposite of the HFT fantasy. The edge an agent gives you on prediction markets isn't the last-millisecond fill — it's the tedious, always-on work no human sits there to do: stream both books 24/7, normalize them into one probability space, track the spread net of every cost, and flag the rare moment something's actually worth a human look. A microsecond engine needs a data center. A research agent needs a cron job.
Prompting a chatbot when you remember to is not automation. The leverage is an agent that watches the books while you sleep and only pings you when the math survives the costs.
Run it yourself
The code for the Polymarket agent in the video is open source. Links below — the companion piece has all the charts and raw data.
- polyclaw — trading-enabled Polymarket skill for OpenClaw
- Chainstack tutorial — building a Polymarket trading OpenClaw skill
- polymarket-alpha-bot — standalone CLI version
- Companion data deep-dive: Polymarket vs Kalshi, World Cup odds & the arbitrage question
MegaBrain Gateway
500+ models. One API. No markup.
Use in Claude Code, Cline, Cursor, or any coding agent.
Newsletter
Stay in the loop
Get the latest model comparisons and guides — no spam, unsubscribe anytime.