← Strategies

New strategy from Settlement projection

A copy of Settlement projection. Change what you like; the original stays as it is. The code on the right is read only until you press Customise.

Settings

Id lowercase, digits, underscores Name

Markets

Bitcoin price up down · every 15 minutes KXBTC15M

Pick the markets this strategy watches. Repeating markets (every 15 minutes, hourly, daily) are listed first; one-off events need a Kalshi key to look up and are not where a bot shines.

Description Rule kind Parameters one key = value per line; text in quotes, numbers and true/false as they are Acts from (s before close) Until (s before close) Min price (¢) Max price (¢) Contracts Order life (s) Max open Cooldown (s)

favourite: Buy the favourite: rest a bid on whichever side the market already favours. Parameter: `min_favourite_cents` (default 80): the favourite's ask must sit between it and the gate's maximum price. We rest one tick above its best bid. The lab's finding: this wins about nine times in ten and still loses, because the price already says so.

longshot: Long shot: rest a bid on the side priced at or below `max_price_cents` (a few cents). Pays about $1 when it hits. The lab's finding (Sam's first week): the hits are real and rare; a run of misses costs more than a hit pays.

momentum: Chase the jump: when the mid moves by `jump_cents` or more within `window_seconds`, rest a bid on the side it moved toward. The lab's finding: Kalshi had already repriced about 4.3c within a quarter of a second of a Bitcoin jump. Chasing paid the new price and the fee.

fade: Fade the spike: when the mid jumps by `spike_cents` or more within `lookback_seconds`, bet it comes back. The lab's finding (paper, honest fills): lost on all 12 coins tried. Spikes on Kalshi mostly carried real information.

near_certain: The 99c contract: rest a bid on a side whose ask is at least `min_ask_cents` (97 to 99) late in the window. Pays a cent or two most of the time and loses nearly everything the rest. The lab's forward test asks whether the rare loss comes often enough to eat the pennies.

maker_ladder: Maker ladder (JZL style): rest a bid one tick above the favourite's bid when the favourite's ask sits in a band. Parameters: `band_min` and `band_max` (default 55 to 92), the favourite's ask range. One rung per market in this version. The lab's finding: the only family that finished ahead with real money (+$51.27 over 1,459 fills at 1 to 2 lots); it failed its own bar when sized to 4 lots.

follow_size: Follow the big trade: after a print of at least `min_trade_usd`, rest a bid on the side the big trader took. Parameters: `min_trade_usd` (default 1000) and `window_seconds` (default 60): the big print must be at most this old. The lab's finding (1,855 trades of $1,000+, about $4 million): the big money lost 4.9%, and copying it 0.25 s, 2 s or 10 s later lost the same 2.92c a contract. Set a cooldown on the strategy so one print is not followed twice.

projection: Settlement projection: trade the arithmetic, not the chart. For Kalshi's 15 minute crypto markets. These markets do not settle on the price at the close. They settle on the simple average of a CF Benchmarks index (BRTI for Bitcoin) over the final 60 seconds. With s seconds left, 60 - s seconds of that average are already known, so projection = (average so far x (60 - s) + latest value x s) / 60. Compare the projection with the line, not the price.

Cancel

Rule code

built-in, read only

This is the code the selected rule kind runs. Press Customise to make it this strategy's own rule and edit it here. Nothing in a rule can place a real order.

"""Settlement projection: trade the arithmetic, not the chart. For Kalshi's 15 minute crypto markets.

These markets do not settle on the price at the close. They settle on the simple average of a CF Benchmarks index
(BRTI for Bitcoin) over the final 60 seconds. With s seconds left, 60 - s seconds of that average are already known, so
projection = (average so far x (60 - s) + latest value x s) / 60. Compare the projection with the line, not the price.

Parameters: `min_distance_usd` (default 10): the projection must sit at least this far from the line, in dollars of
index price, before the rule acts; `max_price_cents` (default: the gate's maximum): never pay more than this for the side
the projection favours. The gate's time window sets when it acts (the lab's public measurement: at 50 seconds left the
projection is no better than the spot price; at 10 seconds it misses the final value by about 47 cents against about 4
dollars for spot, over 635 real settlements). The lab's own live rule in this family runs with settings that are held;
this kind ships with neutral defaults for you to set yourself.
"""
from __future__ import annotations


def _target(ctx):
    """(side the projection favours, distance in dollars) or (None, distance) when it is too close to call."""
    proj = ctx.projection()
    if proj is None or ctx.strike is None:
        return None, None
    dist = proj - ctx.strike
    need = float(ctx.params.get("min_distance_usd", 10))
    if dist >= need:
        return "yes", dist
    if dist <= -need:
        return "no", dist
    return None, dist


def decide(ctx):
    from ping.rules import Decision
    side, dist = _target(ctx)
    if not side:
        return None
    cap = int(ctx.params.get("max_price_cents", ctx.gate_max_price))
    ask = ctx.yes_ask if side == "yes" else ctx.no_ask
    if ask <= 0 or ask >= 100 or ask > cap:
        return None
    px = ctx.rest_price(side)
    return Decision(side, px, {"projection": round(ctx.projection(), 2), "strike": ctx.strike, "distance_usd": round(dist, 2)}) if px else None


def describe(ctx) -> str:
    from . import asks
    proj = ctx.projection()
    if ctx.strike is None:
        return "this market has no line to project against"
    if proj is None:
        return f"waiting for the settlement index ({ctx.index_id or 'unknown index'}) to arrive"
    need = float(ctx.params.get("min_distance_usd", 10))
    dist = proj - ctx.strike
    where = f"projection ${proj:,.2f} vs line ${ctx.strike:,.2f} ({'+' if dist >= 0 else '-'}${abs(dist):,.2f})"
    if abs(dist) < need:
        return f"{where}: too close to call, needs ${need:,.0f} either way; {asks(ctx)}"
    side = "yes" if dist > 0 else "no"
    cap = int(ctx.params.get("max_price_cents", ctx.gate_max_price))
    return f"{where}: favours {side.upper()}; {asks(ctx)}; will pay up to {cap} cents"

Ask your AI

add a key in Settings

Describe the strategy. Your request, the Kalshi facts file, the strategy format and the rule contract go straight from this computer to your own provider. If a built-in rule fits, the answer fills the settings; if not, it also writes the rule's code into the box above for you to read. Nothing runs until you save and press Run on paper.

The honest part

Every strategy starts on paper with the same fill rule as the lab: a fill only counts when a real trade prints at or through your price. Run it long enough to see fills, then compare "through" with "at price". The gap is what a backtest hides.

New strategy from Settlement projection

Settings

Rule code

Ask your AI

The lab tested this shape

The honest part