Kalshi Trade

Kalshi Agentic Trading Playbook

You (Claude) are at the helm of a real, live Kalshi account. Your edge over a mechanical bot is judgment: you can research whether an event will actually happen and form a calibrated true-probability estimate. Use it. Be disciplined, measure everything, and only deploy capital on real edge.

Run every command from the repo root: PYTHONPATH=. .venv/bin/python cli.py <cmd>. The standing mission and account facts live in the mission-autonomous-trading memory — read it if you lack context.

The loop (run every tick)

1. ASSESS — cli.py brief. Read governor (halted? day P&L? drawdown?), equity, cash, positions, resting orders. If governor.halted is true: place NO new buys (you may still close/exit). Note anything that settled since last tick.
2. SURFACE EDGE — cli.py daily (dry-run, no --live) prints the mechanical "near-certain NO, YES≤0.20, model-edge≥3¢" slice. On efficient days that's only un-tradeable 96¢ buckets, so also cast a wider net: scripts/hunt_candidates.py scans the FULL open universe (via the events API — /markets only returns KXMVE parlays) and buckets candidates into genuine longshot-NO fades and contested directional markets, enriched with LIVE orderbook prices. Both are raw material, not a buy list.
3. RESEARCH — for the best 1–3 candidates, estimate the TRUE probability the NO side wins. Use real reasoning + WebSearch for current facts (sports results, event status, prices). This step is the whole point — it's where you beat the mechanical filter. Be skeptical: "edge" on hyper-efficient markets (crypto/BTC price buckets, major indices) is almost always illusory.
4. DECIDE — trade a candidate only if ALL hold:
   • NO-side on a genuine longshot-YES market (favorite-longshot bias — longshots are chronically overpriced, so the NO is underpriced — is the real, documented edge).
   • Your researched true_no_prob beats the NO ask by a fee-aware margin: edge = true_no_prob − no_ask ≥ 0.05 (covers ~1¢ fee + safety). Use YOUR number, not the market's.
   • Category is plausibly inefficient (sports, niche events, obscure outcomes) — not efficient.
   • It clears the governor and the position cap.
   • It clears the Edge Policy gate. Run cli.py policy — the data-driven gate your OWN settled record earns. If your candidate's category is BLOCKED (your record proves it loses money) or its est_prob lands in a HAIRCUT band (you're overconfident there), respect it: cli.py trade will refuse a blocked category. Override only with a genuinely stronger, freshly-researched reason via --override-policy (it's recorded). The gate only ever tightens from your evidence — it encodes exactly the losing buckets below, automatically.
   • It passes the adversarial-verify gate. Before any live buy, run cli.py verify --ticker T — it researches the catalyst + true-YES, runs a SKEPTIC that tries to REFUTE the fade, then a deterministic gate recomputes the edge in points and returns BUY_NO/PASS with a size hint. Trade only on BUY_NO; treat PASS as a hard stop (it fired because the fade didn't survive, edge < 5pts, a positive/live catalyst, or an election frontrunner). Use its size_hint (full only for genuine sub-5% longshots) to size down. If no LLM API key is available, do the research + skeptic YOURSELF (with live web search), write the judgments to a JSON file, and run cli.py verify --ticker T --research-file f.json — the deterministic gate still recomputes the edge off the live book, so it stays a hard gate.
5. EXECUTE — cli.py trade --live --ticker T --side no --count N --price 0.NN --est-prob P --rationale "why" --category C. The tool re-checks the governor, caps size (≤10% equity, ≤cash), places a resting maker limit by default (low fees), and journals your prediction. Omit --live first to preview.
6. JOURNAL — automatic on every trade. Records est_prob, edge, rationale.
7. LEARN — run cli.py learnings (the integrated learn step). It joins live settlements back into the decision journal (filling each trade's outcome), prints the calibration table (predicted vs actual win-rate by est_prob bucket — am I overconfident?) and per-category/side realized edge on YOUR trades, and appends new candidate learnings to data/runtime/learnings.jsonl. Review those candidates: confirm the real ones into this SKILL + memory, and concentrate future trading on categories where YOUR realized edge is positive; stop trading categories that lose. (cli.py settle/history remain for raw P&L.)
8. IMPROVE — run cli.py improve to close the loop: it re-derives the Edge Policy from the whole settled record and persists it as the active pre-trade gate (data/runtime/edge_policy.json), printing the diff of what the newest settlements changed. From the next tick on, DECIDE's policy check enforces it — the losing buckets you just measured are auto-blocked. This is how the system self-improves without you hand-editing rules each tick.
9. REPORT — summarize trades, reasoning, and the equity delta. Then continue the loop.

Data-fed families: tools, sources, and standing verdicts (2026-09-26)

Mechanical, data-resolvable families get priced from their resolution source, not from vibes. Before ANY trade in these families, run the family's tool and read data/aaa/alerts/ADJUDICATIONS.md — the standing verdicts live there.

Every pricing run writes a snapshot under data/aaa/pricings/ (and Ornn ladder pricings) that aaa_pricer.py score / jev_score.py forward-score against the realized print. Never add size to a family before its scored sample shows the model beating the book.