Robinhood calls it Instant Deposits, which starts at $1,000 without a subscription, or $5,000 if you pay for Gold, while Webull and Moomoo offer their own versions under the same “instant buying power” theme.

Effectively, it’s a free, short-term loan extended to anyone with an account.

As we covered in our last post on Abusing Microcaps at Scale, if you wave free money in the air, it’s inevitable that someone will find a way to take as much of it as they can.

Not surprisingly, a group in New York saw this free money and ended up using 600+ brokerage accounts to trade options among themselves, leading to a haul of more than $2 million over 4 years.

Of course, the way they did it was extremely illegal, but how they picked their options and opened so many accounts is rather fascinating, and I think you’ll agree.

So today, we’re going to reverse-engineer exactly how it worked: what they traded and why those contracts were perfect for it, how much they made on every account they burned through, and why trying this today might be a bit harder than you’d think.

The problem with free money

As you might already know, while you can trade the instant deposit from your broker, you can’t immediately withdraw it.

Until the ACH bank transfer actually clears, brokers won’t let you withdraw the credited cash, and if a transfer bounces, the credit gets pulled right back out of your balance. So, if you deposit money you don’t have and the trade goes your way, the profit will be stuck in an account that’s about to get frozen.

Naturally, this begs the question:

How exactly do you get the money out of an account that never had any money in it?

Interestingly, the answer is that you lose it on purpose, to an account you control at a different broker.

How it actually works

Read more

In short, these are just a breed of funds that exclusively trade futures like oil, nat gas, coffee, and so on.

What got me interested in these was seeing the headlines you’ve also likely seen, about how the 10-year Treasury yield has been on a non-stop rally back to 2007 highs.

But more importantly, it looks like it’s a major trade on CTA desks:

As of writing this, leveraged funds are net short about 1.9 million 10-year note futures, a position that makes money as yields rise, so clearly there’s still some life on this part of the spectrum.

We’ve covered our multi-strategy approach previously, but commodity futures are a genuinely new territory for us, where our starting arsenal is weak.

Nevertheless, with this much activity (~$350B industry AUM), we felt that it would be foolish of us to not at least try reverse engineering how the money is made here and seeing if there was anything we could run ourselves.

So today, we’re going to crack this style of trading wide-open and walk you first-hand through the nuances of the real strategies used, why it’s “easier” than you think, and why systematic commodities trading is never going away.

So, without further ado, let’s get right into it.

The data kinda sucks

The big-picture of what these funds do are pretty simple:

1. Commodity/future goes up on a macroeconomic driver

2. Buy

3. Macroeconomic driver changes or stops having an impact

4. Stop buying

So, in order to replicate that for ourselves, we first need data, and lots of it.

However, right off the bat, we ran into the major challenge that comes from working with these products.

Specifically, since futures contracts expire, you have to stitch the proper months together in order to get a clean price series to model.

The hard part is that the new contract trades at a different price than the old contract, so on the day of the switch (the “roll”), there are huge price jumps that aren’t exactly real.

• For instance, let’s say Hog futures expire on October 31st and December 31st. On October 31st, that front month might be trading at $80, but the next December future might be trading at $85. A naively stitched series would show a fake 6% jump.

So, before starting any strategy work, we took some time to clean the data, which pretty much looked like this:

1. Dropping the junk bars, like zero-volume holiday prints and switches to the wrong contract

2. Manually finding each market’s roll day

3. Removing the gap on that day, so the series only carries returns you could’ve actually earned

To check the work, we compared the cleaned series to ETFs that hold the same thing (e.g., copper futures to CPER), and after allowing for the interest those funds earn on cash, Treasuries tracked to within 0.1% a year and most commodities to within 1% to 2%.

So, once we had the clean data engine in place, we pulled ~30 years of data for every tradeable commodity and non-index future, then got to work on finding out what made money.

It’s Easier Than You Think

Read more

The Quant's Playbook

Behind The Scenes of a Profitable Short Selling Operation

For most market participants, the playbook is simple: buy quality assets, hold on, and let compounding do its work. And honestly — it’s good advice. One glance at the S&P 500 over the last decade explains why it’s become the gold standard of investing…

