Prediction Pilot is an AI copilot for Kalshi. You ask questions; it reads live markets, your positions, and the open web, then renders the answer as an inline card with the numbers cited. Below is the actual mechanic — what data goes in, what the AI does with it, and what the output looks like.
Every Prediction Pilot turn follows the same pattern. You type a question. The AI reads the question and decides which tools to call. Each tool fetches a specific piece of data — current Kalshi prices, your open positions, a weather forecast, Polymarket's price for the same event. The tool returns structured data; the AI synthesizes it into a one-paragraph read and renders the underlying data as a card.
The key design choice: the cards are the answer; the AI's prose is just a one-sentence read on top. When you ask "is BTC at 92¢ NO a good bet?", you get a card showing the current price, volume, your existing position (if any), the predicted EV, a letter-grade verdict (A through F), and concrete reasons to pass (thin book, inverted Polymarket gap, similar markets that underperformed). The AI's text is just the bridge sentence: "B — solid edge at 92¢ NO, +$0.08 EV per contract calibrated to 327 settlements."
What this means in practice: you never have to take the AI's word for anything. The numbers are right there. If the verdict disagrees with the numbers, you can see the disagreement.
Kalshi and Polymarket list many of the same events: the same NBA game winner, the same Bitcoin price level on the same date, the same election outcome. When the prices diverge by more than the combined fees + spreads, there's an arbitrage opportunity — you buy the cheap side on one platform and sell (or buy the opposite contract) on the other, locking in profit regardless of how the event resolves.
Prediction Pilot's arbitrage scanner runs continuously across both platforms. It pulls Kalshi's order book and Polymarket's Gamma API, matches markets by event identity (not just title), and surfaces any pair with a price gap of 5¢ or more after accounting for both sides' fees. You can ask "show me arbitrage gaps over 5¢" in chat and get the live list as a card.
Every Kalshi market has a YES side and a NO side. The YES contract pays $1 if the event happens; the NO contract pays $1 if it doesn't. The two prices always sum to $1 — so NO at 88¢ is equivalent to YES at 12¢. The market is implying an 88% probability that the event won't occur.
The favorite-longshot bias says these high-probability NO contracts are systematically underpriced. Empirically, an 88¢ NO contract pays off ~91% of the time — three percentage points higher than the price implies, which after fees nets out to a 1.5-2.4% edge per trade. That's the foundation of the most common Prediction Pilot strategy: scan for NO contracts in the 88-95¢ band that meet your liquidity + spread thresholds, place a small position, and let the math run.
The risk: NO at 88¢ means you put up 88¢ to win 12¢. One loss costs you ~7 wins. The strategy only works if your selection process actually surfaces 88¢ NOs that win ≥89% of the time. That's why Prediction Pilot exposes its accuracy scoreboard publicly — you can verify the AI's hit rate against ground truth before trusting its picks.
Read the full favorite-longshot strategy guide for the math + academic citations.
A backtest answers "if I had run this strategy for the last N days, how would I have done?" Prediction Pilot's backtester uses settled-market data + hourly candles to simulate trade entries and exits, then reports the total P&L, win rate, and per-trade detail.
You backtest by asking. Examples that work:
The result lands as a card with the trade count, win rate, P&L, equity curve, and a "Save as strategy" button. Iteration is fast — tighten one filter, re-run, compare. The harder you push on the filters, the smaller the resulting trade count gets; the sweet spot is usually 20-100 trades over 30-90 days, which is enough to gauge signal without overfitting.
Once you connect a Kalshi API key, Prediction Pilot tracks your positions in the background. The dashboard summarizes today's P&L, the week, and category-level exposure. You can ask "how are my positions doing?" and get a one-paragraph read with the deltas that matter (the one that's moved 6¢ against you, the one approaching stop-loss).
Strategies you save become persistent watches. Each saved strategy scans for matching markets on a cadence you pick (every 5 minutes, hourly, daily) and notifies you when matches fire. You can also save price alerts ("notify me when BTC closes above $100k on Kalshi") and forecast-divergence alerts ("notify me when the NWS forecast disagrees with the market by 4°F or more").
The morning briefing is opt-in: a once-a-day summary of your overnight position changes, settlements, and any alerts that fired. It's never automated execution — you read it, decide what to do, and tap to act.
Good at: reading order books and translating them into plain English, comparing prices across platforms, surfacing pass-signals on bad trades, summarizing settlement rules ("this market settles on the NWS Boston-airport reading, not your home thermometer"), backtesting a strategy and noticing when it overfits, calibrating its own predictions against ground truth.
Bad at: predicting outcomes in domains with regime change (the "this AI knows the next election winner" trap — it doesn't), reasoning about events with no historical precedent, distinguishing between two markets with near-identical titles but different settlement rules. We flag those with explicit pass-signals when we can detect them.
The mechanics above generalize — but each Kalshi market category has its own quirks (settlement rules, typical edge size, liquidity profile). Per-category guides:
That's how it works. Try it on your own market.
Get started — 100k free credits