Position Sizing for Prediction-Market Bots: Beyond Full Kelly

A prediction-market contract resolves to 1 or 0. You buy YES at 60 cents, and the outcome either pays a dollar or pays nothing. That all-or-nothing structure is exactly the setting the Kelly criterion was built for, and exactly the setting where full Kelly will wreck a bot that trusts its own edge estimate too much. This post covers how to size binary bets, why you should run a fraction of Kelly, how to separate account-level caps from per-strategy caps, and how to make those limits bind on every order instead of living in a spreadsheet.

Kelly on a binary payoff

For a bet that either wins or loses your stake, the discrete Kelly formula is the right one to use: f* = (bp - q) / b, where p is your win probability, q is 1 minus p, and b is the net odds. A prediction-market price maps straight to b: buying YES at 0.60 to win 1.00 is net odds of about 0.67 to 1.

The formula has a built-in discipline you should respect. A negative Kelly output means the bet is negative expected value. Do not take it. The formula will never recommend wagering on a losing proposition. If your model says the fair price is below the ask, the math tells you to pass or take the other side, not to shave your size.

The Kelly fraction maximizes one specific thing: the long-term geometric growth rate by determining the optimal bet size as a fraction of bankroll. It does not minimize drawdown, and it assumes you know your edge. On prediction markets you rarely do.

Why full Kelly is too aggressive here

Three problems compound on binary, all-or-nothing markets.

First, variance. Under full Kelly, Thorp's continuous approximation gives a clean result: the probability your bankroll ever falls to a fraction x of its current level is x. That means a roughly 50% chance of experiencing a 50% drawdown at some point during any extended betting sequence. That is true even when the edge is real. Even with a real, verified edge, you should expect to lose half your bankroll at some point before recovering. Most humans cannot psychologically handle that, and the emotional response is almost always to abandon the strategy, which locks in the loss permanently. A bot does not panic, but the operator watching it does, and the operator owns the kill switch.

Second, estimation error. Kelly is only as good as p, and on a resolving event your p is a model output, not a known constant. If you think you have a 60% edge but actually have 50%, Kelly will suggest betting twice what you should, dramatically increasing ruin risk. Overbetting is not a small mistake. Betting twice the Kelly amount results in zero expected growth over time, and going beyond that, you are guaranteed to drain your bankroll no matter how good your edge is.

Third, the frictionless model lies a little. While theoretical Kelly has zero risk of ruin because you are always betting a fraction, real-world constraints change the math. Minimum bet sizes, discrete bet amounts, and correlated bets mean actual risk of ruin is higher than the frictionless model suggests.

Fractional Kelly: the default, not the exception

The standard fix is to bet a fraction of what the formula says. Full Kelly and fractional Kelly use the same formula. The difference comes from how much of the recommended stake you actually bet: full Kelly means betting 100% of the recommendation, half Kelly means 50%, quarter Kelly means 25%. Most serious operators live in that lower range. Most professionals use something between 1/4 Kelly and 1/2 Kelly.

The trade is favorable. Half Kelly captures about 75% of the growth rate while cutting variance by roughly 75%. The tradeoff is almost always worth taking. You give up a slice of theoretical growth and buy a much smoother equity curve plus a margin of safety against a wrong p. There is also a clean interpretation for prediction-market traders specifically: lambda-fractional Kelly is precisely equivalent to full Kelly with a revised belief that is a weighted average of your original belief and the market's belief. Betting quarter Kelly is the same as trusting the order book three parts out of four. For a bot trading against a liquid market, that humility is usually correct.

Practical defaults for a binary-market bot:

• Compute the discrete Kelly fraction per contract from your model p and the live price.
• Multiply by 0.25 to 0.5. Start lower until paper trading confirms your p is calibrated.
• If Kelly is zero or negative, do not trade. Size is not a knob to override a no-edge signal.
• Cap any single position regardless of what Kelly returns, so one mispriced p cannot blow a hole in the book.

Account-level caps vs per-strategy caps

Fractional Kelly sizes one bet. It does not manage a book of bets, and it assumes independence that prediction markets routinely violate. Kelly does not account for correlated bets without modification. Multiple election contracts, multiple rate-decision contracts, and multiple legs on the same event are not independent. A naive fix is to split exposure across concurrent positions: when betting multiple markets simultaneously, divide each Kelly percentage by the number of concurrent bets to avoid overexposure.

That is why per-bet sizing is necessary but not sufficient. You want two layers:

• Per-strategy caps: a max stake per trade and a max number of open positions for that one strategy, plus a daily loss stop that halts the strategy when it bleeds past a threshold.
• Account-level caps: a ceiling on total capital at risk across every strategy and venue at once, because a 25% Kelly bet from each of four strategies on correlated events is not a 25% Kelly bet, it is closer to full Kelly on the underlying.
• A global kill switch that flattens or freezes everything, independent of any single strategy's logic.

The account-level layer is the one that protects you from the failure Kelly cannot see: many small, individually reasonable bets that are secretly the same bet.

Making the caps bind on every order

A sizing rule you have to remember to apply is a sizing rule you will eventually forget at 2 a.m. during a fast market. The point of a runtime is that the envelope is enforced before any order reaches the venue, not advised after. In Banger, you write the sizing logic in the strategy and declare the risk envelope separately, so the per-trade cap, daily loss stop, max open positions, and kill switch apply to every order your code emits regardless of what the strategy intended.

import banger

class FadeLongshots(banger.Strategy):
    def on_book(self, book):
        p = self.model_prob(book.market)      # your edge estimate
        price = book.best_ask("YES")
        b = (1 - price) / price                # net odds from price
        kelly = p - (1 - p) / b                # discrete Kelly
        if kelly <= 0:
            return                             # no edge, no trade
        frac = 0.25 * kelly                    # quarter Kelly
        self.buy("YES", fraction=frac)

# risk envelope is declarative and enforced on every order:
#   per_trade_cap, daily_loss_stop, max_open_positions, kill_switch
# banger run strategy.py --paper

Run it with the --paper flag first. Paper trading against the live order book is where you find out whether your p is calibrated before a real fill proves it is not. Once the realized win rate lines up with your model on enough resolved markets, you have earned the right to raise the Kelly fraction. Not before.

The short version

Binary prediction-market payoffs are textbook Kelly territory, which is exactly why full Kelly is dangerous: it sizes for an edge you only think you have, and it accepts drawdowns no operator will sit through. Use the discrete formula, run a quarter to a half of it, refuse zero-edge bets outright, and stack a per-strategy cap under an account-level cap to catch the correlation Kelly ignores. Then put those limits somewhere they cannot be skipped, so the worst trade your bot can place is one you already decided to survive.