Read more

a year ago · 24 likes · 2 comments · Quant Galore

To quickly recap, we essentially trained a classification model on features of microcap pre-market trading activity to isolate the names most likely to drop more than 5% intraday.

Once we have the model outputs each morning, we size an equal-weighted basket based on a % of NAV, request share locates, then submit market-on-open orders to ensure we get filled at the official opening price.

We haven’t spoken much about it since, but we’ve gotten a lot more serious about how we run this, both in terms of infrastructure and, more importantly, scale.

After all, if you have an extremely effective process but the reason you don’t make more from it is that it’s vaguely “capacity constrained”, you’re potentially leaving a lot on the table.

So today, we’re going to go deep on this and show you what it looks like to run real money behind this. We’ll cover automating the entire process (even the difficult locates), running market-impact models to find the actual amount we can scale to, and get into some live data you likely haven’t seen before.

So, without more waiting, let’s get right into it.

Scale, Scale, Scale!

My bias for seeing the strategy as ultra-low capacity was the visibly low market caps of the names (some <$10m) and the bad aftertaste of getting partial fills a few times.

However, I never did the actual math on the true volume we could theoretically move.

So, to begin, I pulled the opening-auction data for every name the dataset has flagged at $1 or more, which came out to 3,348 unique observations across 582 sessions, since May 2024:

• The median name clears just $73k in its opening auction

• The bottom 10% clear $8k or less

• For the median name, the auction is only about 0.4% of the day’s regular-session volume

• A typical morning’s whole basket (about 5 names) clears around $670k combined

Surprisingly, the numbers got a lot more interesting when I split up the names by auction size and looked at how they performed:

The smallest 20% of names averaged about zero, while the largest 20% averaged +4.7% per trade with a 71% hit rate, so even with a bumpy middle, the names that can hold size are also the ones that have the most edge.

Capacity Modeling 101

Knowing how big each auction is gives us a helpful start, but we still have a bit more work to do to get a usable number.

To get that number, I replayed the live strategy (short at the open, cover at 14:00) over every session in the dataset, with a few realistic limits. Namely, a participation cap that assumes our size can only be at most 10% of each name’s opening auction.

We’ll also use a standard square-root impact model on both legs, which basically charges more the bigger you are relative to the day’s volume.

Given what we found regarding auction performance, I tested two ways of splitting up the order sizes:

1. Equal weight, which is what the live program does today, where every name gets the same slice of the day’s budget.

2. Sized by auction, where each name’s slice is proportional to its opening-auction size, so the bigger auctions take more of the money.

For instance, say you have $30k to short across three names:

• Name A: $20k auction, so at most $2k fits (the 10% cap)

• Name B: $100k auction, so at most $10k fits

• Name C: $180k auction, so at most $18k fits

Equal weight gives each name $10k:

• A only takes $2k, so $8k goes unused

• B takes the full $10k

• C takes the full $10k, even though it had room for $18k

• $22k filled (73%)

Sizing by auction splits the $30k in proportion to each auction’s size (20 : 100 : 180):

• A gets $2k, B gets $10k, C gets $18k

• Every order fits, so $30k filled (100%)

Running that same comparison across every session gives us the graph below:

A quick guide on reading this:

• The bottom axis is how much you try to short each morning, where each step to the right is 10x bigger

• The side axis is how much you actually get on an average day

• The dashed line is the dream scenario, where every dollar you ask for fills

At small sizes (e.g., <$10k), you basically get everything you ask for, but as demonstrated, the auctions simply start running out of room the bigger you get.

If we were to stick to the equal-weight approach, we’d be getting less than 90% of what we ask for once we hit ~$9k a day.

However, if we size by auction, we’d get filled 92% of the time once we hit ~$26k a day.

It’s still small relative to major index strategies, but at least we have a real number to work from and not just “it’s low-capacity”.

The Real Life Version

To see how this works in practice, let’s walk through this morning’s real basket, where one of the names fell over 60% before we covered it.

