This is the first post of our new series, Sketchy Trades, which we introduced here.

On July 9th at 7:30 in the morning, AEHR put out a press release essentially saying that a major customer placed a large order for one of their products.

Within one minute the stock went from $72 to $77, and 21 minutes later it printed $83.54, up 23% from the prior close (chart below).

What’s most interesting about this is that despite the price move being clearly attributable to that new information, the order was already weeks old by then.

• Someone at the purchasing company had to approve the money, issue a purchase order, and likely wire a deposit

• A month prior, AEHR announced that the customer “has also provided Aehr with a forecast for additional systems this calendar year” and the stock was up 11% within ten minutes that morning too.

So right off the bat, even when forward guidance is given in advance, the market still moves once it comes out that an actual order was placed.

This gives us an enticing starting point for our core experiment:

“If we believe that press releases containing big purchase orders result in immediate stock moves, at what point in the chain can we know about that order early?”

What we have below was definitely not easy to find, but by the end, you’ll see that nothing is impossible with enough will and quantitative muscle.

Read more

For the past few years, I’ve lived a wonderful life of solving some of the world’s hardest problems and realizing the rewards for successfully doing so.

Along the way, I publicly talked about what I came up with and often gave you the exact code and instructions to do it yourself.

However, while a lot of the work published is interesting, it does tend to skew a bit safe.

For instance, my favorite, most recent post was about short selling based on real-world event feeds, and while you can definitely make a lot of money by knowing how it works and running it, it’s basically the tip of the iceberg of what we actually get into behind the scenes.

I’ve never really talked much about who’s behind this, but “Alphanume” is a small quantitative trading team that takes a rather ruthless approach to hunting for edge and deploying it.

Now, “ruthless” here can sound a bit aggrandizing, but when it’s your job to identify market-moving information and strategies no one else has, it can take you in a lot of very interesting directions that live up to the name.

So, in a move we may come to regret, we’re starting a new series here, Sketchy Trades, that finally brings you into the more serious side of what unrestricted quantitative trading and research actually looks like.

It won’t be a “here’s how to break market rules” guide, but we’ll be going deep into angles no one else does publicly:

• Sniffing out future press releases early

• Flaws in stock lending programs that a bad actor can use to “manufacture” a short squeeze

• Using mass-distributed survey platforms like SurveyMonkey for real-time information gathering

And so on.

To everyone who’s been here and has given us their feedback, time, and support; we greatly appreciate you and look forward to finally giving you the kind of edge you came here for in the first place.

As always, thank you for reading this, and we hope to see you very soon.

To quickly bring you up to speed, a parlay is essentially just a combined bet where in order to win, every individual bet in that basket must come true.

The reason anyone bothers to do this at all is that the theoretical payoff tends to be multiplicative, so you only need a relatively small bet size to generate “worth it” level returns.

• For instance, combining 5, 50% likely bets into 1 parlay results in a 32x payoff.

Naturally, it’s an extremely low-probability endeavor and is why it makes up the majority of sportsbooks’ profit.

I was late to the game on this one, but after seeing the above headline, I instantly remembered that on prediction markets, there is no “house” that creates and facilitates these bets.

So if these markets were truly P2P, any trader would ask the same question I did:

“Lots of people are making these wagers that won’t pay off, couldn’t I just take the other side?”

After all, in contrast to selling low-probability out-of-the-money options, there would be a virtually infinite amount of combinations users can trade, which should help to mitigate the “pennies in front of a steamroller” effect through diversification.

So, with that clear question in mind, I immediately began pulling some data to see how it would go.

It’s no fun being the house

Starting simple, I wanted to model out the easiest version of this trade:

• Of every available combo (the term for parlays), find the ones where “YES” was quoted at <= 2c

  • In other words, finding every parlay with a less than 2% of chance of paying off

• From there, we’d simply buy the “NO” side and ideally collect a 2% return

  • A combo’s NO side pays out if any leg fails, so the idea was to get paid 2% for holding something that only loses when a 6-leg parlay actually pays out.

With that in mind, I pulled the data for these and immediately found that it made no sense:

Read more

I started collecting them into a calendar earlier this year, mostly out of curiosity, but the numbers around them turned out to be so clean and predictable it made it impossible not to take a more serious look.

That calendar now lives in our enriched reverse-split dataset

Eventually, that experiment led to another experiment, which led to another one after that, and is ultimately why I can say with extreme confidence that there’s probably never been a better time for short selling.

Now, in just the title alone, we’ve already made pretty big claims about how good this space is, so to actually back up those words, let’s start from the beginning.

It doesn’t get easier than a reverse split

When a stock closes under $1 for 30 straight sessions, Nasdaq sends out a deficiency notice. In order to stay listed on the exchange, all the company has to do is bring its price back up to that $1 minimum.

Note how price is emphasized; not market value, revenue, or anything beyond just the surface-level optic of price.

Knowing this, the de-facto solution for these companies is a reverse split, where they consolidate 10, 30, or even 50 shares into one, and the delisting problem disappears overnight.

The company itself doesn’t change at all and still has the same cash burn, the same need to continuously dilute, and the million other problems that got it there in the first place.

To give a relatable example, Beyond Meat ($BYND) has been doing this all year:

• The share count went from 76.5 million to 515.8 million

• Once the stock was trading in the thirty-cent range, the company executed a 1-for-30 reverse split on August 14 to beat the August 31 compliance deadline

Now, one of the challenges in shorting broken companies is that some of the best candidates are often already trading below $1, which most brokers don’t allow you to do.

However, if that candidate just executed a reverse split and became eligible for shorting again, one can ask a pretty simple question:

“If the business model is still broken and the company is still expected to perform poorly, couldn’t you just continue shorting it now that the restriction is gone?”

Intrigued by the question, I pulled the data for every reverse split from January 2024 through July 2026, with a crude strategy of shorting at the next session’s open and holding for 30 trading days.

To filter out un-tradeable noise, I also applied a $1 minimum price and a $100k minimum average daily dollar volume, so sub-dollar zombies with no borrow don’t give misleading results.

For this first, crude experiment, the numbers weren’t too bad:

• 1,373 tradeable events, out of about 2,700 raw splits (the rest had no listed price data or were under the sanity floor described above)

• Mean 30-day short return +7.7%, median +16.6%, hit rate 69%

• The mean and median have a large spread due to the left-tail nature of short positions, where the worst single event, BNAI, cost the short over 2,000% of the position

Interestingly, academia found the same drift decades ago, where a 2008 Financial Management study of 1,612 reverse splits showed significant negative abnormal returns for three years after the split.

Now, one of the advantages of doing this for some time is that you gain the ability to tie an older experiment to the results of a new experiment, allowing for a more effective version that other participants couldn’t build.

We’ve covered similar effects existing in stock dilution events, so that made me curious to see what would happen if we segmented these reverse split events by those who also have a history of repeat dilution.

Fortunately, that extra umph is what made it a viable strategy:

We found that shorting reverse split events in companies with a history of dilution returned +15.9% (9.9% net after a fixed 50% annualized borrow cost assumption) per position over 30 days, at a 77% hit rate.

Machine learning still has some juice

With renewed confidence that short-side edge still exists in relatively untapped areas, I went through some of our old files to see if anything useful still held up.

Back in the early days, when machine-learning models were my first weapon of choice, I remember building out a classification model to track a market phenomenon you’ve probably seen before:

1. Stock XYZ with a $20m market cap is up 150%+ in early pre-market and gets plastered over 100 retail-focused screeners (e.g., “Pre-market movers”)

   1. In the best case, it’s tied to a vague “AI” or “crypto” press release

   2. In most cases, you wouldn’t be able to find a real catalyst even if you tried

2. By the end-of-day close, the stock has either gone negative or is substantially down from its pre-market headline

3. This repeats the next day, but with a new stock

Most of this is attributable to shaky price discovery during illiquid periods, but a meaningful chunk is tied to bad actors running pump-and-dump schemes.

We built a model for exactly that, where given only information available 30 minutes prior to the open (e.g., return distribution, size), we’d have a probability of whether the given premarket ticker would drop by 5% or more by close.

We now publish those daily rankings through Alphanume’s Pre-Market Drop Risk dataset, with each name’s model probability and subsequent outcomes.

To see if it still worked, we re-ran the strategy over the same multi-year test period as above, where we’d short at the 9:30 open (MOO auction order) and buy back the position at close (MOC order).

Surprisingly, it still works:

• 865 trades across 485 sessions since May 2024

• Mean return +4.3% per trade, with a 70% hit rate

• Concentrating helps, as the day’s top-1 highest probability name alone averaged +6.1% per trade

• Extending the position duration also helps, where holding the same shorts for 5 sessions averaged +11.1%

The equity curve (below) immediately raised every “you probably overfit somewhere” flag in the book, but after trying to break it some more and not getting anywhere, I’ll just let you be the judge (replication instructions in the final section).

Now, being transparent, the reason we didn’t keep running this model when we had it is that this is almost entirely in the realm of low-capacity trades:

• Many of these companies are low-volume from the start, so any position size north of even $10k can sometimes be 5%+ of historical ADV, which will give you partial fills when using auction orders

• Full automation is difficult as these are all HTB, so even though locate fees are manageable at places like TradeZero and Centerpoint (e.g., $0.04 per 100 shares), you still have to actually press the button

  • When running this live, we used CSV basket orders to speed things up, but even that was tough as any partially filled leg threw off the target equal weight allocation

So, while this can still work magic for a few thousand bucks, we’d be lying if we said it’s a million-dollar compounding machine.

Pounding the table on dilution, again

This post is already getting a bit lengthy, but we’d be doing a massive disservice to you if we didn’t mention the last leg that we’ve already been running live.

We’ve written about it recently, but shorting small caps that file dilutive S-1 registrations is still one of the lowest hanging fruits in this space.

