← Strategies

New strategy from Sam's first week

A copy of Sam's first week. 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.

"""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.
"""
from __future__ import annotations


def decide(ctx):
    from ping.rules import Decision
    cap = int(ctx.params.get("max_price_cents", 5))
    if 1 < ctx.yes_ask <= cap:
        side = "yes"
    elif 1 < ctx.no_ask <= cap:
        side = "no"
    else:
        return None
    px = ctx.rest_price(side)
    return Decision(side, px, {"ask": ctx.yes_ask if side == "yes" else ctx.no_ask}) if px else None


def describe(ctx) -> str:
    """What this rule is waiting for right now, in plain words (shown in the interface)."""
    from . import asks
    hi = int(ctx.params.get("max_price_cents", ctx.gate_max_price))
    return f"waiting for a side asking {hi} cents or less; {asks(ctx)} now"

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 Sam's first week

Settings

Rule code

Ask your AI

The lab tested this shape

The honest part