At ~09:08, the dataset returned four names priced at $1 or more. MSGY came in ranked second with a 0.695 probability of dropping, after running +320% over the prior five days on a stock that was down 94% over the past year.

It’s definitely not state of the art, but we run this on a Windows Cloud PC (basically a Windows desktop that lives in Microsoft’s data center and never sleeps) with two scheduled tasks that manage the orders and locates, with backup triggers and retries so a missed start or a crash doesn’t cost us the day (diagram below):

Some data from today’s real execution:

1. Locates

   1. The program asked TradeZero for locate quotes on all four names and declined LABT, whose fee came in at $0.125 a share, above our 5% of notional cap.

2. Entries

   1. The other three went into the opening auction as market-on-open short sales, and MSGY filled at $8.25 (the “official” open price)

3. Exits

   1. At 14:00 (2PM EST), the program placed buy-to-cover limits at the ask, re-pricing every 30 seconds, and all three filled within about a minute.

      1. TradeZero’s API doesn’t accept market-on-close orders, unfortunately

PnL:

• MSGY: shorted at $8.25, covered at $3.08, +62.7%

• PMAX: shorted at $1.77, covered at $1.37, +22.6%

• GYGY: shorted at $1.23, covered at $0.97, +21.3%

This came out to an average of about +35% across the three, with locates costing between 0.7% and 2% of each name’s price (LABT, the one we passed on, was also down about 34% by midday).

I was curious about how much extra size we could’ve added, so taking the math from above, I re-ran today’s numbers. With our assumed 10% cap of auction volume, that gives us:

• MSGY: a $77k auction, so we could short about $7.7k

• PMAX: a $21k auction, so about $2.1k

• GYGY: a $653k auction, so about $65k

At full capacity, that comes out to about $75k across the three names, which is a bit under the ~$95k average ceiling, though still more than I’d have guessed.

Running it yourself

Everything the program trades comes from Alphanume’s Pre-Market Drop Risk dataset, which publishes around 09:08 ET each morning, with history going back to May 2024.

Each row gives you the model’s prob_drop, the day’s rank_for_date, and the last pre-market price. After the close, it adds the actual intraday return, so you can reconcile every output yourself.

It’s included in Alphanume Pro, along with the REST API, the hosted MCP server, and live-trading rights. As such, replicating this is pretty simple:

1. Pull GET /v1/premarket-drop-risk?date=YYYY-MM-DD&min_price=1 from about 09:08

2. Size each name by its pre-market dollar volume, capped at a small slice of its typical opening auction

   1. In practice, you won't know the size of today's auction at 09:08, so the live version uses pre-market dollar volume as a stand-in, which tracks auction size closely and performs about the same in the model.

3. Quote locates and only accept the ones under your cost cap (e.g., <5% of position notional)

4. Send market-on-open short sales before about 09:25

5. Cover at 14:00 with limits at the ask, re-pricing until filled

6. Schedule both jobs on a machine/server that never sleeps

Final Thoughts

Although this strategy isn’t new to us, we never took the time to actually build out a market impact model to know how much we were really able to scale up to.

The first obvious change on our end is looking deeper at the auction and imbalances themselves as potentially new features, since they consistently mapped to higher short returns over the sample (t-stat of ~3.2).

As stated before, I genuinely don’t expect this specific approach to stop working anytime soon (no matter how many people read this), as the adverse selection of the pool being an illiquid, low-quality segment just lends itself to negative forward returns. For it to stop, you’d have to come up with a pretty good reason for why large chunks of the market would suddenly want long exposure to these toxic names.

I hope that by the end of this, you were able to get a sense of what it looks like to find the true capacity of a trade, and in the best case, were inspired enough to pull the data to replicate and re-work what we found.

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

1. Market participants pay premiums for contracts tied to unlikely events

2. You sell them those contracts and collect said premiums

3. Once in a while, the event actually happens, and you have to pay back some premiums

4. Repeat

Where things get tricky is when you realize that everyone else is also aware of this, and thus the contracts are pretty close to efficient.

