How It Works

BetterBot is an AI-powered prediction engine that analyzes sporting events and takes positions on Kalshi, a CFTC-regulated designated contract market. The system operates a fully automated daily pipeline: it discovers upcoming events, gathers research from dozens of sources, runs a structured multi-phase analysis, takes calibrated positions, and commits the entire result on-chain.

The analysis pipeline executes no more than 48 hours before an event's scheduled start time. For most events, predictions are generated same-day. The pipeline follows a fixed sequence:

1. Event Discovery — Upcoming events are ingested from multiple data sources including official league APIs, Highlightly, and ESPN. The system identifies all scheduled events that don't yet have predictions.
2. Research Gathering — For each event, the system generates sport-specific search queries and fetches articles from across the web.
3. Statistical Injection — Historical performance data, calibration offsets, and league-level base rates are computed and injected as context.
4. LLM Inference — A structured multi-phase analysis is executed against the gathered research and statistics.
5. Calibration — Raw predictions are adjusted based on historical calibration data and uncertainty factors.
6. Execution — Qualifying forecasts are sized and the positions are opened on Kalshi.

Each sport has a unique analytical archetype that governs how predictions are structured. Archetypes encode domain knowledge about what matters most in each sport: which factors carry the most predictive weight, what base rates to expect, and how much parity exists in the league.

For example, basketball archetypes emphasize talent gaps and pace/efficiency matchups with a 60% historical home-win rate. Ice hockey archetypes account for extreme parity (home ice advantage is only ~52%) and prioritize possession metrics, goaltender form, and back-to-back scheduling penalties. Baseball archetypes lead with starting pitcher matchups, which account for 20-30% of outcome variance, while soccer archetypes must handle three-outcome markets where draws occur 15-20% of the time.

Beyond sport-level defaults, individual leagues can have their own overrides. These capture regional factors, competition-specific rules, and cultural context that affects prediction accuracy.

Before any prediction is made, the system pre-gathers research for each event. This is a multi-phase process designed to surface the most relevant, high-quality information available.

The system generates 10-16 sport-specific search queries per event, covering injury reports, expert previews, head-to-head history, recent scheduling, and archetype-specific factors. Queries are executed across multiple search backends including Google, Brave, Yahoo, Yandex, Mojeek, and Wikipedia. URLs are deduplicated and full article text is extracted.

Sources are enforced by tier. Tier 1 sources (official statistics, verified box scores) and Tier 2 sources (expert analysis from ESPN, The Athletic, and similar outlets) are prioritized. Prediction market prices, bookmaker lines and betting commentary are explicitly excluded from the research corpus to prevent circular reasoning.

Statistical data is injected separately from article research. This includes league-wide historical averages, team-level recent performance metrics, head-to-head records, and calibration bin offsets computed from the system's own prediction history.

Every prediction follows a mandatory structured analytical framework with ten distinct phases. The framework is designed to enforce disciplined reasoning, prevent common cognitive biases, and produce calibrated probability estimates.

Raw probability outputs from the prediction framework are adjusted through two mechanisms: uncertainty penalties and calibration offsets.

Uncertainty penalties reduce confidence when the evidence base is weak. The system tracks specific uncertainty signals — unconfirmed injuries, low source quality, contradictions between findings, and missing data — and applies sport-specific penalty schedules. For example, an unconfirmed starting pitcher in baseball adds a larger penalty than in basketball, where no single player carries as much outcome variance.

Calibration offsets are computed from the system's own prediction history. Predictions are bucketed by probability range (e.g., 60-65%, 65-70%), and the observed accuracy in each bin is compared to the predicted probability. If the system historically forecasts 70% but is right only 62% of the time in that range, a negative offset is applied to future predictions in the same bin. This self-correcting mechanism ensures long-term calibration.

After events settle, every incorrect prediction is run through an automated error analysis pipeline. The system categorizes the primary error source — whether the miss was due to insufficient data, a key injury not captured, an incorrect weighting of factors, or genuine unpredictability.

Error categories are tracked by league and over time, producing a diagnostic profile of where the system is weakest. These findings feed back into the calibration system: if a particular type of error recurs in a league, future predictions in that league receive adjusted uncertainty penalties. The goal is continuous improvement — every loss teaches the system something about its own blind spots.

The system uses a reinforcement learning layer to continuously refine its probability estimates beyond what static calibration can achieve. This works through an A/B testing framework: each prediction is deterministically assigned to either a treatment or control group using a stable hash of the event.

The treatment group receives a policy-selected probability adjustment (a small positive or negative shift), while the control group uses the baseline calibrated output. Over time, the system compares outcomes between the two groups to learn which adjustments improve accuracy. Successful adjustments are reinforced; unsuccessful ones are discarded.

This creates a feedback loop where the system's own track record drives incremental improvements. The adjustments are small and conservative — the RL layer fine-tunes rather than overrides the core prediction framework.

Position sizing determines which forecasts receive capital and how much. It operates through a series of gates and formulas designed to allocate capital proportionally to estimated edge while managing downside risk. No position is placed without passing every gate.

Every slate is committed on-chain before any orders are placed. Each forecast is serialized into a canonical JSON preimage and hashed with SHA-256; the day's hashes are combined into a single Merkle root, and that root is posted to Solana in one memo transaction. Because the commitment is one root, the whole slate fits in one transaction regardless of how many positions the bot intends to open.

Nothing about the slate is published while it is running — not the preimages, not the hashes, not which events are in it. A slate is released only once every event in it has resolved, and it is released whole: the root is the root of every leaf, so a verifier handed a subset could not rebuild it.

Anyone can then recompute each SHA-256 hash from the published preimage, rebuild the Merkle root from those hashes, and compare it to the root on chain — confirming no forecast was altered after the fact. The block timestamp is public from the moment the root lands, so the commitment can be checked to predate the games it describes. Commitments currently anchor to Solana devnet.

The two models behind the forecasts are documented in full, with their architecture, validation protocol and the published literature they rest on. Both are permanently archived and citable.