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%

An illustrative momentum score could be calculated as:

Momentum =
    0.25 × Return10s
  + 0.35 × Return30s
  + 0.40 × Return60s

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%

while the best available UP ask is:

UP ask = $0.58

The estimated edge is therefore:

Edge = Model Probability - Market Price
     = 0.71 - 0.58
     = 0.13

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.

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

The execution engine can then use configurable thresholds:

Edge > entry threshold
    → Continue buying

Edge falling
    → Reduce order size

Edge <= stop threshold
    → Stop execution

For example:

Edge > 10%       → aggressive slices
5% < Edge <= 10% → smaller slices
0% < Edge <= 5%  → minimal execution
Edge <= 0%       → stop

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

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()

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

Dynamic TWAP behaves more like:

Signal strong
    ↓
Buy
    ↓
Recalculate
    ↓
Signal strong
    ↓
Buy
    ↓
Recalculate
    ↓
Edge weakening
    ↓
Reduce size
    ↓
Edge disappears
    ↓
STOP

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

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:

💬 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