For instance, if you’re offered a spread with a 95% implied probability of expiring worthless, it will do that ~95% of the time.

Stats 101 tells us that such an offering results in 0 EV, so even if you derive an approach that makes money the majority of the time, your equity curve will generally look like this:

Fortunately though, it doesn’t have to be this way.

Remember, selling options is essentially underwriting insurance. Insurers write out the policy, but more importantly, they constantly buy re-insurance, specifically to prevent the “pennies in front of a steamroller” problem.

So today, we’re going to walk you through what it actually takes to systematically trade these in a +EV fashion. You’ll get a real-world look at effective hedging and by the end, you’ll see why calling these -EV or even efficient is far from reality.

Without further ado, let’s get right into it.

Just hedge, man.

When one is first presented with this reality, the most tempting choice is to try moving around the risk-reward slider.

In practice (and this may look familiar), it generally goes like this:

• Your max loss on a short put credit spread is, say, $1,000

• To minimize this worst-case loss, you try:

  • Simultaneously buying the equivalent put spread of a later expiration

  • Selling a tighter butterfly spread around the at-risk strikes

  • Buying a deeper OTM put to act as a tail-risk hedge

Each time, as you may already know, the EV still nets out to 0.

This is largely because you’re trying to hedge an already efficiently-priced option position with more efficiently-priced options, so the EV isn’t really coming from anywhere new.

Now, the appeal of hedging with the underlying is pretty clear (predictable PnL, no views on vol), but to really understand where we’re going, it’ll help to walk through an example.

To start, let’s go back to October 10th last year, which was the single worst day in our test. Here’s how it went for a plain put spread with no hedge:

1. At 10:30 ET, SPX was at 6750.50, so we sold the 6645 put (about 1.5% below spot) and bought the 6595 put 50 points under it.

2. The credit came to $8.75, or $6.75 after fees.

3. SPX sold off all afternoon and closed around 6552, below both strikes, so the spread took its full loss of about $5,000.

The average winner in this test made ~$66, so that one afternoon handed back roughly 75 winning days.

Now, let’s replay the same session with one extra parameter, where the moment SPX touches our short strike, we short SPY shares against the spread:

1. SPX touched 6645, and after a 1-minute lag for realism, we shorted 409 SPY shares at $662.93

2. SPY kept falling, and we covered just before the close at $653.25.

3. The short made about $3,950 after costs, which took the day from a ~$5,000 loss down to about $1,040.

This recovered about 79% of the loss, which should help you see the appeal of this direction pretty quickly.

Of course, we know better than to cherry-pick over 1 trading day, so now that we have a starting framework, we can ask a new question:

What happens when you run this hedge every single day, for years?

The experiment

To find out, I kept the base trade as crude as possible, so any change in the curve comes from the hedge:

1. Take the 10:30 ET SPX price and find the highest same-day put strike at least 1.5% below spot.

2. Sell that put and buy the put 50 points lower, using the 10:31 quotes.

   1. Although basic automated scripts are substantially faster, adding in time-lags gives us a realistic basis.

   2. We’ll model giving up half the distance between the mid and the worse side of the quote, as opposed to just assuming a fill at the mid.

      1. We also assume a standard retail brokerage commissions fee of $1 per contract.

3. Skip the day if the quotes are unavailable or the credit is under 0.05 points (i.e., <$5).

4. Hold through expiration, using one spread per session with no compounding.

So with the simple baseline strategy established, we can move into how we’ll run the hedging side:

1. Starting at 10:31, pull each completed SPX one-minute aggregated price.

   1. We stop checking for new triggers at ~2:00 PM ET

2. On the first bar whose low touches the short strike, short SPY at the next minute’s open.

3. Size the short at 0.25x, 0.5x, or 1.0x of the spread’s delta at that moment, converted into SPY shares (we’ll explain more on this below).

4. Keep the share count fixed and cover at EOD.

   1. We’re deliberately not continuously hedging throughout the session to ensure practicality.

Now, step 3, calculating the net delta and converting it into the optimal hedge size, is the most important part, so we can slow down a bit there.