For quick context, an S-1 registers new shares in companies that usually need the money badly. Despite the announcement being priced-in rather quickly, shares continue to go down abnormally as the new lack of shareholder incentive combines with the already dim outlook on the company’s future.

A few days ago, I publicly shared the performance (link above) to show that the edge still survives out of sample:

• 301 tradeable filings, mean 30-day short return +26.3%, median +31.5%, hit rate 82%

Again, being transparent, we recently tried the same strategy with the cousin of this (shelf registrations) and found it wasn’t that effective, running at +1.8% on average, with a 57% hit rate.

You can inspect a delayed sample of the S-1 filings here, including the company, shares registered, and market cap, without creating an account.

You’ll blow up if you don’t combine them

In short selling, you will eventually have a position that goes up n standard deviations against you. It might not happen in the first 100 trades, but it is almost a guarantee that it’ll happen at some point.

The best solution I’ve found for this is “simply” running the multiple strategies as a diversified book, so that one day’s strategy loss can be offset not just by the smaller allocated size, but ideally also by the gains of another strategy.

“Simply” in quotes, as each strategy might have non-overlapping exposure periods. For instance, the pre-market list updates every morning, but reverse splits execute in weekly clumps, while S-1s arrive most evenings.

To make it easier for you, we can walk through a sample framework:

1. A $30,000 account puts $1,000 behind each sleeve each morning, split equally across whatever positions that sleeve has open that day

2. A sleeve with nothing on keeps its $1,000 in cash

3. A position’s one-day loss is capped at -100% of its slice

4. Position sizes stay fixed in dollars, with no compounding (compounding full size in microcap shorts is unrealistic)

Over 561 sessions from June 2024 through August 2026, the combined book of strategies grew from $30,000 to $67,307 (+124%), while dripping the same $3,000 a day into SPY finished at $31,227 (+4%).

Broken down, that comes out to roughly $16.5k a year of P&L against $3,000 of gross short exposure, with 72% of days positive (chart below).

Final Thoughts

None of the inputs here are secret, as reverse splits are announced in press releases, S-1s and shelfs sit on EDGAR, and pre-market movers are on every dashboard.

The reason they aren’t talked about as much is that putting it all together took deep domain experience and hard data work.

However, all of this is now accessible through an API call, which is pretty much my whole case for framing this as the golden age.

All three datasets covered here are available through Alphanume Pro, with their available history and ongoing updates through the dashboard, REST API, and hosted MCP server, at $99/month.

If you want to run or model any of this yourself, you can go two ways:

Manual pipeline

1. Pull the event calendar (reverse splits, S-1s, or the morning drop-risk)

2. Enter at the next session’s open, and apply the same tradeability floor ($1 and $100k daily dollar volume is what I used)

3. Hold 30 trading days for the filing-driven trades, or close at the bell for the pre-market tranche

4. Before sizing anything, get a real borrow quote to simulate the interest costs

Give it to Claude

We run a hosted MCP server, and the setup takes about a minute:

1. Open Settings in Claude, then Connectors, and click Add custom connector

2. Paste https://mcp.alphanume.com/mcp as the server URL and confirm

3. Click Connect and sign in with your Alphanume account

From there, all 25 datasets sit one plain-language question away, so here’s a few prompts worth stealing:

• Have it build the production plumbing: “watch the reverse-split calendar and alert me the day before any split with an S-1 or shelf on file executes”

• Have it go deeper than I did here: “re-run the reverse-split short with a 60-day hold and a hard-to-borrow fee assumption, and show me where the edge dies”

• Or have it hunt for an edge that’s fully yours: “cross reference the premarket drop-risk list against the SEC filing intensity and Wikipedia-attention feeds, and show me whatever filter survives”

So, hopefully we’ve given you enough evidence to back up our confidence on this. We’ve long believed that there’s a much bigger world out there than the vanilla “buy large-caps” you see on Bloomberg, and for once, the data actually agrees.

As always, thanks for reading, and we’ll see you in the next one.

As such, most decide to rent this processing power by the hour.

Now, if you’ve been remotely following markets in the past few months, you know that a major fear is that too many companies are overspending on this compute and may not be able to justify the returns soon enough.

So to partially address this risk, a new futures market was created, where you can now essentially bet/hedge that the price of compute will either go up or down.

This interested me as, on the surface, it doesn’t really make that much sense:

• What is the actual deliverable?

• What does it actually hedge against?

  • If you short it, are you hedging against the Mag 7 missing earnings? If so, what’s the optimal hedge ratio?

  • If you long it and lock-in the price, see question 1.

There are currently ~20 live markets on Polymarket quoting the future rental price of Nvidia GPUs, covering everything from the H100 down to the RTX 5090 in your gaming rig.

So curious, I pulled every quote through their public API to try making sense of the numbers.

What’s actually trading

Each market is a bracket ladder (e.g., $2-2.25) on where a GPU’s rental price will close the month.

The resolution source is the Ornn compute index, a daily benchmark of what an hour on that GPU actually rents for, taken from real transactions.

Here’s the live ladder for the H100 at the end of August, three days from resolution:

• $2.75 to $3.00: 46%

• $3.00 to $3.25: 20%

• $2.50 to $2.75: 17%

• $3.25 or higher: 9%

• everything below $2.50: ~8% combined

For reference, Ornn printed $2.76 on August 27, so the market is effectively saying “it’ll close right about here, maybe a touch higher by Monday,” which makes sense given the short time-to-expiration.

Being so new and niche, the liquidity for these are pretty low, with just ~$34k in liquidity for that contract.

Going back to what we know about standard futures and options, we know that the premium for out-of-the-money strikes drastically decreases with time as there’s a smaller probability that a major event will occur by expiration.

So if the same dynamics apply to these, we also know that most of the money is made from future expectations:

• If we take the expected price 3 months out, can we convert that into an “implied volatility” figure?

  • If so, can we reconstruct a short-volatility position via the positions ladder?

    • E.g., Taking “no” wagers of >$3+ and <$1.50 (pays off if price is below $3 and above $1.50)

A question with high rewards, but to even see if it’s possible, we need to pull some more data.

What the curve believes

To try creating a “term structure” for these markets, I computed the implied averages (Σ (midpoint × normalized probability) ) for each H100 market that expires in later months:

• end of August: $2.88

• end of September: $2.74

• end of October: $2.65

• end of 2026: $2.72

Against spot at $2.76, the market’s forecast for the next four months is basically “nothing happens”, the lumpiness is a bit unusual, but we’ll attribute it to the wide bid-ask spreads which can distort the mid.

Interestingly enough though, there does seem to be a pretty strong informational view in the tails further down the curve. By the December expiry, traders put roughly 21% on the H100 closing the year below $2.00 and 34% on it closing above $3.00 (chart below).

In other words, a fifth of the probability mass is a rental-price crash, and a third is a further squeeze.

This likely represents the high-conviction “AI bubble” vs “AGI tomorrow” crowd placing high-payoff wagers in either direction, but regardless of the reason, it shows that there’s a volatility risk premium in this market as well.

So, to answer our earlier question, you absolutely can trade this from the lens of a volatility trader:

Read more

For a long time, we primarily just wrote up what we found, ran some tests, and shared the code for you to deploy verify it for yourself.

What we haven’t done as much though is actually go back and show you how the strategies we produce and cover have actually performed since release.

So, I took the week to fully organize every strategy, model, and dataset we publish at Alphanume to show you the actual results, for good and for bad.

The momentum index

Starting off strong, the momentum basket returned +82.5% over the last twelve months, against +20.4% for SPY (chart below).

The strategy itself is about as simple as this business gets. Each month we publish the ten highest-momentum US names by the classic 12-1 measure (and a few other risk-adjusted metrics), you hold them equal weight, and you swap the list at the next refresh.

What makes our approach work as opposed to “just buy what’s up” is the universe selection of only those with deep option liquidity at their point-in-time snapshot.

Now, again, we said we’d be completely honest here, so it’s important to admit that the ride was awful at times. The basket fell 47% peak-to-trough between the June high and early August, with July alone down ~-20%.

To be fair though, almost every quant fund with momentum exposure suffered the same fate over that time period:

High volatility comes with the territory of running concentrated exposure to a factor, but it’s called a factor premium for a reason, as you typically end up outperforming standard index beta.

Shorting bad corporate news

While we do consider ourselves good people, this is honestly our favorite class of strategy.

In the majority of cases, when a poorly performing company announces they’ve done something “bad” (e.g., diluting their shares, missed a payment, etc.), forward returns continue to be negative, even after the information is known.

It’s a pretty linear trade with a 1:1 rationale that almost anyone can understand.

Every strategy in this family isolates a company on one of the worst days of its life: an S-1 that registers a pile of new shares, a shady SPAC that just completed its merger, an 8-K admitting a missed debt payment, etc.

Simply shorting these has results that are pretty easy to predict:

• De-SPAC completions: mean 30-day short return +36%, hit rate 83% (of 18 tradeable completions this year).

• Corporate default disclosures: +33%, hit rate 87%. Only 15 of 58 flagged names were still tradeable though, as by the time a default hits an 8-K, like Luminar’s bankruptcy filing in December, trading has often stopped.

• Dilutive S-1 filings: +26%, hit rate 82% across 170 events, and the micro-cap slice (under $50M) did +30%.

The visual below demonstrates the average short-return path for each event type over the 30 days after the filing:

Now, before you go short every dilutive S-1 that comes, you should know about the biggest reason most funds don’t short sell at all:

• One dilution short (HCWB) lost 283% when the stock squeezed 3x in a week

• This inherent left-tail nature of a short position (max gain is 100%, max loss is infinite) makes scaling incredibly hard.

  • To make this work at scale, your size per name has to be a tiny portion of your gross book, since its inevitable that at least one name per quarter will have an adverse 5 standard deviation move against you.

  • The challenge is that for the actual dollar returns to be worthwhile, you’d need a pretty big book to keep risk sane.

