I built a Directional Arbitrage Bot for Polymarket crypto markets in Rust — here's the architecture

Harrier — Wed, 24 Jun 2026 15:30:13 +0000

Hey everyone,

Sharing a new bot I've been building — it's a directional arbitrage bot for binary prediction markets (BTC/ETH/SOL Up/Down on Polymarket). Written in Rust for the latency requirements this strategy demands.

The core idea

Pure arbitrage on prediction markets is straightforward — if Up + Down < $1, you buy both and lock in the difference. Safe, but the upside is capped at the spread.

This bot starts from that arbitrage structure but adds a directional tilt. If the model identifies that one side has additional edge beyond the arb, it skews the position — buying more of the stronger side and less of the hedge side. The result is:

Arbitrage base = structural protection
Directional tilt = additional EV when the model has conviction

Why this matters in short crypto markets

BTC/ETH/SOL 5-15 minute markets on Polymarket are interesting because the underlying asset can move sharply while Polymarket's CLOB reprices one side with a delay. That lag is the exploitable window. By the time the order book catches up, a pure arb bot has already exited. A directional bot can hold the stronger side through the reprice and capture the full move.

Architecture (Rust)

rust// Core position structure
struct Position {
    arb_base: f64,      // guaranteed arb fill on both sides
    directional_tilt: f64,  // extra exposure on favored side
    hedge_ratio: f64,   // partial hedge on weaker side
    edge_threshold: f64, // minimum model edge to tilt
}

Key design decisions:

Limit orders only — never market orders. Paying the spread kills the arb base immediately
Tilt gated by edge threshold — the model has to show meaningful conviction before skewing the position. No tilt = pure arb fallback
Hedge ratio is dynamic — scales down as directional confidence increases, never goes to zero
Rust for execution — async order management with Tokio, minimal GC pauses, deterministic latency on the quoting loop

Position logic flow

1. Scan CLOB for Up + Down < $1 (arb opportunity exists)
2. Run edge model on both sides
3. If edge delta > threshold → tilt toward stronger side
4. Place limit orders: full size on strong side, hedge_ratio on weak side
5. Monitor fill state and adjust tilt if market moves before fill

The hedge means a wrong directional call doesn't blow up the position — it just reduces the arb profit. The floor is always the arb spread minus fees.

Current limitations

Edge model is still rule-based — pattern recognition on price movement sequences. Not ML yet
Liquidity on some markets is thin enough that the tilt size is constrained by available depth
Correlated markets (BTC and ETH moving together) need net exposure tracking across both, not per-market limits

Why Rust

Polymarket's CLOB API has enough latency variance that the quoting loop needs to be tight. Rust gives deterministic async performance without the GC pauses you'd get in Node or JVM. The order state machine is also complex enough that Rust's ownership model catches a lot of bugs at compile time that would be runtime errors elsewhere.

GitHub: https://github.com/HarrierOnChain/Prediction-Markets-Trading-Bot-Toolkits

Happy to discuss the edge model, position sizing logic, or the Rust async architecture. Also curious if anyone has solved the correlated market exposure problem cleanly.

I built an open-source market maker for prediction markets (Polymarket/CLOB) — here's how it works

Harrier — Fri, 19 Jun 2026 15:16:29 +0000

Hey everyone,

I've been deep in prediction market infrastructure for a while and just open-sourced a market maker bot designed for CLOB-based prediction markets like Polymarket.

What it does:

Quotes both sides of a binary market automatically
Adjusts spreads based on order book depth and volatility
Manages inventory risk to avoid getting stuck on the wrong side of a resolved market
Built on top of Polymarket's CLOB API with Gnosis Safe / EOA wallet support on Polygon

The core challenge with prediction markets vs. regular markets:

Normal market making is about capturing spread. Prediction markets add a brutal edge case — resolution risk. If you're holding YES at 0.6 and the market resolves NO, you're not just down on the spread, you're down the full position. So the bot has to:

Track time-to-resolution and widen spreads as resolution approaches
Reduce inventory exposure on markets with high directional momentum
Use FAK orders to avoid resting limit orders too long near resolution

Stack:

Rust
Polymarket CLOB API
Polygon (USDC settlement)
SQLite for order state tracking

What's next:

Dynamic spread model based on implied volatility
Multi-market portfolio rebalancing
Better signal integration (news feeds, oracle data)

GitHub: https://github.com/HarrierOnChain/Prediction-Markets-Trading-Bot-Toolkits

Happy to answer questions on the architecture, risk model, or anything CLOB-related. Always looking for feedback from others building in this space.

DEV Community: Harrier

I built a Directional Arbitrage Bot for Polymarket crypto markets in Rust — here's the architecture

I built an open-source market maker for prediction markets (Polymarket/CLOB) — here's how it works