The spread’s delta tells us how many dollars we lose for each point SPX falls, and once we know that, we just short enough SPY to make the same amount back.

Taking the same session replay from above, here’s how that worked:

1. Derive the implied move of the session

   1. At 10:31, the ATM straddle (6750 call + 6750 put) was pricing about a 22.7-point move for the rest of the day.

2. Scale the implied move to the remaining time in the session

   1. Expected moves scale with the square root of time, and 273 of the original 328 minutes were left (triggered at ~11:26), so 22.7 × √(273/328) gives us about 20.7 points.

3. Convert that into implied odds for each strike

   1. We measure how far each strike is in “expected moves”, where a bell curve tells us how often SPX finishes beyond it.

      1. A strike sitting right at the current price is a coin flip (50%), one full expected move away is about 16%, and two is about 2%.

      2. At 11:26, SPX was at 6649.60, just 4.6 points above our 6645 short put. Running 4.6 ÷ 20.7 gives about 0.2 expected moves away, which is roughly a 41% chance of finishing below it.

      3. The 6595 long put was 55 points away, or 55 ÷ 20.7 = 2.6 expected moves, which works out to about 0.4%.

         1. If you want to check these yourself, it’s =NORM.S.DIST(-0.22, TRUE) and =NORM.S.DIST(-2.64, TRUE) in Excel or Sheets.

4. Subtract the two to estimate the spread’s delta

   1. So, 0.412 − 0.004, or about 0.408, and with the $100 multiplier, the spread was losing about $40.80 for every point SPX dropped.

5. Convert SPX points into SPY shares

   1. SPX was trading at about 10.03x the price of SPY, so a 1-point SPX move is only about a $0.10 move in SPY. To make $40.80 back per SPX point, we need 40.8 × 10.03, which is the 409 shares from earlier.

Put together, the model is shares = ratio × 100 × spread delta × SPX/SPY, where the ratio is our 0.25x, 0.5x, or 1.0x.

Okay, that was a lot of information at once, so I’d take a second before we move into the PnL.

C’mon, does it work, or not?

Putting it all together, we went back as far as our cached quote data allowed us to, and re-ran the above schematic every single day.

Fortunately, this approach manufactured positive expected value in every single variation:

The big picture results:

• Net P&L nearly quadrupled, going from about $2.6k unhedged to $10.2k with the full-size hedge

• The largest drawdown fell by about half, from $8.3k down to $4.2k

• The worst single day improved by about 40%, from a ~$5k loss to a ~$3k loss

• The hedge paid off when it was actually needed

  • On the nine losing days, the short recovered $14.5k of the $21.4k, roughly 68%

So, although the hedge only fired on a handful of days, it made more on the selloffs than it cost us everywhere else, and we kept far more of the premium while still having something in place for the worst-case sessions.

As usual though, there’s a bit of nuance to this.

Nuanceville

The first thing to know is that, obviously, the hedge often loses money on a day the spread ends up totally fine.

To see this, let’s pull out a session from the run:

1. SPX touched our short strike, so we shorted 520 SPY shares at ~$659

2. The market rose right after and we covered near the close at ~$665, for a loss of about $3,000

3. The spread expired worthless and made $47

So, even though we only hedge on a trigger, there’s still a cost to hedging. The hedge fired nine times in the whole test, and went like this:

• 5 triggered on days the spread actually lost, and all 5 made money ($14.5k).

• 4 triggered on days the spread finished fine, and all 4 lost money (-$6.8k).

Interestingly though, we found that the hedge made money as its own trade.

Net of the rebounds, the short was up about $7.7k by itself (chart below), which suggests that SPX touching the short strike is a bit of a signal in its own right, since the selling continued more often than it reversed.

Lastly, if you haven’t already noticed, this is a pretty capital-intensive trade.

The short in our earlier example was about $271k of SPY against a single spread, and you’d need that much in buying power to hedge on a minute’s notice.

Fortunately, the same framework carries over to futures, as it’s virtually what index futures were made for.