The 0-DTE Strike Band

Each morning we publish a lower and upper strike for SPX, which represents the range the index is expected to finish inside that day.

The obvious trade is an iron condor with the short strikes at or beyond the band, so that’s the one we’ll focus on.

Over the last 246 trading days:

• SPX closed inside the band 87.8% of the time.

• The full intraday range stayed inside only 65% of the time, so if your short strikes sit right at the band, you’ll watch them get touched a lot more often than they actually get breached at the close.

Because this is such a sensitive trade, we make the data for this P.I.T. integral, meaning we never retroactively change the data after it’s been published. So, the outputs you see here are the actual outputs that were visible on that exact day.

Continuing to be transparent, while making some infrastructure changes in July, we had almost a full week where the strikes delivered were modeled on delayed data points which led to erroneous values that brought down July’s average.

Nevertheless, this is one of our more regime-agnostic strategy sleeves that produces a rather steady flow of option premium. It being short volatility still leaves it susceptible to the left-tail drawdown days, but when run as 1 overlay in a multi-strategy book and paired with dynamic sizing criteria, things tend to work out pretty well.

Side note: For those who beared through the intermittent issues and are still with us, thank you and it does not go un-appreciated.

Next-day movers

This feed lists five names before close that our volatility model expects to move substantially in the next session.

Across 1,240 model predictions, the average absolute next-day move was 7.1%, and a quarter of the signals moved 10% or more. The best call of the year was OPEN, flagged the evening before it moved +78%.

For context, those same tickers move about 5.8% on a normal day (these are wild names to begin with) and SPY moves ~0.6%. So the model’s real skill is picking which day an already-jumpy name goes, which is exactly what you want if you’re buying vol or convexity on the list.

One more for the vol crowd while we’re here: across 1,329 earnings events in the window, the pre-earnings straddle was overpriced 66% of the time, with an average implied move of 8.9% against a realized 7.5%, so selling the earnings straddle still got paid on average.

What didn’t work

Now, in this space especially, if someone says they have a 100% success rate, you would be right to immediately distrust them.

The same applies to us, so let’s take a look at what hasn’t performed that well:

• Shelf registrations came back flat: +1.8% mean short return and a 57% hit rate across 346 filings

  • A shelf just reserves the right to sell shares later, sometimes years later, so the market prices it that way. In contrast, a dilutive S-1 often implies that shares are trying to be sold right now.

• FDA setbacks actively lost money: -10.6% mean, 40% hit rate.

  • A CRL or clinical hold is essentially “something bad happened with the drug” for biotech stocks. What we found is that over the sample, these are priced-in pretty quickly, so even shorting on a t+1 basis is too slow.

  • This may be a “skill issue”, as we can likely try harder to create a faster data source for these kind of events.

Now, one that wasn’t a failure, but is still too uncertain to call it a success was Wikipedia attention.

We track daily Wikipedia page views for every covered company and flag spikes of 3+ standard deviations above the trailing month.

Our first idea was the obvious trade of mean-reversion of the spike and waiting 30 days. Interestingly enough, that lost ~1.7% on average across 1,678 spikes. Raising the bar to 5, 10, or even 20 standard deviations didn’t help either, as once you subtract SPY the forward return of a spike is basically zero at every threshold.

Still though, I firmly believed that such an uncorrelated metric of “who’s paying attention to stock X right now” wasn’t completely worthless, so eventually I just tried doing the opposite:

The biggest finding was that same-direction momentum exists for names that experience a spike in attention.

For instance, of stocks with attention spikes that were up >= +2% on the day of the spike, they often returned +3.1% over SPY within 10 trading days across 291 events.

Run it yourself

Everything above comes from the public API, and each strategy is maybe an afternoon of work to reproduce:

1. Pull a year of events from the feed you care about, say GET /v1/de-spac-events, and grab daily bars for each ticker from your price vendor

2. Enter at the next open after each event date, mark 30 trading-day closes, and dedupe repeat events (e.g., drop_duplicates())

3. Apply sanity checks (e.g., $1 price minimum, $100k average volume minimum)

4. Compute the mean path, the median, and the hit rate, and look at the worst five events by hand before you believe any of it

Final Thoughts

We made this post after sitting down and trying to look at our old posts from the perspective of someone else in the space.

Although we love to run strategy research and publish our findings, we feel that it’s important to at least check-in from time-to-time to make sure what we ship actually works.

If you’d like to get to the point where an afternoon of this is routine, that’s exactly what we built Alphanume Learn for. Every strategy in this post lives in the curriculum (the dilution short, the SPACs, momentum, the earnings premium), shown the same way we just did it here: pull the data, test the claim, look at what the worst events did.

As always, thanks for reading, and we’ll see you in the next one.

Recently though, things have started to pick up speed.

The current generation writes real research code, runs it, reads its own output, and argues with me about the interpretation, and somewhere in there an idea I would have laughed at two years ago started looking buildable.

Now, I want to be delicate with this post, as the genre it belongs to is mostly garbage:

• The “AI replaces all quants by 2030” forecasts, usually written by people who have never cleaned a corporate action in their lives.

So, we’re going to approach this the right way: from the mechanics up.

The question on the table is simple:

“What would it actually take to train a machine that does quantitative research at industrial scale?”

By this I mean a system that gets handed a dataset and an objective, runs its own experiments, kills its own bad ideas, and hands back something robust, running a few thousand copies in parallel.

Essentially a quant research desk, but ultra-scaled like compute.

Now, we won’t turn this into an academic ML sleeper, but to reason about any of this the right way, we first need to understand a few basics.

How a model gets good at things

A base language model is trained to predict text, and that alone gets you a generally capable generalist. It writes decent pandas, knows what a Sharpe ratio is, and can recite a few momentum papers.

Now, just predicting something based on what’s already known has a pretty low ceiling. What’s actually made novel research and fresh ideas possible is reinforcement learning (RL).

RL often sounds more mysterious than it is, so let’s think about how a junior quant actually learns.

Nobody hands them a rulebook covering every market state; they start with a hypothesis, put on positions, the P&L comes back, and the strategies that kept making money survive while the ones that kept losing get removed.

RL is that loop, run on a model, millions of times, with a reward/penalty standing in for the P&L:

1. Give the model a task where a computer (“grader”) can score the outcome: a math problem with a known answer, code with unit tests, etc.

2. Let it generate a full attempt, reasoning, tool calls and all. That whole attempt is called a trajectory.

3. Grade the outcome mechanically. Correct earns a reward (+1), wrong earns nothing.

4. Update the model so trajectories that earned a reward become more probable, and trajectories that didn’t become less probable.

Step 4 is where a lot of people in the space degenerate to bizarre overfitting, so let’s slow down a bit.

You might picture it writing down a rule like INVERSE_VOL = GOOD somewhere. That update is actually a nudge to billions of weights that makes the entire chain of behavior that preceded a reward slightly more likely to happen again.

The public proof this works is DeepSeek-R1, which was trained with rewards linked to final-answer correctness. Nobody told it to double-check its work, and by the end of training it was pausing mid-solution to re-evaluate its own reasoning anyway, because trajectories containing that behavior kept getting rewarded.

That’s pretty much it: a grader, a lot of attempts, and a rule that says be more like your better self.

Alright, that was the bulkiest academic part of this post. So now that you have some starting notion of how RL works, we can get our hands dirty.

The quant research game

Say you wanted to do this for quant research. Each training episode would look something like a fresh, self-contained research assignment:

Universe:   1,500 US equities
Period:     2004-2020

Fields:     date, ticker, adjusted_close,
            volume, market_cap

Objective:  Construct a market-neutral
            long/short momentum strategy.

You may write and execute Python.

The agent sees 2004 through 2020. The years 2021-2025 exist only on the grader’s side, and the agent is never shown them, or even told exactly where the boundary sits.

Then, you let it cook.

To demonstrate, here’s a plausible sequence of attempts, with numbers loosely borrowed from how this actually goes:

• Naive 12-month momentum, deciles, equal weight, daily rebalance: Sharpe 0.83, monstrous turnover, 38% drawdown.

• It notices cross-sectional vol varies wildly and tries inverse-vol weighting: 1.34.

• Skip the most recent month (the classic 12-1 construction): 1.55.

• Monthly rebalance instead of daily: 1.73.

• All three together: 2.13.

Grade the out-of-sample years, reward accordingly, and repeat.

Across one experiment this is basically just a parameter search, and honestly RL would be overkill for that; a grid search finds rebalance = monthly too.

The interesting thing happens when the next experiment is Japanese equities and mean reversion, then the one after that is commodity carry, then futures trend, then earnings revisions, each with different hidden periods, different costs, different regimes.

Run 100,000 episodes of this.

Now, no single “trick” generalizes (e.g., “always monthly rebalance”). The research model will find that inverse-vol weighting helps in some experiments and is irrelevant in others.

What will generalize though are the research behaviors that led to good outcomes:

• “Check whether risk differences are driving your portfolio before believing your signal”

• “Test whether the effect lives entirely in microcaps, then impose liquidity constraints”

• “Distrust any spectacular in-sample Sharpe on principle.”

• “Compare neighboring parameters; a strategy that dies at lookback = 11 was never alive at 12”

• “Run subperiods, and check the whole result isn’t three good years carrying seven bad ones”

• “When two constructions perform the same, keep the simpler one”

Those are the habits of a good systematic researcher, and under this training loop they’d be reinforced the same way Deepseek R1 learned to double-check algebra: they just keep getting paid. (chart below)

Now, markets give you one history, and you can’t generate 50,000 more S&P 500s to practice on, which is exactly why RL on raw prices has such a miserable track record.

