Kalshi Weather Markets logo

Kalshi Weather Markets

Community
agiprolabs
kalshi-weather-markets

Daily temperature high/low bracket and threshold contracts on Kalshi — contract structure, forecast→P(YES) map, settlement rules, cross-venue divergences, and weather-specific pitfalls

Overview

Publisheragiprolabs
Repositoryclaude-trading-skills
Skill namekalshi-weather-markets
Stars
434
Forks
85
Bundled files
3
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 3 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by agiprolabs on GitHub. Read the source before you install it.

Installation

Install the Kalshi Weather Markets AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/agiprolabs/claude-trading-skills/tree/main/skills/kalshi-weather-markets
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/agiprolabs/claude-trading-skills.git /tmp/claude-trading-skills
mkdir -p .claude/skills
cp -r /tmp/claude-trading-skills/skills/kalshi-weather-markets .claude/skills/kalshi-weather-markets
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Kalshi Weather Markets in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Kalshi Weather Markets on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Kalshi Weather Markets is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Kalshi Weather Markets — Daily Temperature High/Low

Kalshi lists daily high and low temperature options for ~20 US cities as binary contracts that settle YES ($1.00) or NO ($0.00). This skill covers the market structure, the forecast-to-probability map, exact settlement mechanics, and hard-won pitfalls. It builds on the exchange layer — for Kalshi API mechanics (host, auth, orders, order book, candlesticks) see the kalshi-api skill; for strategy, sizing, and backtesting see prediction-market-strategy.

Contract Types

Brackets — B<center>

A bracket ticker B<center> is a 2°F-wide, both-ends-inclusive window.

  • B74.5 covers the two integers {74, 75}°F.
  • YES iff the settled temperature is exactly 74 or 75.
  • Brackets in one event are mutually exclusive and (with two open tail markets) collectively exhaustive.
  • Their YES prices sum to the overround (fair = 1.0; > 1.0 = aggregate overpricing).

Thresholds — T<strike>

A threshold ticker T<strike> is a one-sided binary.

  • greater → YES iff cli >= strike + 1
  • less → YES iff cli <= strike - 1
  • Critical: strike_type ("greater" / "less") is not inferable from the ticker. Read it from the API strike_type field every time.

Ticker Format

KXHIGH<CITY>-<YYMONDD>-B<center>     # bracket high
KXLOW<CITY>-<YYMONDD>-T<strike>      # threshold low

The date is encoded in the ticker, not derivable from close_time.
KXHIGHNY-26JUN21 settles 2026-06-21 LST. close_time is next-day UTC (~00:59 ET). Joining on close_time off-by-ones every label — use the ticker date.


Forecast → P(YES)

Given a forecast distribution N(μ, σ) for the day's extreme, apply the half-integer continuity correction (mandatory — settlement is on integers, not a continuous scale):

# Bracket B<center>, covering integers {floor, cap}
P(YES) = Φ((cap + 0.5 − μ) / σ) − Φ((floor − 0.5 − μ) / σ)

# Threshold "greater":
P(YES) = 1 − Φ((T + 0.5 − μ) / σ)

# Threshold "less":
P(YES) =     Φ((T − 0.5 − μ) / σ)

Φ(x) = 0.5 · (1 + erf(x / √2))   # stdlib only, no scipy needed

The ±0.5 shift is not optional. Dropping it biases every bracket. Treating 2°F brackets as 1°F half-open windows produced a +1640% phantom backtest in one project.

See scripts/weather_brackets.py for runnable implementations of all four functions.


Deriving (μ, σ) from Ensemble Quantiles

sigma_raw = max((p90 − p10) / 2.56, 0.5) · sigma_scale · sigma_mult
mu        = p50                          # or nowcast-blended (see forecasting.md)
sigma     = max(sigma_raw, 0.1)          # hard floor against degeneracy

The 2.56 divisor is the 10th–90th percentile span of a standard normal (2 × 1.28σ).


CLI-Space Bias Correction

The settlement value (NWS CLI integer °F, LST day) is not the same as raw ASOS/METAR hourly max/min — CLI applies QC, backup-station fallback, and LST aggregation. Shift μ before computing P(YES):

mu_cli = mu_metar + bias_city_season     # bias = oracle_extreme − asos_extreme, fit per city + season

Fit bias_max / bias_min as seasonal (circular) curves per city. Skipping this systematically misprices every bracket for cities with a structural CLI/METAR gap.


Settlement Rules

Kalshi

  • Source: NWS Climatological Report (CLI) — the official daily climate summary issued by each WFO.
  • Fallback: IEM ASOS daily download matches CLI 100% and is available programmatically.
  • Window: LST (Local Standard Time), no DST adjustment. The day runs midnight-to-midnight LST year-round.
  • Value: Integer °F maximum (HIGH) or minimum (LOW) temperature for that LST day.
  • Bracket: YES iff cli ∈ {floor, cap} (both ends inclusive).
  • Threshold greater: YES iff cli >= strike + 1.
  • Threshold less: YES iff cli <= strike - 1.

Settlement-Source References

Read each market's own rulebook before scoring or trading. Settlement source, station, and day-window are per-market contract terms that can change.