Our spread was losing about $41 per SPX point at the trigger, and a Micro E-mini (MES) contract moves $5 per point, so shorting 8 MES contracts covers roughly the same exposure for a fraction of the capital, with no shares to borrow. We’ll go deeper on that version in a later post (we’re still cleaning the messy futures data - rolls, margin changes, etc.).

Final Thoughts

When 0-DTEs first launched back in 2022, I immediately saw the potential economic value:

• Same-day settlement

• Deep liquidity

• Clear hedgeability

It unfortunately took me too long to get serious about implementing the hedging frameworks that are commonplace at larger option desks.

Our next research direction from here is seeing what the low-cost futures version of this looks like. First though, we opened a can of worms when we first reverse-engineered retail trading patterns in 0-DTE, which led us to some very interesting findings in the single-stock space.

• We’re running that new framework live for a few weeks to make sure our code is right, so it’ll take some time to accumulate enough live data to present any findings.

Nevertheless, we hope that if you’re running into the “pennies in front of a steamroller” problem, reading this will have at least given you a real direction on what it takes to fix it.

One more thing before you go.

Everything we publish here starts with a dataset, and those datasets are what we build over at Alphanume. We know better than to ask you to take our word that they’re predictive, so we tested each one against real prices and put the results on our proof page:

• IV/HV Premium: the richest 20% of names had implied vol 5.7 points richer than realized, while the cheapest 20% came in 8.7 points below (t = 14.3).

  • In other words, you can reliably find stocks with cheap vol and expensive vol.

• Pre-Market Drop Risk: names that the model marked with 70 % or higher risk averaged a decline of 8.3 % from open to close and 76 % of those names closed lower.

  • In other words, each day, the dataset reliably publishes those that’re likeliest to fall significantly intraday

Those are just 2 of the simplest examples, but we have 25+ more and we’re adding datasets constantly. If you want to run your own version of experiments like this one, it’s just one API call away.

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

For quick context, about 319 million shares were scheduled to be approved for trading, so people worried that those holders would start unloading their positions to realize liquidity and thus severely bring down the stock price.

In reality though, virtually nothing happened:

Nevertheless, the whole ordeal was pretty interesting to me.

After all, event-driven trades are our bread and butter, and this one seems to have an extremely clear rationale of why it would work:

1. Employees, early investors, etc., go through the joys of an IPO

2. They’re told that in 6 months, they can finally trade their shares

3. Once approved, they sell and turn their shares into cash

4. Aggressive selling activity lowers the trading price

The SpaceX event was just 1 instance, but surely, over many of these events:

“shouldn’t one be able to generate a profit by just selling short in advance?”

If so, we could potentially turn a benign, routine event into a lucrative systematic strategy.

So, to test this out, we pulled the data for every share lockup expiration over the last few years to see what the data would say.

As you’ll see shortly, this was one of the easiest edges we’ve ever found.

This full dataset, along with 25 others, is now available over at Alphanume.

The no-brainer trade

As always, before getting into the trade, it’s important to go over some requisite knowledge on this stuff.

Although we started with IPO lockups, they’re essentially second-fiddle to the most predictable type of lockup:

• Struggling companies often take on toxic financing agreements (PIPEs) where for a private capital injection, they sell shares to a private party, usually at a discount (e.g., 15% below current daily VWAP)

  • These shares come with their own lockup periods, usually between 6 and 12 months from the signing of the deal

PIPE agreements are the most interesting here since the incentive for selling is stronger than with a regular IPO lockup. These deals usually make money from the profit of selling the discounted shares the second they’re allowed to. Since these are so clearly linear, we made sure to add them to our universe.

So, again, it all goes back to the core rationale behind the trade:

motivated-to-sell shareholders are bound by lockup periods → lockup period ends → shareholders finally sell.

Now that you have pretty much all of the context you need, we can finally get into actually trading this.

To start, let’s run the simplest version:

Read more

This is the second post of our new series, Sketchy Trades, which we introduced here, dedicated to showcasing the “darker side” of quantitative trading research.

A few years back, EDGAR (the place where SEC filings get distributed) accepted and published a Schedule TO-C from a company called PTG Capital Partners, announcing an offer to buy all of Avon for $18.75 a share.