The research process above sidesteps that limitation though, as the thing being practiced is the process, and you can manufacture endless distinct research problems from enough historical data.

You WILL train the world’s best p-hacker, at first.

Suppose your reward function is a naive one:

“Sharpe above 2 pays +1, anything else pays 0”

In order to earn a reward, your agent will “discover” that some obscure universe filter plus a 173-day lookback, excluding Tuesdays, rebalanced every 37 days, prints a Sharpe of 2.04 on the historical window.

This failure is known in RL as reward hacking.

Fortunately for us though, Finance met this exact adversary years before the AI labs did.

When you test N random, zero-edge strategies on the same history, the best one’s Sharpe grows like the square root of the log of N. In other words, search enough noise and noise will clear any bar you set (chart below).

Bailey and López de Prado formalized the fix as the deflated Sharpe ratio: given how many trials you ran, this is the Sharpe that means anything at all.

The standard complaint about Sharpe deflation is that human researchers lie about N. For instance, a junior quant runs 400 variations, has their pitch deck say 3, and no one can really prove otherwise until it starts losing money.

An RL environment can have none of those problems, but only if you structure it right from the beginning. To do this, the environment must see every experiment the agent ran. Every backtest, every parameter touched, the full trajectory has to be logged.

This way, you can compute the deflated Sharpe exactly, per episode, and pay the reward on THAT.

Making the grader evil enough

Here’s a high-level view of what I’d say is the ideal framework for making this possible:

1. Hidden holdouts with undisclosed boundaries

   1. The agent sees a train window and a validation window. The grader scores a third period the agent never touches and is never told the edges of, so there’s no boundary to quietly optimize toward.

2. A continuous, multi-term reward

   1. No “reward if 2+ Sharpe“ targets.

   2. Score out-of-sample Sharpe, drawdown, turnover, transaction costs, factor neutrality, and cross-universe robustness together, smoothly, as single hard-targets like Sharpe are what get hacked.

3. Randomized episodes

   1. Asset class, region, regime, cost model, liquidity assumptions, all drawn fresh each episode, so the only thing stable enough to learn is the research process.

4. Deflate, deflate, deflate

   1. The grader counts every experiment in the trajectory and deflates the reward accordingly.

      1. Ten clean experiments that led to a Sharpe of 1.4 outscores 400 experiments that wound up with a 2.1

5. Robustness probes

   1. After the agent submits, the grader scrambles its parameters, resamples the universe, and stress-tests the costs.

The high-level view loop can be visualized as follows:

What comes out the other side, if it works, is a model whose instincts on a brand-new dataset go like this:

“This looks cross-sectional, so first I’ll characterize coverage and missingness. There’s heavy heteroskedasticity, so I’ll compare equal-weight and risk-normalized books before trusting any signal. Quintile portfolios first; no parameter optimization yet. Interesting, the effect is concentrated in small caps. Impose ADV constraints and retest. Sharpe falls from 2.1 to 1.2, so before abandoning it, check whether it survives in large caps and internationally.”

The model behaves that way because across the 100,000+ graded research problems, behaving that way is what got it rewarded.

THAT’S the version of “AI quant” one should take seriously: a fleet of these, each one a few dollars of compute, pointed at every dataset you own, running the full protocol every single time.

Why this doesn’t exist yet

What’s interesting is that, right now, this is where the actual arms race is, since the RL algorithms are public and the labs are in an outright land rush for training environments. Anthropic reportedly discussed spending over $1 billion on them in a single year, and a dozen startups now sell simulated Salesforce instances and browser sandboxes by the seat.

There’s also academic LLM “alpha mining” agents too, all you have to do is make one GitHub search and you’ll see 50.

However, almost all of them are practically just prompted systems. Clever, yes, but it isn’t actually letting the model self-learn the behaviors needed to come up with novel ideas and strategies.

We just proposed a sample framework to get there, but a few things make it difficult:

• The grader is uniquely evil here

  • A math environment’s verifier is truth itself (e.g., x+y is objectively z). Our verifier, historical performance, is a noisy proxy for the thing we care about, which is future performance.

• The environment is made of data

  • A hundred thousand distinct, bias-free episodes means point-in-time universes, survivorship-aware histories, real cost surfaces, across assets and regimes. You can’t scrape that, and using broken data just scales a broken process.

The first problem has a solution this post just sketched, and the Sharpe deflation math is twelve years old at this point. The second problem is an infrastructure problem, and it’s the one we’ve decided to go after.

If you’re an Alphanume client, you got an email from us recently about an infrastructure upgrade so we can start scaling the quality and breadth of the dataset catalog.

Our mission with Alphanume, since day one, has been to build the best quantitative finance data provider, full stop. We aren’t fully there yet, but the progress behind the scenes is real.

The point-in-time, survivorship-aware catalog we provide to human researchers is, structurally, the same thing a machine researcher’s environment is made of. We just want to be the ones holding the data once someone figures this out at scale.

Final Thoughts

This has objectively been the most interesting rabbit hole I’ve gone down in a while.

The original Situational Awareness paper theorized that in the future, million-deep swarms of research agents would be able to produce novel research to solve problems in biology and other vital fields.

Admittedly, I, like most people, read predictions like that as “huh, yeah maybe.”, but when you actually try running this yourself with current frontier models, you start to think that such a system might not be that far-fetched.

Now, I don’t know whether the first genuinely RL-trained quant research swarm comes out of a frontier lab or some niche options desk. Again, my background is just on the quantitative research side of things, but you can see for yourself that models with frontier-level intelligence are getting substantially cheaper along with the compute necessary to run them.

It’s inevitable that when enough people at least try a framework like this, at least one will genuinely work, for awhile anyway. Heck, there’s even a chance that we’re way behind the curve on this one and it’s already a solved problem somewhere.

This post was a bit different than my typical pure-quant research/experimental style, but I was just so enthused by this space that I felt compelled to write it up. Of course, no one knows exactly what the future will look like, but if (when) these possibilities are realized, it will be very interesting.

As always, thanks for reading, and we’ll see you in the next one.

At ~2pm, the trade log seemed to glitch out on itself as 40,000 shares printed at exactly $7.78, over and over, like the price had hit a wall.

Then, the stock stopped trading entirely.

Now, everyone already knows about trading halts at a high-level:

“a stock moves around a lot, it gets halted, re-opens, maybe halts again, maybe it doesn’t.“

But when you think about it on a more granular-level, you begin to wonder if that’s really all there is to it:

• After a halt, does price tend to revert in the direction it halted in?

  • If not, does it continue its momentum?

• Are you able to predict the likelihood of a halt before its official?

  • If you could, would it even be profitable to do so?

  • Would you be able to place the order in time?

When you have these kind of niche research questions, you’ll often find that the only way to answer them is to just get your hands dirty and look into the data yourself.

So, that’s exactly what we did.

“Trading halts are weird, but when they happen, can they be turned into repeatable, harvestable edges?”

How does this stuff even work?

As usual, it’s important that we start from first-principles.

LULD stands for Limit Up-Limit Down, the mechanism the exchanges rolled out after the 2010 flash crash. Thankfully, the exact rules behind it are wide-open and public.

To keep things short:

1. Every stock has a reference price: the average trade price over the last 5 minutes, republished every 30 seconds.

2. There’s usually a band around that reference price:

   1. For large caps (S&P 500, Russell 1000) it’s 5%, doubling to 10% in the last 25 minutes of the day (3:35 to 4:00).

   2. For everything else above $3 it’s a flat 10%, and between $0.75 and $3 it’s 20%, doubling to 40% into the close.

3. If the best bid rises above the upper band (or the best ask below the lower) for 15 seconds straight, it becomes a “limit state” and the stock goes into a 5-minute trading pause.

4. The listing exchange then reopens it with an auction, the same mechanism as the opening cross.

   1. If it can’t find a clean price, the pause can stretch to 10 minutes before other venues are allowed to resume on their own.

So, going back to our CDTG example from earlier, that constant $7.78 print was it entering that limit state and essentially being glued to that upper band.

They happen literally EVERY day

I expected halts to be rare, maybe a few a week, only reserved for clear info-driven outliers, but the data did not agree with that.

Exchanges publish every halt with timestamps (NYSE’s log covers Nasdaq listings too), and I pulled 17 trading days of it, July 27 through August 18.

• 1,260 LULD pauses in 17 days, so ~74 per day

• 467 unique ticker-days had at least one volatility halt.

• One stock, AIXC, halted 24 times in a single session yesterday. Another, YXT, managed 30 on August 5.

There’s not a single quiet day anywhere in the sample (chart below).

Now, most of these are $2 stocks doing $2-stock things, but the interesting part is what they do after the halt is over.

Read more

In other words, you keep 90% of the market and get paid double digits for it.

Numbers like that didn’t make any sense to me, as my initial thought process went along the lines of “if you can have that, then why invest in anything else?”

These high-yield option ETFs have been out for a few years now, but there doesn’t seem to be any rigorous, data-based insight on whether these are just self-liquidation schemes (i.e., “NAV erosion”) or actual, legit products.

So, I spent the week pulling data to answer an incredibly simple question:

“Are these things legit, or not?”

The answer is… sort of.

To get things started, I first established a universe size of ~17, covering the typical names like JEPI, the weekly 0-DTE funds, and the YieldMax funds (the triple digit APY guys).

For each fund, I pulled every dividend, split, close, and any other data point I could for the last 12 months, then computed three numbers per share:

1. Distributions paid: every dividend over the window, converted to today’s share basis (after a reverse split, one of today’s shares is several of last year’s, so the old checks get scaled up to match)

2. NAV change: what the share price itself did over the same window, split-adjusted

3. Coverage: distributions plus NAV change, divided by distributions. At 1.0, the fund earned exactly what it paid you. Below 1.0, the check was your own capital coming back.