ResourceURL
Kalshi market rules / Rulebookhttps://docs.kalshi.com (per-market "Rulebook")
NWS Climatological Report (CLI)https://www.weather.gov/wrh/Climate
IEM ASOS daily downloadhttps://mesonet.agron.iastate.edu/request/daily.phtml
Polymarket resolution (WU)https://www.wunderground.com
Polymarket disputes (UMA)https://docs.uma.xyz

Cross-Venue Divergence

The same metro on the same date can settle to different values across venues — both because of the station and the DST window in spring/fall.

AxisKalshiPolymarket
SourceNWS CLI / IEM ASOSWeather Underground
Day windowLST (no DST)Local clock (with DST)
NYC stationKNYC (Central Park)KLGA (LaGuardia)
RoundingInteger °F, t ∈ {floor, cap}Per WU history

Any cross-venue analysis must settle each leg on its own source.


Nowcast Blending (Same-Day Path)

Once an intraday observation is available, pull μ toward reality and shrink σ:

  • HIGH: clamp μ to [obs, obs + drift · hours_remaining]
  • LOW: clamp μ to [obs − drift · hours_remaining, obs]
  • σ shrinks as sigma_raw · sqrt(hours_remaining / 24), floored at sigma_floor (≈ 0.5)
  • drift ≈ 3.0°F/hr default

Optional NWP prior blend: new_p50 = w · hrrr + (1−w) · p50 (w ≈ 0.5), then rebuild symmetric quantiles using a calibrated σ.


Calibrated Model Performance (Reference Numbers)

Per-city OOS Brier scores across 22 highs + 22 lows (v1.5, 2026-06-17 baseline):

MetricRange
Per-city OOS Brier0.07 – 0.14 (lower = better; 0.25 = climatology)
Per-city accuracy65–85% (bracket classification)

Forecast skill ≠ trading edge. A calibrated model that beats climatology by 0.05 Brier does not guarantee positive EV at market prices — the market already incorporates NWP. The practical edge is maker-side fading of mispriced longshot brackets (favorite–longshot bias), not raw directional forecasting.


Weather Pitfalls

  1. Wrong settlement source. Scoring against a derived truth that correlates with but differs from the venue's resolution flips ~10% of outcomes. Settle on the venue's own result.

  2. Bracket off-by-one (phantom +1640%). Treating 2°F inclusive brackets {floor, cap} as 1°F half-open [floor, cap) manufactures a large phantom backtest edge. The bracket is both-ends-inclusive.

  3. strike_type not inferable from ticker. T74 on a low market might be greater or less. Always read strike_type from the API. Never guess.

  4. Date-in-ticker, not close_time. Use the date embedded in the ticker string for settlement-date joins, not close_time (which is next-day UTC).

  5. LST ≠ local clock. Kalshi settles on LST (no DST). In spring/fall, the LST window shifts relative to local time. Cross-referencing WU (which uses local clock) against CLI on DST-transition days will produce mismatches.

  6. CLI ≠ METAR. Raw ASOS hourly max/min is not the settlement value. CLI applies QC, backup-station fallback, and LST aggregation. Fit per-city seasonal bias corrections before computing P(YES).

  7. UTC vs local-day feature aggregation. Aggregating forecast features over UTC days instead of LST days misaligns labels — cost ~14 percentage points of accuracy in one study.

  8. Clock-mismatch look-ahead. Filling at an 18:00Z book snapshot while features are cut at 14:00 LST trades non-Eastern cities on future information. Use each city's own local decision time.

  9. Phantom penny asks. 1¢ ask levels are frequently spoofed; assuming you fill them over-credits PnL ~23×. Count only depth that persists across snapshots and is corroborated by trade prints.

  10. Overround as a diagnostic. Sum the YES prices across an event's full bracket set. overround > 1.0 is normal (house edge); overround >> 1.1 signals a mispriced event (or data error).


Files

References

  • references/brackets-and-settlement.md — Bracket/threshold structure, P(YES) formulas, settlement rules, cross-venue divergence table, overround
  • references/forecasting.md — Ensemble quantiles → (μ, σ), nowcast blending, CLI-space bias correction, model skill numbers, forecast ≠ edge

Scripts

  • scripts/weather_brackets.py — Gaussian bracket/threshold P(YES), settlement resolution, and quantile→(μ,σ) functions (pure stdlib, runs offline)

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Kalshi Weather Markets AI skill do?

Daily temperature high/low bracket and threshold contracts on Kalshi — contract structure, forecast→P(YES) map, settlement rules, cross-venue divergences, and weather-specific pitfalls

Why use Kalshi Weather Markets on TypingMind?

Because you install it once and use it with any model. Kalshi Weather Markets is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Kalshi Weather Markets in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/agiprolabs/claude-trading-skills/tree/main/skills/kalshi-weather-markets. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Kalshi Weather Markets?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Kalshi Weather Markets?

As many as you like. As long as a model supports skills, you can use Kalshi Weather Markets with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Kalshi Weather Markets AI skill free?

Yes. It is published on GitHub by agiprolabs under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