How this thing works
A dashboard for finding moments when the price of a Ethereum bet on Kalshi looks too cheap (or too expensive) compared to a simple statistical estimate of fair value. It points out the disagreement — you decide whether to act on it.
First, what's the bet?
Kalshi sells contracts that look like this:
If yes → the contract pays $1.
If no → it pays $0.
You can buy these contracts (called "YES") any time before the deadline. People also buy and sell them while the hour is running, so the price moves around like a stock. The price floats between 1¢ and 99¢, and you can read that price as a probability: a YES contract trading at 70¢ means the market collectively thinks there's roughly a 70% chance that contract pays out.
Kalshi runs about 190 of these contracts every hour, one per strike — $80,000, $80,100, $80,200, and so on. Each row of the table is one contract.
YES vs. NO — same coin, two sides
Every contract has two sides. If a YES contract costs 70¢, the matching NO contract costs about 30¢ (they have to add up to ~$1, since exactly one of them will win).
- Buy Yes 70¢ → win $1 if ETH closes above the strike. Net profit: 30¢.
- Buy No 30¢ → win $1 if ETH closes at or below the strike. Net profit: 70¢.
Buying NO is exactly the same bet as betting against YES. Different label, same trade.
What does this dashboard add?
Kalshi already shows you what the market thinks the chance is — that's just the YES price. This dashboard does one extra thing: it computes its own estimate of the probability and puts it next to the market's number. When the two disagree by a lot, that's a signal worth investigating.
If the market is selling YES for 50¢ but our model thinks it's worth 56¢, we're saying:
That 6¢ gap is the edge column.
How does the model decide?
It only uses three ingredients:
- How jumpy has ETH been recently? We look at the last hour of one-minute price data and measure how big the wiggles have been. Bigger wiggles → bigger possible future moves. (You'll see this in the header as σ, pronounced "sigma" — that's the formal name. Don't worry about the symbol, just think "jumpiness, in percent per year.")
- How much time is left? More time = more chances to drift away from the current price. A $500 move is unlikely in 30 seconds, plausible in 30 minutes.
- How far is the strike from where ETH is right now? A strike $200 below the current price is much easier to clear than one $500 above.
Combine those three and you get a probability for each strike — basically, "given that ETH has been wiggling this much, and there's this much time left, what fraction of plausible paths land above the line?" Multiply that probability by $1 and you have the model's idea of fair value.
That's it. There's no AI, no chart-pattern recognition, no news scraping. Just recent price wiggle + time + distance, fed through a textbook formula that mathematicians have been using on stocks since the 1970s.
The big thing the model doesn't know
The model is direction-agnostic. It assumes the next move is equally likely up or down — it only has a view on how big moves can be, not which way. That's deliberate: making no directional guess is hard to overfit and easy to reason about.
But it's also where the model is wrong: if ETH is in a clear, sustained trend, the market knows and the model doesn't. So if you see all the strikes above the current price flagging "Buy YES" and all the strikes below flagging "Buy NO," that's almost always not real edge — it's the market correctly pricing in a trend that our model is ignoring.
Reading the columns
| Column | What it means |
|---|---|
| Strike | The line in the sand for this row. $80,000 or above means the bet is "ETH closes above $80,000." |
| Chance | What the market collectively thinks the chance is, as a percent. Same number Kalshi shows under "Chance". |
| Model | What our model thinks the chance is. This is the column Kalshi doesn't show you — it's the whole point of this page. |
| Yes | Yes 70¢ — what you'd pay right now to buy a YES contract. |
| No | No 30¢ — what you'd pay right now to buy a NO contract. |
| Edge | The gap between Model and Market, in cents. Green = model thinks YES is too cheap; red = too expensive. |
| Action | What we'd do if we acted on this row right now: Buy YES +6.2¢, Buy NO +4.1¢, or just — if the gap is too small to bother. |
| Size | How many contracts are sitting at the current bid + ask. Below ~100 is thin — there might not be much volume to trade against. |
| Ticker | The full Kalshi ID for this contract. Copy this to find the same market on Kalshi. |
The header at the top
| Field | What it tells you |
|---|---|
| Big ETH price | The current Ethereum price (from Coinbase). Updates every second or two. |
| Ethereum price today at 6pm EDT | Which hourly bet you're looking at. Each hour has its own contracts. Matches Kalshi's market title verbatim. |
| σ (60M, ann.) | How jumpy ETH has been in the last 60 minutes, expressed as an annualized percent. Below 25%: ETH is calm; the model's signals are mostly noise. Above 50%: ETH is moving; signals are more meaningful. |
| Time to close | Minutes:seconds until trading halts for this hour and the contracts settle. |
| Edge threshold | The minimum disagreement we need before we flag a row. |
| Last poll | How fresh the data is. Goes yellow if it's been more than 90 seconds (something might be stuck). |
The filter buttons
- All — show every strike (~190).
- ITM — strikes below the current price. YES is currently winning on these.
- ATM ±$500 — strikes near the current price. The most active region.
- OTM — strikes above the current price. YES is currently losing on these.
- Flagged — only rows where the disagreement is big enough to act on. If this number is 0, there's nothing to do right now.
When the model actually works (and when it doesn't)
This is the most important section. Same edge number, totally different reliability depending on conditions:
- ETH has been moving a lot in the last hour (σ above ~50% in the header)
- The strike is well away from the current price (more than ~$300 in either direction)
- The YES price is cheap (under ~30¢)
- There's still 15+ minutes until close
- ETH has been quiet (σ below ~25%)
- The strike is right at the current price (within ~$50)
- There are only a few minutes until close
- ETH is in a clear directional trend
The workflow
- Open this page next to Kalshi (the actual betting site).
- Click Flagged. If the number is 0, nothing to do — close the tab and come back later.
- If something's flagged, ask:
- Is ETH moving (σ above ~50%)? Is the strike well away from spot? Is YES cheap? Is there 15+ minutes to go? If yes to all four, this is a real signal.
- Has the same edge been flagging for more than two refreshes? Brief flickers are usually bid/ask jitter, not edge.
- Is there decent Size behind the price (more than ~100)? If only 5 contracts are sitting there, you can't really trade it.
- If you decide it's real: copy the Ticker from the right column → paste into Kalshi search → place the order on Kalshi by hand. This dashboard never places trades for you.
Things that look like edge but aren't
- Strikes way out at the edges — when the model says "0.001% chance" but Kalshi can't quote below 1¢, the apparent "+0.5¢ edge" is a rounding artifact.
- Symmetric bias around spot — every strike below the price flagging Buy NO and every strike above flagging Buy YES means ETH is trending and our model is fighting the trend. Skip.
- One strike flagging, neighbors don't — usually a stale resting order or pulled quote. Sometimes worth investigating, but check Size first.
- Big edges right after launch — the σ measurement uses the last 60 minutes; if the engine just started, the most recent minute is partial and σ is unreliable for the first 5 minutes or so.
Caveats baked into the design
- ETH price source. Kalshi settles based on the CF Benchmarks ERTI rate (an average across six exchanges); we use Coinbase as a proxy. Under stress these can drift by a few dollars, so very small edges (under ~$10 of ETH distance) may just be the gap between the two feeds.
- Final 60 seconds. Kalshi doesn't settle on the last-second price — it averages ETH over the final 60 seconds. Our model knows about this and adjusts in the final minute, but signals inside the last minute should be treated cautiously.
- No directional view. See "What the model doesn't know" above.