The share-basis part matters more than you’d think as my first pass had TSLY “gaining” 185% when it actually lost 43%, so if you’ve ever audited these funds on raw price history and gotten nonsense, that’s why.

Now, if you’re still reading despite that onslaught of technical terms, thank you.

To try making things a bit easier, let’s start with a visual on what the first run came up with:

The big dogs are pretty legit

Because we’re optimists, we’ll start with the good.

Looking at the funds everyone’s parents own, the big-picture is that they actually make much more than they pay out:

• QYLD paid 12.5% of its year-ago share price and its NAV still rose 8.1%. Coverage: 1.65.

• JEPQ paid 11.7%, NAV up 8.5%, coverage 1.73.

• JEPI, XYLD, RYLD, SPYI, and QQQI all landed between 1.27 and 1.75.

Zero of the seven monthly index funds handed back a dime of your capital over the last year.

The weekly machines aren't all there

The Roundhill 0DTE funds sell same-day calls every morning and mail a check every Friday, and the findings are pretty much speak for themselves:

Read more

These were ordinary public URLs that simply didn’t exist at the moment I first asked, and the script’s whole job was to keep asking, politely, until one of them stopped returning an error and started returning a filing.

The reason this works is a quirk of how EDGAR publishes documents, and the reason it’s worth writing up is that the quirk hands you a filing tens of seconds before the feed everyone else watches knows the filing exists.

When the SEC says a filing is “public”, which clock is it talking about: the one where the file is on a server, or the one where everyone was told about it?

So today, I’m going to show you exactly how to do it yourself.

Where the seconds come from

EDGAR is pretty old now, and as such, it’s a well-documented pipeline: a submission gets accepted, validated, assigned an accession number, reassembled, and only then handed to the dissemination service that feeds the RSS streams, the paid subscriber feed, and every data vendor downstream of them.

Each stage takes time, and most importantly, the stages don’t finish all at once.

A developer named John Friedman noticed this in August 2025 in the crudest, best way possible: he looked at the HTTP headers.

• A 10-K’s SGML file carried a Last-Modified timestamp nine seconds before his RSS poller first saw the filing, and when he widened the check to roughly 4,000 filings, the delay between EDGAR accepting a document and the RSS feed publishing it averaged around 25 seconds.

If you know anything about how fast price moves after an earnings release, you know that even just a 5 second lead is major.

So, naturally, being inspired by his finding, I set out to run an experiment to see if this has already been arbitraged away to nothing.

Surprisingly, it hasn’t.

The accession number is just a counter

Every EDGAR submission gets an accession number, and the format does most of the work for you:

0001193125-26-351131 = {submitter CIK}-{two-digit year}-{sequence}

Now, this is pretty much the entire bedrock of the edge, so let’s take a second to actually define those:

• Submitter CIK: This just identifies whoever submitted the filing, and most companies pay a filing agent to press the button and the agent files under its own CIK all day long for hundreds of clients.

• Sequence #: Basically what it sounds like and is a counter that increments with each submission the agent makes that year.

What makes this prediction feasible is the submitter population is tiny and concentrated. Friedman’s follow-up repo found that ten submitters accounted for about 42% of all filings in 2024, so watching a handful of counters covers a huge slice of the market and companies tend to stick with the same agent year after year.

When I pulled the current-filings feed that morning, the busiest submitters were two law firms, Seward & Kissel and Willkie Farr, and a compliance shop, each churning out filings under a single prefix.

If the last thing an agent filed was sequence 003661, the next thing it files will be 003662.

The trick, in four steps

Once you know how that works, you can see how the whole pipeline can be run from a simple laptop:

Read more

What got me to even care about this was the profit behind it.

In the case, there were at least 3,000 unique spoofing instances, which works out to about $372 per spoof. Call it six spoofs a day and it comes out to roughly $23,000 a month.

Nobody does 3,000 of anything by accident, so this was clearly a sophisticated operation which begs the question of how exactly did a guy in a bathrobe clock in and manipulate prices six times a day for four years?

If we can figure out how he did it, can we, just for fun, see if it’s still plausible to do right now?

Cerisano’s email to a broker: “I really Feel that My Account never should have been Closed, anyway the reason the Account was Closed was because of Layering, an easy way around this would be if the system only let Me put orders in on one side of the Market Meaning I Could only bid or offer but not both, this would take Care of the problem please advise thanks ..”

The trade, as a trade

We don’t want to make this post a sleepy academic explanation on microstructure, so to understand what happened and how spoofing works, let’s walk through one of the trades:

1. On Jan. 10, 2025 after the close, a mid-cap ETF had an bid/ask spread of 61.58x62.04.

2. The trader entered 9 sell orders from one account, at progressively lower prices. This brought down the ask to $61.65.

3. In a second account at a different broker, he was simulatenously buying, getting filled at an average price of $61.67.

4. In the original account, he then canceled the sell orders and the ask went back to the original $62.04.

5. He then ran the above steps in reverse:

   1. 10 buy orders pushing up the bid to $61.87

   2. Sold the shares in his second account at that price, collecting a $2.8k profit in 19 minutes.

So in sum, he sent fake orders to lower the price for his second account to buy in, then he made fake buy orders to raise the price for his second account to cash out.

It’s simple, definitely illegal, but that’s pretty much the end-game of spoofing.

Finding the ETF

The complaint anonymizes the ETF used, but it quotes exact prices at exact timestamps, which for anyone with a market data subscription is pretty easy to reverse-engineer:

• A mid-cap ETF trading between $61.58 and $62.04 on January 10, 2025

• I checked the daily bars for the obvious candidates and IJH, the iShares Core S&P Mid-Cap ETF, printed a low of 61.59 and a high of 62.20 that day.

  • Surprisingly, this is a $128 billion fund, one of the largest mid-cap vehicles in the world.

Next, I pulled the consolidated quote tape for IJH that evening, and the spoofing record is all there (chart below):

• At 6:25:46.107 p.m., a 300-share offer appears at $61.81 against the standing $62.04.

• The offer steps down through $61.78, $61.75, $61.71, $61.68, $61.65, exactly the ladder the SEC describes.

• At 6:31:31 it snaps back to $62.04 in a single update, which is what mass cancellation looks like.

• Then the bid walks up from $61.57 to $61.87, and starting at 6:37:19 you can watch him peel the buy ladder off tier by tier, about one cancel per second, until the final order dies at 6:44:05.336 p.m.

• Additionally, the complaint says “approximately 6:44:05 p.m.”, so there’s a good chance this was the actual trade.

The only thing that matters is the book

During regular trading hours (RTH) none of this works, and you can exactly why (chart below).

I pulled all 735,000 of that day’s IJH quote updates and computed the time-weighted spread by half hour:

Read more

The account is a real brokerage account, the order was a real order, and the only thing standing between a language model and the market was a config file I edited in a text editor. By Friday it held four positions, and I couldn’t reconstruct the reasoning behind a single one of them.

Taking a step back, this only exists now because every retail broker decided, roughly at once, that language models should be allowed to trade:

• Robinhood opened Agentic Trading on May 27 and extended it to crypto in July

  • Apparently, more than 50,000 customers connected an agent within weeks of launch, with daily volume in the millions.

• Coinbase shipped an MCP server for agent trading back in June

• eToro says its Tori assistant has crossed 500,000 trades across everything from equities to FX.

With so many attention-grabbing headlines, it naturally begged the question of whether this wave brings a genuinely useful research tool or just a slow-motion margin call.

So, I spent the week finding out.

MCP This, MCP That

Put simply, an MCP server is just a menu.

It tells the model, in a machine-readable format, which tools it may call: fetch a quote, list positions, check buying power, place an order, cancel one.

The model reads the menu, reasons about what it wants, and emits a tool call, and the broker’s server executes it against your account like any other API request. That’s the entire integration, which is why setup takes four minutes and why 50,000 people did it.

The guardrails, in every one of these launches, are variations on the same three ideas:

• A dedicated account holding only the money you’ve reserved for the agent

• A push notification on each trade

• A disconnect button in the app.

Robinhood’s own terms are admirably direct about where their responsibility ends, stating that the company “does not control, supervise, monitor, recommend, or audit” the agents you connect. You pick the model and write the prompt, so you own the outcome.

The budget cap constrains how much the agent can lose, but nothing anywhere constrains how it loses it: there’s no order-type restrictions, no position limits, no drawdown stop, and no rule about turning the whole account over eleven times a day (chart below).

Where It Actually Breaks

I’ve been running variations of this harness privately for a while, well before brokers made it a product, and the failure modes are consistent enough that I can rank them.

Surprisingly, the model’s stock-picking ability barely makes the list.

Read more

The fill came back in about a quarter of a second, a fifth of a cent per share better than the offer on my screen, and the confirmation email landed shortly after.

Pretty simple: you clicked, a computer matched you with a seller, done.

Naturally though, what wasn’t in the email was that my order almost certainly never touched an exchange.

In reality, my broker sold the order, a market maker filled it out of its own inventory from a data center in New Jersey, and the “better than the quote” fill was my cut of a pie that got divided three ways before I ever saw it.

Every junior quant eventually has to learn these mechanics, usually in fragments, so I traced my Ford order through every tollbooth to see who got paid along the way.

When you hit buy in a brokerage app, where does the order actually go, and whose P&L does it land in?

Hop one: your broker sells the order

To anyone who was around during the PFOF debacle with GME back in 2021, this part will be common knowledge, but it won’t hurt to start here.

At the end of the day, your commission-free broker’s routing decision is a revenue line. Wholesale market makers pay brokers for the right to execute their customers’ orders, which is the famous payment for order flow.

Interestingly enough, every broker publishes a quarterly Rule 606 report listing exactly which venues got its orders and what it was paid per hundred shares, and Robinhood’s disclosures even spell out the pricing model: the market maker pays a fixed percentage of the bid-ask spread on each execution.

