How to Clone and Configure a Marketplace Strategy

Cloning a marketplace strategy is the fastest way to go from reading someone else's code to running your own configured version against a live order book. But a clone you never inspect is just borrowed conviction. This walks the cloner path end to end: pull a published strategy, set its parameters through the surfaced form fields, paper-trade the result, then promote it to live with a risk envelope you actually control.

The context matters. Prediction market volume has grown sharply through 2026, and automation follows liquidity. Combined monthly global trading volume on Kalshi and Polymarket rose from under $5 billion in September 2025 to about $24 billion in April 2026, according to a Pew Research Center analysis of data from The Block. More liquidity means tighter books and more room for systematic strategies that would have starved a year ago.

Step 1: Pick a clone and read the code first

A published Banger strategy is a Python file that subclasses banger.Strategy. When you clone one, you get the actual source, not a black box. Read it before anything else. You are looking for three things: what signal fires an order, what the strategy assumes about the market it trades, and which numbers are hard-coded versus exposed as parameters.

Pay attention to venue assumptions. A strategy tuned for Kalshi's sports contracts behaves nothing like one built for Polymarket politics markets, and the two platforms specialize differently. According to the same Pew analysis, sports has made up 80% of total trading volume on Kalshi and 39% on Polymarket since July 2024. A clone that assumes deep sports liquidity will underperform if you point it at a thin market.

Step 2: Configure through the surfaced form fields

Banger reads a strategy's typed parameters and surfaces them as form fields. You do not edit source to reconfigure a clone. Anything the author declared as a parameter, with a type and a default, becomes an editable field with validation. This is the difference between forking code and configuring a product.

Here is what a parameterized strategy declaration looks like, so you know what maps to which field:

import banger

class MeanReversion(banger.Strategy):
    # These become form fields at clone time.
    market_id: str                 # which contract to trade
    entry_edge: float = 0.04       # min mispricing to act on
    max_position: int = 200        # contracts per side
    exit_after_hours: float = 48.0 # force-close window

    def on_book(self, book):
        fair = self.estimate_fair(book)
        if book.best_ask < fair - self.entry_edge:
            self.buy(self.market_id, size=self.max_position)

When you clone MeanReversion, you get four fields. Change market_id to the contract you want, tighten or widen entry_edge to match the current book, and size max_position to your bankroll rather than the author's. The defaults are a starting point, not gospel. An edge that worked on a market averaging heavy daily turnover can evaporate on a quiet one.

• Retarget the market. The original author's market_id is theirs, not yours. Point it at a contract you understand.
• Rescale position size. Set max_position against your own capital and the market's depth, not the cloned default.
• Sanity-check thresholds. If entry_edge is 4 cents on a market whose spread is routinely wider, the strategy will rarely fire. Widen it or pick a different market.
• Note what is NOT a field. Hard-coded logic in on_book is fixed unless you fork and edit the source directly.

Step 3: Paper-trade the clone against the live book

Never promote a fresh clone straight to live. Paper trading runs your configured strategy against the real, current order book without sending real orders. You see how often it fires, what it would have filled at, and whether your entry_edge is realistic against actual spreads.

pip install bangertrades
banger run strategy.py --paper

Let it run across a full market cycle, not ten minutes. A strategy that looks profitable during a volatile window can be flat or negative once liquidity thins out. This is also where you catch configuration mistakes that pass type validation but make no economic sense, like a position size larger than the resting depth on the book.

Watch fill assumptions closely. Paper trading against a live book tells you whether your orders would realistically clear. If the clone assumes it can move 200 contracts at the touch and the book only shows 40, your paper results are fiction and your live results will be worse.

Step 4: Promote to live with a risk envelope

Once the paper run behaves, you promote the clone by attaching a declarative risk envelope. This is separate from strategy logic on purpose. The strategy decides what to trade; the envelope decides how much damage it can do when it is wrong. Set a per-trade cap, a daily loss stop, a maximum number of open positions, and a kill switch. These are enforced by the runtime, not by the cloned code, so a bug in the author's logic cannot blow past your limits.

Banger never custodies funds. You bring your own venue keys, and the runtime places orders through them under the envelope you set. That means the clone runs against your own Kalshi or Polymarket account, and your risk limits sit between the strategy and your balance.

Configure, paper-trade, envelope, promote. Skip any of those and you are trusting a stranger's defaults with your capital.