Avon had closed at $6.67 the night before, so it was a 181% premium.

Within 19 minutes of the filing, the stock went up 20%, the exchange halted trading three times, and about 31 million shares changed hands against a normal volume of ~13 million.

Unfortunately, the offer was fake. In fact, “PTG Capital” wasn’t even a real firm that existed.

When I first heard about this, I naturally thought, “Hmm, crazy. I bet there’s now lots of structure in place to prevent that from happening again”.

But the more I looked into this, the more I found out that there’s virtually nothing in place to prevent someone from doing this right now.

That’s a bold claim anyone can make though, so today, we’re going to show you the full mechanics of how this is done in the modern age, why it’s impossible to stop, and why you probably shouldn’t do it yourself.

Read more

Long story short, spread sellers were doing fine, being positive on most days in the sample and making about $18 million more than option buyers.

Getting to that number meant rebuilding every multi-leg order that crossed the exchange, which left us sitting on a massive pile of data.

Now, we know that for a lot of option sellers, systematization is a core element of their strategy. For instance, “every day at time t, sell an n delta put”. So, if we know what they’re trading, could we also map out when they’re trading?

If so, then it naturally begs the question:

“If we know what they’re trading and when, how much can be made from simply getting in front of that flow ahead of time?”

Is this stuff even predictable?

Before putting a strategy together, we first have to figure out whether this flow is even as predictable as we think it is.

To do that, we can put together a simple v1 experiment:

1. For every completed trade, take its timestamp and measure how many seconds away it was from the nearest 5-minute mark

   1. This allows us to see if any trades cluster at 10:00, 10:05, 10:10, etc.

2. Fingerprint each trade by its structure and direction

   1. Short put spreads, short iron condors, long straddles, etc.

3. For each fingerprinted trade, count how many of its trades happen on the exact 5 minute wall-clock intervals

4. Split the sample days in half to test actual predictiveness

   1. We’ll find the 10 most repeated results from days 1-10, then see if those same trades show up the same way on days 11-20

With that baseline test, we ran the experiment, and once again, the data pretty much speaks for itself.

Starting with every multi-leg order in the sample, the first finding is that the actual clock time is an extremely predictive factor:

Read more

Now, that paper is about 3 years old by at this point, and since then, there are a lot more 0-DTE traders. So, if it’s true that it’s all just net-negative gambling, then why would people keep trading them in increasingly large numbers?

That didn’t make much sense to me, so I wanted to take a look on my own to find a more recent and nuanced picture.

Specifically, I wanted to find out how much spread sellers were making, as pretty much everyone who’s serious about this knows that’s where the +EV is.

After pulling about 2.7 million trades over the last month, we were able to re-construct almost the exact option positions taken by small traders and derive how much they made per day.

As you’ll see shortly, people are trading these more and more for a reason, and they aren’t as dumb as you’d think.

So with that covered, let’s get into the numbers.

How we even know what they’re doing

Thankfully, the paper shared the methodology they used for being able to derive positions from trade data, so we simply borrowed some chunks of it.

To keep things simple, we’ll just walk you through what we did:

1. Pull every trade on every SPXW contract expiring that day from Massive.

   1. Condition codes come with every trade, but we only needed two: SLAN (single-leg auction) and MLAT (multi-leg auction)

2. Match each trade to the last quote before it

   1. A trade above the midpoint is a buy, below is a sell

3. Group MLAT legs that hit the same exchange within a millisecond of each other, then find the mix of known structures (e.g., verticals, iron condors, butterflies, straddles) that fit the trade.

4. Mark everything to the 4pm settlement

Now, while this approach works for identifying the opening trades, it’s still difficult to identify whether or not just someone opened the position and closed it 5 minutes later.

So this builds on the assumption that trades are held to close, which we know isn’t always the case.

Nevertheless, we’re focused on spread sellers, where the highest EV trade is usually holding to close anyway, so it’s a good enough starting point.

The sellers are WINNING

We expected the first data pass to take more interpretation, but right off the bat, the results were extremely clear:

Read more

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