Wide-spread names generate bigger checks than tight ones, so naturally, most of the profit comes from more illiquid stocks.

Per share it looks tiny, a fraction of a cent, but multiplied across a few billion retail shares a month it’s the reason “free” trading exists.

Hop two: the wholesaler keeps the spread

Now, remember how we were so confident that our order never touched the exchange?

Well, marketable retail orders overwhelmingly skip the exchange entirely: more than 90% of them are routed to off-exchange wholesalers and filled from the wholesaler’s own book.

The wholesaler business, like any high-barrier industry, is about as concentrated it gets, with Citadel Securities handling roughly 41% of retail market orders, Virtu 26%, and G1 another 16%, so three firms see more than 80% of everything retail does.

What makes the business so attractive to market makers is that, in theory, retail flow is the safest counterparty in the market.

An order for 100 shares of Ford from a phone carries essentially zero short-term information; nobody’s personal account is front-running an index rebalance.

When the counterparty is uninformed, the market maker gets to earn the bid-ask spread without the adverse-selection tax that comes from trading against people who know something, and the SEC’s own economists have a working paper walking through exactly this logic.

The wholesaler’s fill is where my “price improvement” came from. The quote on my screen was, say, $14.38 bid, $14.40 offered. The wholesaler filled my buy at $14.398, two tenths of a cent inside the offer, and booked the difference between that and wherever it lays the risk off as its own edge.

By some measure, it’s a win-win and everyone walks away feeling good: I beat the quote, the broker got its check, the wholesaler kept the fat middle of the spread.

The key thing to grasp is that price improvement is measured against the public quote, and the public quote is set on exchanges the retail flow never visits.

The wholesaler “improves” on a benchmark it is partly responsible for leaving wide.

That’s the sentence that made the whole industry make sense to me, and I’d hold onto it before forming an opinion on whether the arrangement is good or bad for the little guy.

Whether the benchmark itself would be tighter in a world where retail flow hit the lit market is an open-ended question.

Hop three: the exchange gets the leftovers

Read more

There were dozens of tools like it, odds overlays, portfolio trackers, copy-trade mirrors, stop-loss managers, and as of August 1st they’re all contraband. Google updated the Chrome Web Store policies to prohibit extensions that facilitate real-money trading on prediction outcomes, gave developers until August 1st to comply (rebrand from “arbitrage” → “simulated analytics”), and started pulling listings.

The same date was supposed to be a much bigger deadline. Minnesota passed a law in May making it a felony, up to five years and a $10,000 fine, to operate a prediction-market platform in the state, effective August 1st.

Fortunately (or unfortunately, depending on where you stand) that ban never arrived, as a federal judge blocked it two days early on the argument that the Commodity Exchange Act preempts state law, in a case where Kalshi, Polymarket, and the CFTC were all on the same side.

So, let’s tally up what happened on August 1st: a state legislature tried to ban the venues and got stopped in federal court, while an ad company banned an entire class of trading software by editing a policy page.

At this point, a pretty important question comes up:

If the arb bots just died, shouldn’t the spread between Kalshi and Polymarket show it?

Thankfully, it’s a measurable question, and I’ll get to the measurement, but it’s worth being precise about what actually died first, because “Google banned trading bots” gives the bots more credit than they earned.

What on Earth is a “Browser Bot”?

The extension ecosystem around these venues was bigger than most people realize: odds converters that reprinted prices in American or decimal format, wallet trackers that showed you what the accounts you follow were buying, stop-loss managers promising professional-grade risk management from a browser popup, and so forth.

An extension reads prices after the site posts them, injects its own buttons next to the real ones, and when it wants to act, it either simulates your click or calls the venue’s own client-side endpoints from within the page, wearing your session cookie.

That architecture, while effective, put a hard ceiling on how fast or how big these things could ever get. The loop is: venue updates, page renders, extension reads, extension decides, extension clicks.

On a good day that’s a few hundred milliseconds behind the book, on a normal day it’s seconds, and the whole thing is throttled by the same public rate limits your browser tab gets, on one retail account, at retail size.

The full stack looks like this (diagram below).

Google’s policy deleted exactly the top layer of that diagram, but everything underneath is untouched.

Kalshi uses a real central limit order book behind public REST and WebSocket APIs, and Polymarket matches orders off-chain against a book of its own before settling on-chain; so if your bot spoke to the book directly, August 1st changed nothing for you.

Who’s Trading This Stuff, Anyway?

The marginal spread on both venues stopped belonging to retail tooling a long time ago.

Read more

Every time that pair of numbers makes the rounds, the same idea follows:

“both of these things are decay machines by construction, so short $100 of each, net out the market, and collect the drag from both sides at once.”

took a run at it in July and landed about where the academic literature lands, the decay is real but frictions eat a meaningful chunk of it.

Now, if you’ve been reading our work for awhile, you know that we love nothing more than these kinds of potentially scalable, market-neutral edges.

So naturally, I wanted to look at the data myself: the borrow in actual dollars, the margin it locks up, what the rebalance schedule changes, and what the tail did across the full sample.

So, I rebuilt the whole thing from scratch and ran every version of the trade side by side.

Short $100 of TQQQ and $100 of SQQQ. Where does the money actually go?

Why there’s drag to harvest

Both funds promise 3x the daily move of the Nasdaq-100, and the daily part is where we need to look: they reset leverage every close, so over any horizon longer than a day the compounding takes over:

• If the index goes up 1% and then down 1%, it sits 0.01% lower while the 3x fund sits 0.09% lower. What makes the trade tempting is that the minus-3x fund is also down 0.09%.

A flat, choppy market grinds both legs down simultaneously, and a short position in both collects the grind.

In theory, the harvest should scale with realized variance, and in the data it does: the yearly gross P&L of the pair short correlates with the Nasdaq’s realized variance at 0.60 across the sample (2015-2026).

So, right off the bat, chop pays.

The Reddit version

The Reddit version is as crude as it gets: short $100 of each in January 2015, walk away, let both legs rot.

The SQQQ leg performs exactly as advertised and hands you the full $100, since a short’s gain caps out at the entire value of what you sold, but the TQQQ leg is where you’re effectively guarnteed to blow-up.

A short’s loss has no cap, TQQQ went up 37x, and what started as a $100 short liability compounds into a $3,698 position you owe.

The pair finishes down $3,498, and at the low in June 2026 it was down $4,132 (chart below).

Rebalancing fixes it

Now, obviously the naive version doesn’t work; so at this point, we can ask ourselves a simple question: instead of just holding forever, what if you just rebalanced the position frequently?

Fortunately, this is where things get good.

Read more

That’s about $2.5 million at the $77,135 average the filing reported, out of a treasury that measures its position in the hundreds of thousands of coins, and it was the company’s first sale in over three years.

The disclosure was one line in an 8-K filed June 1, the kind of housekeeping detail an analyst skims on the way to the leverage tables.

It flipped a $60 million Polymarket contract from a near-certainty into an 81-cent panic, drew two formal resolution proposals that both got challenged, went to a token-holder vote, and as of July it’s the subject of a lawsuit in the New York Supreme Court.

I spent this week reading everything that line broke.

A market about a thing that never happens

The contract was “MicroStrategy sells any Bitcoin by May 31, 2026?”, and for most of its life it was one of the most boring things on the venue.

Saylor’s entire public identity is that he never sells, so YES traded down at a few cents the way deep out-of-the-money puts trade at a few cents:

someone is always willing to hold a lottery ticket, and someone else is always happy to collect pennies for insuring an event that never happens.

About $60 million of volume went through on those terms.

And if you were short YES down there, you were arguably making the cleanest bet on the platform:

• The company files everything with the SEC

• The treasury wallets are watchable on-chain

• The one man who decides whether to sell gives interviews about never selling.

As forecasting problems go, there was almost nothing to get wrong.

June 1, 81 cents

On June 1st, the 8-K landed:

• The sale executed between May 26 and May 31, which sits inside the market’s window.

• The disclosure arrived June 1, which sits one day outside it, since the contract’s cutoff was 11:59 PM ET on May 31.

Within hours YES had spiked from low single digits to 81 cents as traders piled into what looked like a resolved question, because the filing said, in plain SEC prose, that the thing the market asked about had happened on time.

Polymarket’s team then pinned a clarification to the market page, which is what the next two months of fighting were about:

“Confirmation achieved outside of the market’s time frame does not qualify.”

Read one way, the market asked whether Strategy sells by May 31, Strategy sold by May 31, done.

Read the other way, a market has to be resolvable from information available inside its own window, and on May 31 no filing, no on-chain evidence, and no credible reporting confirmed any sale.

Both readings are coherent, which was pretty much the problem as the resolution text supported either or.

I pulled the contract’s price history and annotated the whole arc (chart below)

That middle nub, where YES hovered near 12 cents for days, is a beautiful representation of how markets become efficient. By then, the original outcome was pretty much established (he sold the Bitcoin), so the price at 12 cents acted as a proxy for how the hundred or so pseudonymous token holders would vote on the final outcome.

“Pseudonymous token holders” might sound like jargon-slop at first glance, but if you’re getting into prediction markets, you quite literally need to know how they work.

Two disputes and a token vote

Polymarket outsources settlement to UMA’s optimistic oracle:

• Anyone can propose an outcome by posting a bond, and if nobody challenges it within a couple of hours, it stands.

Almost every market resolves this way, cheaply and instantly.

The keyword here is almost, as this one went a bit differently:

• Someone proposed “No” and got challenged, a second “No” proposal followed and got challenged too, and after that the question escalated to UMA’s voting layer, where UMA token holders pick the outcome and voting power is proportional to how many tokens you hold.

The ballot had three options: settle it “No” on the announcement-timing reading, settle it “Yes” on the event-timing reading, or call it too early to resolve.

