DEV Community

Benjamin-Cup
Benjamin-Cup

Posted on

Building a Dynamic TWAP Momentum Strategy for Polymarket

#polymarket #trading #strategy #bot

Short-duration prediction markets can move faster than the prediction-market order book itself.

For crypto markets, BTC often moves first while the Polymarket book takes a few seconds to reflect the change. This creates a temporary pricing opportunity: if an external momentum model estimates that the probability of an outcome is higher than its current market price, a trading bot can gradually enter the position.

The challenge is execution.

A traditional TWAP strategy continues buying according to a fixed schedule, regardless of whether the original trading edge still exists.

A dynamic TWAP strategy takes a different approach:

Execute gradually while the edge remains positive. Stop immediately when the edge disappears.

How Dynamic TWAP Works

The strategy combines three components:

  1. External BTC momentum
  2. A probability model
  3. Adaptive TWAP execution

The bot continuously compares its estimated probability with the current Polymarket price.

For example, suppose a 5-minute BTC market opens with:

  • BTC reference price: $100,000
  • UP price: $0.48
  • DOWN price: $0.52

Thirty to sixty seconds later, BTC starts trending upward.

The momentum model observes:

10-second return:  +0.05%
30-second return:  +0.11%
60-second return:  +0.18%
Enter fullscreen mode Exit fullscreen mode

An illustrative momentum score could be calculated as:

Momentum =
    0.25 × Return10s
  + 0.35 × Return30s
  + 0.40 × Return60s
Enter fullscreen mode Exit fullscreen mode

This produces a positive momentum signal, which can then be normalized into the model's internal scoring range.

Suppose the resulting model estimates:

P(UP) ≈ 71%
Enter fullscreen mode Exit fullscreen mode

while the best available UP ask is:

UP ask = $0.58
Enter fullscreen mode Exit fullscreen mode

The estimated edge is therefore:

Edge = Model Probability - Market Price
     = 0.71 - 0.58
     = 0.13
Enter fullscreen mode Exit fullscreen mode

That's a 13 percentage-point theoretical edge.

The bot can now begin execution.

Dynamic TWAP Instead of Fixed TWAP

Assume the target position is 600 UP shares.

A traditional TWAP might simply divide the order into fixed slices and continue executing until the full quantity is purchased.

Dynamic TWAP continuously reevaluates the trade.

Slice Momentum UP Price Model P(UP) Edge Action
1 +0.68 $0.58 71% +13 pts Buy 50
2 +0.66 $0.59 70% +11 pts Buy 50
3 +0.55 $0.61 66% +5 pts Buy 50
4 +0.39 $0.64 60% -4 pts Stop
5 +0.18 $0.67 55% -12 pts Do nothing

The bot only accumulates 150 shares before stopping.

The remaining 450 shares are never purchased.

This is the key difference between fixed and dynamic execution.

A mechanical TWAP is primarily concerned with completing the order.

A dynamic TWAP is concerned with preserving the trading edge.

The Edge Is the Control Signal

The most important part of the strategy is not the TWAP interval.

It is the edge calculation.

Conceptually:

Edge = Model Probability - Market Price
Enter fullscreen mode Exit fullscreen mode

The execution engine can then use configurable thresholds:

Edge > entry threshold
    → Continue buying

Edge falling
    → Reduce order size

Edge <= stop threshold
    → Stop execution
Enter fullscreen mode Exit fullscreen mode

For example:

Edge > 10%       → aggressive slices
5% < Edge <= 10% → smaller slices
0% < Edge <= 5%  → minimal execution
Edge <= 0%       → stop
Enter fullscreen mode Exit fullscreen mode

These values are illustrative. In a production system, the thresholds should be determined through backtesting and live execution data.

Why This Matters in Short-Duration Markets

Short-duration crypto prediction markets are highly sensitive to timing.

The underlying asset can move significantly while the prediction-market price is still adjusting.

But the opposite can also happen.

The market can catch up quickly.

When that happens, the original edge disappears.

If the execution algorithm continues buying simply because the TWAP schedule says it should, it can transform a profitable signal into a poor entry.

Dynamic execution solves this by separating two decisions:

Signal generation
        ↓
Is there still an edge?
        ↓
Execution decision
        ↓
Execute another slice
        ↓
Recalculate
Enter fullscreen mode Exit fullscreen mode

The bot does not assume that an initial signal remains valid throughout the entire order.

A Simple Execution Loop

A simplified implementation could look like this:

while remaining_size > 0:

    momentum = calculate_momentum()
    model_probability = estimate_probability(momentum)

    market_price = get_best_ask()

    edge = model_probability - market_price

    if edge <= STOP_EDGE:
        break

    if edge > HIGH_EDGE:
        slice_size = LARGE_SLICE
    elif edge > MEDIUM_EDGE:
        slice_size = SMALL_SLICE
    else:
        slice_size = MIN_SLICE

    place_limit_order(
        side="UP",
        size=min(slice_size, remaining_size),
        price=market_price
    )

    wait_for_next_recalculation()
Enter fullscreen mode Exit fullscreen mode

The important design principle is that execution size is conditional on the current signal.

The bot is not blindly following a clock.

It is following the relationship between:

  • market price
  • model probability
  • momentum
  • remaining time
  • execution cost

Dynamic TWAP Is Not Just "TWAP With Smaller Orders"

The important distinction is that the schedule itself is adaptive.

A conventional TWAP might behave like:

Time →  Buy → Buy → Buy → Buy → Buy
Enter fullscreen mode Exit fullscreen mode

Dynamic TWAP behaves more like:

Signal strong
    ↓
Buy
    ↓
Recalculate
    ↓
Signal strong
    ↓
Buy
    ↓
Recalculate
    ↓
Edge weakening
    ↓
Reduce size
    ↓
Edge disappears
    ↓
STOP
Enter fullscreen mode Exit fullscreen mode

This makes the strategy much more suitable for markets where the underlying asset and prediction-market price can temporarily diverge.

Practical Considerations

A production implementation should account for more than momentum.

Useful inputs can include:

  • BTC spot returns across multiple windows
  • BTC volatility
  • Polymarket order-book imbalance
  • distance from the market strike
  • time remaining
  • current spread
  • available liquidity
  • estimated execution cost
  • current position
  • recent fill rate

The probability model should also be calibrated rather than assuming that a momentum score directly represents a probability.

For example:

Momentum
   +
Volatility
   +
Order Book
   +
Strike Distance
   +
Time Remaining
        ↓
Probability Model
        ↓
Estimated P(UP)
        ↓
Market Price Comparison
        ↓
Dynamic TWAP
Enter fullscreen mode Exit fullscreen mode

Final Takeaway

The biggest lesson is simple:

TWAP should be an execution framework, not a commitment to finish an order.

If the market edge remains, continue executing.

If the edge weakens, reduce exposure.

If the edge disappears, stop.

In the example above, the target was 600 shares, but the strategy only bought 150 because the model no longer justified the remaining exposure.

That is the fundamental advantage of Dynamic TWAP Momentum: the bot adapts its execution to the market instead of forcing the market to fit a predetermined execution schedule.

For short-duration prediction markets, that distinction can be critical.

🤝 Collaboration & Contact
If you’re interested in building trading bots, buy trading bots, collaborating, exploring strategy improvements, or discussing about this system, feel free to reach out.

I’m especially open to connecting with:

Quant traders
Engineers building trading infrastructure
Researchers in prediction markets
Investors interested in market inefficiencies

📌 GitHub Repository
This repo has some Polymarket several bots in this system.
You can explore the full implementation, strategy logic, and ongoing updates about 5 min crypto market here:

GitHub logo Benjam1nCup / Polymarket-trading-bot-python-V2

polymarket trading bot polymarket bot polymarket twap bot polymarket arbitrage bot polymarket trading bot polymarket bot polymarket twap bot polymarket arbitrage bot polymarket trading bot polymarket bot polymarket twap bot polymarket arbitrage bot polymarket trading bot polymarket bot polymarket twap bot polymarket arbitrage bot polymarket bot

Polymarket Trading Bot | Polymarket Arbitrage Bot | Polymarket TWAP Trading Bot

An open-source and Strong Strategy collection of Polymarket trading bot and Polymarket arbitrage bot and Polymarket TWAP trading bot in Python for high-performance automated trading on polymarket crypto 5min and 15min markets.

Polymarket-benjamincup-bot-dashboard

This repository is primarily intended for educational and research purposes. It includes strategy concepts, implementation approaches, and selected performance screenshots to help developers understand how different automated trading strategies can be designed and tested.

The repository does not provide a complete production-ready trading bot source code. Instead, it provides strategy descriptions and research materials that you can use as a foundation for developing your own system.

If you are interested in building a Polymarket Trading Bot, you can follow my tutorials and use the concepts in this repository to develop your own implementation.

For users who prefer a ready-to-deploy solution or require custom strategy development, commercial…


View on GitHub


💬 Get in Touch

If you have ideas, questions, or would like to collaborate or want these trading bots, don’t hesitate to reach out directly.
Feedback on your repo (based on your description & strategy)

Contact Info
Telegram
https://t.me/BenjaminCup

tags: polymarket,trading,bot,architecture,tutorial,TWAP

Top comments (0)