By the end, about 98.6% of voting power went “No”, the vote wrapped June 4, and YES went to effectively zero.

One account had bought roughly 50,000 YES shares for about 35,000 USDC after the 8-K dropped, which is to say they paid about 70 cents a share for a claim on an event that had already, verifiably occurred, and they collected nothing.

Another trader claims he lost $500,000 on the same trade.

On July 3, two of them sued Polymarket and its executives in the New York Supreme Court, alleging breach of contract and deceptive practices and asking for the full $1.00-per-share redemption value.

Who counts the votes

So the natural next question is who these voters are, which is what the Wall Street Journal spent the spring answering.

Their analysis of UMA’s voting records, published about two weeks before this dispute, found that:

• At least 60% of active UMA voters are linkable to live Polymarket accounts

• The ten largest wallets carry more than half the voting power in most disputed markets

• In roughly one in five disputes, at least one voter held a financial stake in the very outcome they were ruling on (chart below).

None of that proves this particular vote was corrupt, and to be fair, a 98.6% landslide doesn’t need any self-dealing to explain it. Still though, you have to admit it’s… interesting.

In any regulated corner of finance, an arbitrator with a position in the case is a Bloomberg-headline-turned-arrest, but in prediction markets, it’s pretty much the default.

What you’re actually long

If there was any general lesson to pull out of this, I’d say:

• A prediction-market contract is a package of two bets: one on the event, and one on the resolution process agreeing with you about the event.

  • On the happy path, the second bet is invisible and free, so everyone prices these contracts as if the first bet is the whole product.

This episode highlights what it looks like when that “free” second bet gets nasty. It happens exactly when the outcome is ambiguous and the money at stake is large, since that’s when someone finds a dispute worth bonding. And you can’t hedge it, because your counterparty in the settlement fight may literally be the one voting.

For the sellers of long shots, the pennies-collecting crowd, this is something you need to be aware of. You’re likely already automated, so at the very minimum, pass in the contract’s resolution rules to an LLMs API to get a score on the ambiguity of the settlement; it might be the only thing that keeps you in business.

Final Thoughts

I love prediction markets, and none of this changes the fact that they price ordinary events well and settle nearly all of them without drama.

As we covered in our "Bonding Bots" in Prediction Markets post, you really can run a solid business of executing high-probability trades, but the settlement risk will always be there.

So, if you’re just getting started and want to trade these markets, then at the very minimum, just keep that in mind.

As always, thanks for reading, and we’ll see you in the next one.

You’ve been trading your own account for a few years and the track record is real: a decent Sharpe, a small following, and a few calls that aged unusually well.

Suddenly, an email lands from a quant fund you’ve never heard of.

There’s no job in it, but for some reason, the fund wants to buy your trade ideas: ticker, long or short, a time horizon, how confident you are, all submitted through a portal.

If the ideas work, you get paid. Nobody interviews you, nobody audits your model, nobody even asks for a resume.

A multi-billion dollar quantitative fund, the kind of shop that measures execution slippage in fractions of a basis point, wants to wire money to strangers on the internet in exchange for stock picks.

The whole thing reads like a phishing attempt. However, it’s real.

In fact, that model has been running for over two decades, and the industry calls it alpha capture.

So today, we’re going to walk through where it came from, what actually happens when you hit submit, and what happened when two siblings in a London flat figured out how to game it.

It Started With an Argument

In 2001, the two founders of Marshall Wace had a disagreement.

Ian Wace, formerly Deutsche Bank’s global head of equity trading, and Paul Marshall, ex-Mercury Asset Management, couldn’t agree on whether the stock recommendations brokers constantly phoned in were actually worth anything.

To settle it, they handed the problem to a fresh graduate named Anthony Clake:

“build a system that tracks every broker idea and measures whether following them makes money.”

The first version was an Excel spreadsheet that eventually became TOPS, the “Trade Optimised Portfolio System,” and in July 2002 it started trading real money through the Eureka Fund.

In its first full year it returned +23.9% gross while the market benchmark fell -21.1% (chart below).

The scaling from there was aggressive. By 2005 the London operation was ingesting 800 to 900 ideas per day, and the firm had collected roughly half a million trading ideas from 2,200 individuals across 246 securities firms.

Marshall Wace was paying brokerage firms over $250 million a year by 2004-05, and Wace described it himself:

“All TOPS is a Hoover... It sucks in great quantities of ideas and tries to sieve out what is interesting.”

Clake made partner in 2004, is now the firm’s third-largest owner, and reportedly took home around $330 million in a recent year. TOPS vehicles run roughly $30 billion today.

Too Good to Be True

If you wave dollar bills in the air and tell people you’ll pay them for trade ideas, eventually, you’ll get people who do whatever it takes to get paid.

Squarepoint Capital runs offices in London, New York, Singapore, Dubai and Paris.

Oerta Korfuzi, an Albanian day trader, submitted trade ideas to Squarepoint’s alpha capture program through an entity called Pelkor Capital. She shared a London flat with her brother, Redinel, a research analyst at Janus Henderson.

Her ideas were good. Specifically, they were short ideas on names about to announce dilutive equity raises, and they were remarkably well-timed.

Part of her brother’s job involved “wall-crossing” emails: confidential notices from companies gauging investor interest ahead of equity raises and block sales. If you know a company is about to announce a dilutive raise, you know its stock is about to drop.

Within minutes of those emails hitting Redinel’s inbox, trades went off in accounts operated by his sister.

The instrument of choice was CFDs, leveraged shorts on the exact names about to announce. Between 17 December 2019 and 25 March 2021, the pair traded ahead of announcements in 13 stocks, clearing over £960,000 in profit.

Now, what separates this from garden-variety insider trading is that the same information was being monetized twice.

Once through their own leveraged trading. And once more, sold to a quant fund as a “signal” through Pelkor Capital.

Think about what Squarepoint’s platform saw:

• a contributor whose short ideas kept hitting within days

• a hit rate a legitimate analyst would kill for

• alpha with almost no decay, because the catalyst was already scheduled

Prescience and inside information look identical in a track record.

Worse than identical: the insider scores better. Higher hit rate, faster payoff, cleaner alpha versus benchmark (chart below).

A system that pays strangers for prescient ideas has no easy way to ask why the ideas are prescient.

The FCA (UK version of the SEC) caught it the way modern regulators catch most things: market surveillance and trading-pattern analysis across large datasets. The trades clustered too tightly around announcements Redinel had been wall-crossed on.

Investigators also found 173 deposits funneled to Albania and about £25,000 in cash sitting in a Knightsbridge safe deposit box.

Both siblings were convicted in 2025; Redinel got 6 years, Oerta got 5.

How It Actually Works

While the high-level version of this is interesting on its own, things get really quirky when you look at the finer parts.

Read more

• The game is in the 9th and one team is up eight runs

• The election has been called

• The movie has already premiered, whatever.

A “bonding bot” systematically buys these near-certain contracts and collects the last few cents at settlement. Institutional bond traders typically call it pull to par, as you’re buying something at a discount to face value and clipping the yield as it matures.

The math on it is honestly seductive, at first:

1. Buy YES at $0.98.

2. Contract settles at $1.00.

3. Collect $0.02, roughly 2% on capital, often within minutes.

4. Recycle the capital into the next “decided” event.

5. Repeat across every market on the board, every night.

Run that loop across a full slate of outcomes and the equity curve looks gorgeous. Straight line up, win rate north of 99%, the kind of thing that screenshots well.

The problem, however, is the skew. When you buy at $0.98, you’re risking 98 cents to make 2, so one miss wipes out roughly 49 perfect trades.

The payoff profile (chart below) is a long staircase of two-cent steps up, and a trapdoor that gives back all of them at once:

It’s the same profile as selling deep out-of-the-money puts: a long stream of small wins funding one occasional catastrophic loss.

The Run That Didn’t Count

On July 24, that trapdoor opened at Oracle Park, a little after 1 a.m. Eastern.

We’re not a sports publication, so to keep things high-level:

• In the final inning of a tie game, Team A made a play that visually won it by multiple runs

• Data feeds posted the multi-run final and bots rushed the “win by 2+” contracts up to $1

  • Volume went from 11,149 contracts to 5 million in a few minutes.

• The official scoring was subsequently corrected under an MLB rule

• The “bond-like” contracts closed the market at $0, with aggregate bonder losses in the seven figures.

This was the last game of the night, so a good chunk of that carnage likely happened while the owners of those bots were asleep. Kalshi appears to have paid traders on both sides afterward, though there’s no official postmortem on the mechanics yet:

Now, believe it or not, even after a face-plant like that, running one of these can be genuinely profitable with a bit of sophistication.

Well, Maybe a Bit of Free Money

A naive bonding program essentially buys anything with a high price:

while markets_open:
    for market in board:
        if feed_status == "final" and ask < $1.00:
            buy(everything)

In contrast, a more sophisticated operator knows which two cents are actually free, and it generally doesn’t even take that much.

Read more

“The night before every earnings report, the options market publishes a forecast of how far the stock is about to move. But is that forecast any good?”

That question has been sitting in our research notes for a while, and it turns out to be one of the cleanest studies you can run with public data.

It’s a strange forecast to begin with. No analyst signs it, nobody defends it on CNBC, and it’s backed by real money on both sides.

It also gets graded automatically. The report drops, the stock moves, and the forecast was either too big or too small. Every quarter, for every listed name, forever.

Yet almost nobody keeps score. Sell-side analysts get their price targets mocked on Fin-Twit every quarter, economists get their CPI calls stomped within seconds of the print, but when was the last time someone overpaid for vol and called for a brand new options pricing model?

So today we’re going to walk through this little corner of the derivatives business, end to end, the same way we’d run any event study on the desk.

It’s Essentially a Betting Line

The forecast lives in the ATM straddle: the call and the put at the strike nearest the stock price, bought together.

Say a stock trades at 100 the afternoon before it reports, the ATM call costs 2.60 and the ATM put costs 2.40, so the straddle costs 5.00.

Whoever buys it makes money only if the stock ends more than 5 points away from 100, in either direction. Whoever sells it keeps the premium only if the stock stays inside that band.

Divide the straddle by spot and you get the break-even as a percentage:

5.00 / 100 = 5%

That ratio is the implied earnings move: the size of move at which straddle buyers and straddle sellers both walk away flat.

The reason we call it a forecast is that it gets set exactly the way a betting line gets set:

• If traders collectively believed the stock would move 8% on the print, a 5.00 straddle is free money and they’d buy it until the price rose.

• If they believed 2%, they’d sell it until the price fell.

The price settles where the marginal buyer and the marginal seller cancel out. A live, money-backed consensus estimate of the move’s magnitude.

There’s also a mechanism-first reason to suspect the line might sometimes be off:

• Market makers are obligated to quote through the event, and every quarter a reliable crowd shows up on the other side: hedgers protecting positions through the print, and speculators buying the straddle as a lottery ticket.

  • Someone has to warehouse all that demand, and warehousing risk you can’t hedge away commands a premium. That premium lives inside the straddle price, which means it lives inside the forecast.

A suspicion isn’t a result, though, so let’s see what the data actually says.

Don’t Botch the Clock

The first rule of the loop we run on every event class: write the hypothesis down before touching data, precisely, so the data can’t seduce you into testing a prettier claim later.

Hypothesis: The earnings move implied by the options market is, on average, larger than the move that gets realized.

Yes/no answer, with a clean, measurable magnitude.

Now, when working with earnings data, it’s especially important to make sure you’re tracking the clock.

Earnings come in two flavors, bmo (before market open) and amc (after market close):

• The capture date is the last session that closes before the announcement. That close is where the straddle still contains the full event premium, so it’s where the implied move gets read.

• The reaction date is the first session that trades after the announcement, the one that absorbs the move.

For a company reporting amc on Tuesday: capture Tuesday, reaction Wednesday. For a company reporting bmo on Tuesday: capture Monday, reaction Tuesday, because by Tuesday’s open the answer is already out.

This is why we like event datasets that carry the alignment explicitly. In the earnings-move-history data we use, every row is one event stamped with its timing (bmo or amc), its capture date, and its reaction date, alongside implied_move_pct and realized_abs_move_pct measured at exactly those moments.

Was the Market Right?

With the clock handled, the measurement is pretty straightforward.

The core metric to track is the implied-minus-realized spread, event by event:

events["spread"] = events["implied_move_pct"] - events["realized_abs_move_pct"]

print(f"Events:      {len(events)}")
print(f"Mean spread: {events['spread'].mean():.2f}pp")
print(f"Hit rate:    {(events['spread'] > 0).mean():.1%}")

Three numbers, and each one earns its place:

1. Event count tells you whether you have evidence or an anecdote. Eight events is a story; several hundred is a distribution.

2. Mean spread is the headline: on average, was the forecast an overestimate?

3. Hit rate tells you the distribution of outcomes. A positive mean driven by 55% of events is a very different animal from one driven by 90%.

Run this across broad universes of liquid names and you land on the population verdict: the implied move has historically tended to overshoot the realized one. The line runs rich, on average, exactly the way the warehousing story predicts (chart below).

Interestingly enough, this is where most write-ups stop, declare victory, and back into a short-straddle strategy.

It’s also where the study starts getting good, because a population average is a blunt instrument. It says the crowd overpays on average, but it says nothing about who.

Okay, So Who?

Some names overprice their own earnings move nearly every single quarter: the street buys the straddle, the report drops, and the stock moves half of what was priced in. Other names, far rarer, keep delivering more than the market priced.

So, the question narrows from “does the market overpay?” to “who does the market chronically overpay for?”

In the dataset, every event row carries the name’s running record as of that event:

• n_events_to_date: how many events are on record.

• hit_rate_to_date: the share of past events where implied overshot realized, on a 0 to 100 scale.

• avg_over_under_to_date: the trailing average of implied minus realized, in percentage points.

• overpriced: the outcome on this specific event.

Now, the _to_date suffix is doing more work than it looks like:

• Each row’s running stats are computed only from events up to and including that row’s date, then frozen into the row forever.

• Which means a backtest that ranks names by hit_rate_to_date on some historical date is ranking on exactly the information a trader standing on that date could have had. Look-ahead bias, the classic backtest sin, is designed out of the data from the start.

Reading the records, you’re looking for three things at once (chart below):

1. A high hit rate, say above 75. The straddle overshoots most quarters, habitually.

2. A bias big enough to survive costs. A +0.2pp (percentage points) average is real but untradeable after spreads; a +2pp average is a different conversation.

3. Enough events to believe it. Roughly 12 or more, three years of quarters. A perfect record over 4 events is a coin that came up heads four times.

A name that clears all three is what the market calls a chronic overpricer: the market keeps buying its event insurance rich, quarter after quarter, and the record says so in writing.

The public snapshot begins in 2024, so no name yet clears that 12-event conviction floor. Using a deliberately looser eight-event floor only to show what the live ranking produces, the top three candidates in this snapshot were:

Final Thoughts

Notice what never happened in this walkthrough: nobody predicted a single quarter. The entire edge came from being the one who bothered to grade the forecast.

Everything to this point gets you a list of suspects, though. Turning that list into a position is its own discipline: checking whether a name is charging its usual rich price right now, gating the watchlist ahead of the reporting week, and attacking whatever survives for the tails, regimes, and costs that can erase a +2pp edge.

We go substantially deeper into that discipline, deploying this exact study into a trade, in Module 5 of Alphanume Learn: you build the chronic-overpricer tally and the full pre-earnings screen yourself, live in the browser, against the same dataset we just used.

Learn is the series we created to be the first of its kind: an interactive quant curriculum that goes genuinely deep into systematic, event-driven trading. Twelve modules, one research loop, run on volatility, 0-DTE, dilution, de-SPACs, defaults, and the rest of the catalog.

Module 1 is free, and the full course is included with Alphanume Pro ($99/month).

Start with Module 1 (free) →

As always, thank you for reading, and we hope to see you in the next one.

To see why anybody would want that, put yourself behind a gas utility desk:

Ten weeks into winter somewhere in the Midwest, and nothing has broken. No pipe burst, no substation dropped, no crew got called out at three in the morning.

The winter is just… mild. A few degrees above normal, day after day.

Every therm (unit of gas) you didn’t deliver is a therm nobody pays you for.

Now, remember, you still own every mile of pipe, you still staff every crew, and you still service the same debt.

Mild winter → fewer therms out the door → lower revenue

By March you’ve missed guidance, and everyone on the call knows why.

So, you call your broker to ask what it costs to insure against this next year, but find that nothing really exists.

Insurance pays on a loss event, something discrete that an adjuster can drive out to, photograph, and attach a number to. When all you’ve got is a furnace in a house in Wisconsin that cycled on four fewer times a day for two months, you don’t really have a claim.

At this point, you ask a question:

“How do you still make a profit, even when the weather acts against you?”

Fortunately for you, this is the whole idea behind weather derivatives.

It’s a niche market, tiny compared to equities or rates, and almost nobody outside a handful of trading desks and utility hedging teams actually trades it.

Even so, the mechanics are elegant once you see them, and the fact that this market exists at all tells you something about how far derivatives can be stretched once you’re willing to turn anything measurable into an index.

So today, we’re going to take a quick journey into the strange land of trading weather futures.

How Does This Stuff Even Work?

The whole market rests on the degree day.

Heating and cooling demand tracks how far temperature strays from 65°F, the rough point where a building doesn’t need the furnace or the AC. That’s the industry convention, and it’s the base of almost every US contract written.

From there, each day converts into one of two numbers:

• HDD = max(0, 65 - average daily temperature)

• CDD = max(0, average daily temperature - 65)

Average daily temperature is the day’s high plus the day’s low, divided by two.

A 50°F day gives you 15 HDD and 0 CDD. An 80°F day gives you 0 HDD and 15 CDD (chart below).

Cold day → HDD. Hot day → CDD. 65°F → nothing happened.

Sum the daily values across a month or a season at one weather station and you have a cumulative HDD or CDD index.

Just Add It Up

At this point, seeing how this maps to a tradeable product likely seems vague, but it’s actually pretty simple:

1. Pick a city and a period, either a calendar month or a multi-month seasonal strip. CME designates one weather station per city.

2. Convert each day, taking the station’s reported temperature and adding the resulting HDD or CDD to a running cumulative total.

3. Settle on the total. At expiration, that cumulative number is the settlement index.

4. Multiply. For US cities the contract unit is $20 times the cumulative index. A 31-day month averaging 55°F throughout is 310 cumulative HDD, worth $6,200 per contract.

5. Pay in cash. Whoever was positioned for a colder or hotter month than showed up pays the difference.

Run it through our utility desk from the top of the post and it looks like this:

• The exposure: a low-HDD month is what hurts you, since fewer degree days means fewer therms sold

• The position: short 20 contracts at the market’s 310 HDD level

• Riding on it: 310 × $20 × 20 = $124,000

The month comes in warm. Your station stops at 260 cumulative HDD.

• Settlement index: 260

• Move against the level: 310 - 260 = 50 HDD

• Hedge P&L: 50 × $20 × 20 = $20,000

The 50 degree days you didn’t get are the same 50 degree days the contract just paid you for.

Where Trading Gets Interesting

As usual, every market built for hedging ends up attracting people with nothing to hedge. Weather is no exception as whoever took the other side of that utility’s short doesn’t own a mile of pipe and has never sold a therm in their life.

To see how, let’s work through a real-world edge-case:

Read more