Today, shareholders of Churchill Capital Corp XI (CCXI) vote on merging with Agility Robotics, the humanoid robot company, and if it passes, the stock starts trading as AGLT on Thursday.

It’s a $2.5 billion deal with Foxconn leading the private money, so there’s going to be a lot of excitement around that first trade, but before that happens, I wanted to take a look at history to see what usually comes next.

So, I pulled every SPAC merger that closed and started trading since the start of 2023, 171 deals in all, and tracked each stock through its first year.

A year after the first trade, 131 of the 139 deals old enough to measure were lower, the typical one was down 81%, and 96% were trading below the $10 the SPAC shares were originally sold for.

That’s a lot worse than I expected, but once you see how many people get a cut before you ever place a trade, things get a lot less surprising.

What are you ACTUALLY buying?

A SPAC is basically a shell company that lists on an exchange with no business, raises cash at $10 a share, and parks that cash in a trust account while it hunts for a private company to merge with.

Once the merger closes, the shell becomes the operating company under a new name and ticker, which is why you’ll hear the new stock called a de-SPAC.

The trouble is that a lot of people get a piece of that $10 along the way:

1. The sponsor
   The team that sets up the SPAC typically pays around $25,000 for 20% of the shares, which is called the “promote,” and since those shares cost almost nothing, they dilute everyone who paid $10
2. Warrants
   Early SPAC buyers and the sponsor usually get warrants, which are essentially the right to buy more stock at $11.50, so if the stock ever gets above that, new shares get created
3. The PIPE
   Big investors often put money in privately right before the merger (a PIPE agreement), sometimes at better terms than the public gets
4. Fees
   The bankers who took the SPAC public get paid when the merger closes, out of the same pot
5. Redemptions
   This is the most important one, so we’ll go into more detail on it a bit later

Where The Cash Goes

Now, before the merger vote, every public SPAC shareholder gets the right to hand their shares back for roughly $10 plus interest, which is basically a free exit, so if you don’t love the deal you just take the cash, and plenty of people do (often while keeping the warrants).

I checked the 62 deals in my sample where Alphanume’s De-SPAC dataset had both the trust size and the redemptions, and in the typical one, 82% of the trust money got pulled out.

Agility is a nice live example, since Churchill XI’s trust would have delivered about $424 million if nobody redeemed, and after the redemption deadline passed, the companies said about $164 million of it would actually make it to the company.

That comes out to roughly 60% of investors asking for its $10 back.

So, think about who’s left holding shares when the new ticker starts trading:

• The sponsor, who paid pennies
• PIPE investors, who negotiated their price
• The private company’s old owners, usually locked up for a while (180 days in Agility’s case)
• A small slice of public holders who chose not to take the $10

Because the float, which is essentially the shares that can actually change hands, is so small, the first few days can get wild, and about 1 in 6 of these stocks (27 of 171) closed their first day at $15 or higher.

Most didn’t get anywhere near that, though, and 61% closed their very first day already below $10.

Where It Goes Terribly Wrong

So, now that you get the high-level mechanism, let’s take a look at what the typical de-SPAC looked like over its first year (chart below), with every price adjusted for later reverse splits so a split never shows up as a fake jump.

Measured from the close of the first trading day:

• After 20 trading days (about a month): down a median 46%, and 88% are lower
• After 60 days (about three months): down 52%, 88% lower
• After 120 days (about six months): down 63%, 93% lower
• After 250 days (about a year): down 81%, 94% lower

And in plain dollar terms, 79% of them were trading under $5 a year in.

Our longer study on the De-SPAC Events page goes back to 2020 with a larger sample and measures from the merger’s completion instead of the first close, and it points the same direction, with the median name down 47% six months after completion.

Isn’t SPAC 2.0 supposed to be better?

The obvious rebuttal is that the newer wave of SPACs, the so-called SPAC 2.0, is supposed to come with better sponsors and better deals, so I split the one-year results by the year each stock started trading (chart below).

• 2023 listings: down a median 73%, 96% lower (68 deals)
• 2024 listings: down 83%, 93% lower (44 deals)
• 2025 listings: down 87%, 89% lower (27 deals)

To be fair, there are some exceptions to the rule:

• Oklo (OKLO): up 232% in its first year after listing in May 2024.
• Sable Offshore (SOC): up 147%.
• QT Imaging (QTI): up 344%, though from a first close of $1.35.

So, that comes out to 3 names out of 139 that more than doubled, and only 8 that finished the year higher at all.

How you’d actually trade this

The obvious read is to short every new de-SPAC and wait, which works great on paper until you go looking for shares to borrow.

Before you can short, your broker needs a locate, which is basically confirmation that there are shares out there for you to borrow.

So, I checked Alphanume’s short-locate data for the 50 de-SPACs that started trading since June 2025, using the morning snapshot from October 30:

• 38 of 50 showed up on the hard-to-borrow list
• 5 of those had no shares on offer at all
• For the ones with shares, the typical one-time locate fee was about 0.26% of the stock price, and the most expensive was 5.5%

That fee is manageable on a stock that falls 50% in three months, as long as you can actually find shares, which wasn’t the case for 5 of the 50.

So, here’s roughly how I’d run it:

1. Watch the calendar
   The vote, the close and the first trade usually happen within a few days of each other, so you want to know about them before the new ticker shows up.
2. Read the redemption number first
   It tells you how much cash actually made it to the company and how small the float will be.
3. Don’t chase the day-one pop
   The small float makes the early moves violent in both directions, and the typical stock is down 24% from its first close by day five anyway.
4. Check borrow before you plan a short
   If there are no shares, there’s no trade.
5. Mark the lockup date
   When the old owners can sell, there can be a lot of new supply.

Here’s a small script that pulls the upcoming SPAC milestones from the De-SPAC Events dataset, soonest first:

import os
import requests

r = requests.get(
    "https://api.alphanume.com/v1/de-spac-events",
    params={"status": "pending", "upcoming": "true"},
    headers={"X-API-Key": os.environ["ALPHANUME_API_KEY"]},
)

deals = sorted(r.json()["data"], key=lambda d: d["next_event_date"])

for d in deals:
    print(d["next_event_date"], d["next_event_type"], d["prior_ticker"], "->", d["new_ticker"], d["new_company_name"])

When I ran it this morning, it returned today’s CCXI to AGLT vote, plus three more shareholder meetings later this month:

• CubeBio on the 11th
• Blockfusion on the 17th
• Quantum Space on the 20th

Final Thoughts

I went in expecting SPACs to be bad, and I still came out surprised by how consistent it is.

Agility could easily end up among the exceptions, since it’s a real company with real customers and a lot of private money behind it, and the names above prove that some of these do work.

The base rate is still brutal, though, so anyone buying AGLT on Thursday should at least know that 131 of the last 139 were lower a year later.

If you want to track these yourself, the De-SPAC Events dataset follows every deal from announcement to first trade, including the redemption and trust numbers I used here, while Short Locates covers the borrow side.

Both come with Alphanume Pro, which has a 3-day free trial, so you can run the script above on this month’s votes yourself.

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

On September 28, our bot shorted GYGY at $1.23 in the opening auction and bought it back a little after 2 PM at 97 cents, which is about +21% on a stock that had been up 72% before the bell.

Now, we’re cherry-picking that result for a reason.

Back in July, GYGY had sold $8 million of convertible preferred stock to Streeterville Capital, priced at the lesser of a fixed price or a discount to wherever the stock happened to be trading. In August it registered 22.2 million shares for resale, on a company worth about $24 million at the time, and that registration went effective on September 16.

So when GYGY ripped 72% in the pre-market 12 days later, there was someone sitting on a pile of freshly sellable shares who had every reason to hit the bid.

In part 1, we went through why some trades keep working for years after they’re known: the names are too small, the plumbing is annoying, the payout takes forever, and shorting carries a stigma.

However, when you’re in the business of edge, no edge is too small or too much work. So today, we’re going to take it a level deeper and show you some of the grittier mechanics of more of these types of trades.

Not All Money is Good Money

“Toxic financing” might sound like jargon-slop at first, but the reason it’s called that is pretty simple.

Basically, a small company that can’t raise money the normal way signs a deal with a specialty fund, and the deal usually works like this:

1. The fund buys a convertible note, convertible preferred, or an equity line from the company
2. The conversion price floats, which essentially means the fund’s price follows the stock wherever it goes
    — Usually that’s a 5% to 20% discount to the recent market price, or the lesser of a fixed price and that discount
3. The company files a resale registration so the fund can legally sell the shares it gets
4. The fund converts, sells, converts again, and sells again, for as long as there’s a bid.

The fund’s whole business is buying stock at a discount and dumping it into whatever liquidity shows up, and a stock running 72% in the pre-market is the best liquidity a company that size will see all quarter.

So, that shines a bit more light on who the “forced seller” from part 1 might be.

There’s Still Value in The Math

Now, the other half of this is our Pre-Market Drop Risk dataset, where every trading morning a model takes in the microcaps that have been active before the open and ranks them by their chance of falling 5% or more from the open to the close.

Rows land a few minutes after 9 AM ET and the history goes back to May 2024, so here’s what the list has done since then for names trading at $1 or more:

• 3,452 flagged names over 609 trading days, about 5 a morning.
• 65% of them fell from the open to the close.
• The median one fell 5.7%.
• The top 3 names each day fell 70% of the time, for an average short return of +4.7% per trade.

You get all of that without reading a single filing, since the model only sees prices, which also means it has no idea who’s holding a convertible.

That’s where the Toxic Financing dataset comes in, since it tracks the PIPEs (basically a fund buying stock straight from the company) and structured private placements disclosed in 8-Ks since 2024.

Each deal comes with:

• The pricing formula and the discount.
• The investors behind it.
• The resale registration dates.
• A 0-to-3 toxicity grade, where 3 means the price floats with the market.

Pull one out of a hat

I wanted to see how dumb I could make this and still get paid, so I simulated the laziest possible version, where every morning you pick one name at random from the list, short it at the open, and cover at the close.

I ran that across all 609 days, 10,000 separate times, which is basically 10,000 different people each drawing their own name out of a hat every morning for about 2.5 years.

Even with zero filtering, 88% of them finished in profit, averaging +1.7% per trade.

Then I made it one notch less dumb by only drawing from names on the list that also had a deal in the Toxic Financing feed over the prior year, which left 512 days with at least one of those names to draw from.

This time, all 10,000 runs finished in profit, averaging +4.1% per trade (chart below).

So out of 10,000 people pulling from those 2 lists at random, not a single one lost money. You can literally pick one of these names out of a hat, short it, and make money.

Interestingly enough, the edge keeps growing the tighter you make the filter, so here’s every name on the list sorted by what was sitting in its filings before the morning it got flagged:

• Any name on the list: 65% fell, average short return +2.5% (3,452 trades).
• Any private placement in the past year: 67% fell, +4.8% (1,205 trades).
• A deal graded 2 or 3 in the past 90 days: 72% fell, +6.2% (302 trades).
• A resale registration that went effective in the past 90 days: 72% fell, +7.5% (209 trades). These come from our Stock Dilution feed, which flags registrations of shares existing holders already own.

That last one is GYGY’s exact setup, and it’s the cleanest version of the mechanism, because the financier’s shares just became sellable and then the stock ran.

The names with a financier behind them also beat the rest of the list in every single year of the history (chart below).

Why it’s still sitting there

So if it’s this easy, why doesn’t everyone do it already?

Mostly because it checks almost every box on part 1’s list:

• Too small. The median opening auction for one of these names trades about $73,000, which a fund running a few billion can’t even see, never mind trade
• Operationally annoying. You need a list by 9 AM, a locate before 9:30, a market-on-open order, and an afternoon cover, every single day.
• Short-side stigma. You’re betting against tiny companies that just announced a “strategic financing”

The fourth friction, the slow payout, is the one that’s gone, since this trade opens at 9:30 and closes the same afternoon, so you know whether you were right before dinner and there’s no overnight borrow to pay.

How to run it yourself

1. At about 9:05 AM ET, pull the day’s list with min_price=1.
2. Pull every Toxic Financing deal from the past year and keep the names that show up in both.
3. Check the borrow in the Short Locates feed, which snapshots quoted locate costs before the open, and skip anything you can’t get.
4. Short what’s left with market-on-open orders, equal dollars per name.
5. Cover everything at 2 PM ET, which is what our bot does.

Steps 1 and 2 are a dozen lines of Python:

import requests, pandas as pd

KEY = "YOUR_ALPHANUME_KEY"
B = "https://api.alphanume.com/v1/"
H = {"X-API-Key": KEY}
today = pd.Timestamp.now(tz="America/New_York")

# This morning's list, $1 and up
picks = pd.DataFrame(requests.get(B + "premarket-drop-risk", headers=H,
    params={"date": today.strftime("%Y-%m-%d"), "min_price": 1}).json()["data"])

# Every toxic financing deal from the past year
deals = pd.DataFrame(requests.get(B + "capital/private-placements", headers=H,
    params={"date_gte": (today - pd.Timedelta(days=365)).strftime("%Y-%m-%d")}).json()["data"])

# Names on the list with a financier behind them
shorts = picks[picks["ticker"].isin(deals["ticker"])]
print(shorts[["ticker", "rank_for_date", "prob_drop", "px_at_trading", "premarket_return_at_cutoff"]])

If you want the stricter version, add min_toxicity=2 to the second call and shrink the window to 90 days.

Keep each name small, since every so often one of these runs a few hundred percent before the close. The worst top-3 day in the history was PLAG in August, up 443% from the open, and the top 3 still finished every year in profit.

Final Thoughts

Part 1 was the argument for why this kind of edge sticks around, and this is the part where you get to go collect it.

What I like about this one is how little discretionary judgment it asks for, since the model finds the names that ran before the open, the filings tell you who’s waiting to sell into them, and the rest is basically a couple of orders and a timer.

If you want to try it, both datasets are in Alphanume Pro, which comes with a 3-day free trial, so you can pull a few mornings (or years) of the list and see it for yourself.

It also makes me wonder how far the same idea stretches, since at-the-market programs and warrant exercises come to mind first, and there’s probably a version of this for anyone with a reason to sell.

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

Until June 4th of this year, a US trader needed $25,000 in their account to make more than three day trades in five trading days, which ended up keeping a lot of smaller accounts out of intraday shorting entirely.

FINRA scrapped the PDT rule and replaced it with a new intraday margin framework, so the floor for short selling at a broker like TradeZero is now $2,000 of equity.

It’s been a few months since the change, but yet there hasn’t been a public proliferation of small traders running the kinds of strategies that actually make money.

Now, the question I get most about our core short selling strategy is basically “how do I even start?”, so I assume this is largely an information issue, where not enough people even know where to start looking.

For some quick context, our hallmark strategy has been a daily short of beaten-down small caps that now runs on a fully automated basis, at >70% hit rates. I recommend checking out these two posts for more detail:

• Abusing Microcaps at Scale
• Running Sophisticated Trading Strategies with TradeZero [Code Included]

So today, I’m writing down every step in detail, from opening an account to placing your first short with a single Python script.

With that being said, let’s get right into it.

What Shorting Even Is

A short is just a trade that makes money when a stock goes down, and contains three components:

1. Borrow shares you don’t own, through your broker
2. Sell them at today’s price
3. Buy them back later, hopefully cheaper, and return them

Your profit is the spread between where you sold and where you bought back, minus whatever the borrow cost you.

The payoff feels backwards at first, because a stock can only fall to zero, so the most a short can make is 100%, while there’s no cap on how high a stock can climb or what a short can lose, which is basically why everything below is built around small size and getting out the same day.

Step 1: The account

You need a margin account, which is essentially the kind of account that lets you borrow.

We use TradeZero for this, mainly because it lets you rent hard-to-borrow shares straight through its API, and here’s what TradeZero America lists today:

• No minimum to open the account
• $500 in account value before trading is turned on
• $2,000 in equity to trade on margin or sell short
• $0 commissions on stocks priced $1 or more, on NYSE, AMEX, or NASDAQ

If you sign up through this referral link, you’ll get $100 once you fund the account and place one trade.

Once you’re approved, getting API keys only takes a few clicks, and their API key guide has screenshots for each one:

1. In the TradeZero portal, pick the ProBundle or FreeBundle platform plan, and turn on the API Trading add-on. The end-game is automated execution, so you realistically only need the Free bundle.
2. Sign the API Trading Agreement on the Agreements page.
3. Go to API Keys and generate a key pair.

You’ll get a key ID and a secret, and the secret only shows once, so save it right away.

Step 2: Borrowing the shares

Before you can short anything, your broker has to find shares to lend you, and this is probably where most beginners get stuck because stocks fall into two buckets:

• Easy to borrow: big, liquid names where the broker has plenty of shares, so there’s no extra step and no fee
• Hard to borrow: small, crowded names where shares are scarce, so you have to request a locate first. A locate is basically renting the right to borrow those shares.

At TradeZero, you ask for a locate and get a quote, and you only pay the fee once you accept it, so checking a price costs you nothing.

That fee is a one-time charge for the day, which is why we cover before the close, since holding a hard-to-borrow short overnight means paying an annual borrow rate that, on these names, can run north of 100%.

We have a share locate dataset so you can see historical daily prices, but most cost around a dollar per 100 shares.

Step 3: Finding something to short

Every morning, a handful of small caps rip in pre-market on a phony press release, a reverse split, or just noise, and a lot of them give it back once the regular session opens.

Our Pre-Market Drop Risk model ranks those names on the odds each one falls 5% or more from the open to the close, and the list lands around 09:03 ET, ranked from most to least likely to drop.

Pulling the stats for the top 3 names every day since May 2024, shorting at the open and covering at the close:

• 947 trades
• +4.7% average return per trade
• 70% of them made money

If you’d rather not stare at a pre-market scanner at 8 AM, the dataset does virtually ALL of the work for you.

Step 4: Your first short, in Python

Once you have the account, the margin, and the exact names to short, all that’s left is placing the order.

At a high-level, the process goes like this:

1. Pull this morning’s top 3 names priced at $1 or more
2. Request locates for each name at your desired size, and drop the name if the fee is more than 5% of the position size
3. Short $500 worth of each with a market-on-open order
   ** This puts you in the opening auction, which is essentially where everyone trades at one price at 09:30, so you skip the wide spread on a thin small cap
4. At 14:00 (2PM EST), buy it back with a limit order

The full code for this is in the Alphanume Strategy Lab, but we’ll walk you through a few chunks of it:

Going through each name and getting the locates:

def pick_a_name():
    picks = requests.get(f"{ALPHANUME}/premarket-drop-risk", params={"date": today, "min_price": 1, "max_rank": 3},
                         headers=ALPHANUME_HEADERS).json()["data"]
    snapshot = requests.get(f"{ALPHANUME}/short-locates", params={"date": today, "slot": "am"},
                            headers=ALPHANUME_HEADERS).json()["data"]
    locate_status = {row["ticker"]: row["status"] for row in snapshot}

    for pick in sorted(picks, key=lambda row: row["rank_for_date"]):
        if locate_status.get(pick["ticker"]) in ("no_shares", "threshold"):
            print(f"{pick['ticker']}: no shares to borrow this morning, skipping")
            continue
        return pick["ticker"], pick["px_at_trading"]
    sys.exit("nothing shortable today")

Now, the locate is the step that actually costs money, and since locates come in 100-share lots, the script rounds up, gets a quote, and cancels it if it’s too expensive:

fee = offer["locatePrice"] * locate_shares
if fee > MAX_LOCATE_FEE * shares * price:
    requests.delete(f"{TZ}/accounts/locates/cancel/accounts/{account_id}/quoteReqID/{quote_id}", headers=TZ_HEADERS)
    sys.exit(f"{ticker}: locate costs ${fee:.2f} on a ${shares * price:.2f} position, too expensive")

requests.post(f"{TZ}/accounts/locates/accept", headers=TZ_HEADERS,
              json={"accountId": account_id, "quoteReqID": offer["quoteReqID"]})

On this morning’s POM, a $500 position is 384 shares, which rounds up to a 400-share locate, and this morning’s locate cost us $9.50, or roughly 1.9% of the trade, so it cleared the 5% cap comfortably.

Finally, we send the short order, routed to ARCA because on TradeZero only ARCA and NYSE accept opening-auction orders:

order = {"symbol": ticker, "securityType": "Stock", "side": "Sell", "openClose": "Open",
         "orderType": "Market", "timeInForce": "AtTheOpening", "orderQuantity": shares,
         "route": "ARCA", "clientOrderId": f"{ticker}-short-{int(time.time())}"}

Looking at the full code linked above will make more sense, but that’s pretty much all you need to be off and running.

I recommend going by hand for the first week to get comfortable with the code (or just give it to your AI agent to double-check), but once you’re comfortable, you can deploy the full thing on a $6 DigitalOcean droplet and check back in a few weeks to see how much you’ve made.

Final Thoughts

For most, the hardest parts of running profitable strategies were the $25,000 PDT gate and gaining the knowledge to step out of the long-only space.

Powers out of our hands solved the first issue, and I hope this post at the very least helped on the second front.

If you want to try this, Alphanume Pro has a 3-day free trial, and both datasets in this post, Pre-Market Drop Risk and Short Locates, come with it, which is enough time to watch the list for a few mornings and run your first short on real data.

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

On September 28, our automated requested locates, shorted MSGY into the opening auction at $8.25 and bought it back a little after 2 PM at $3.08, which is about +63% on the trade.

While this is only one example and it’s easy to cherry-pick, this same process happens every single trading session, day after day.

Now, we’ve talked about this before in Abusing Microcaps at Scale, but we’ve never actually broken down the full process required to actually run this. Specifically, the grittier parts like brokerage integration, how to set up the automation to reliably run, and everything required to do more than just backtest into infinity.

So today, we’ll be showing you the exact process we deploy daily, using TradeZero as our broker for short-selling and Alphanume as our data provider.

We’ll also leave the full code for this in our Strategy Lab repository on GitHub for you to verify and test this out yourself.

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

The Strategy

Before diving straight first into the technical aspects, it’d be wise to start with how the strategy works.

At it’s core, we’re doing mean reversion within a toxic basket of stocks.

From a universe of the most toxic assets (serial diluters, microcaps, etc.), our model takes the cross-sectional pre-market return to output the 5 likeliest to drop more than 5% intraday, and returns its probabilities:

    {
      "date": "2026-09-28",
      "ticker": "MSGY",
      "rank_for_date": 2,
      "prob_drop": 0.695,
      "px_at_trading": 8.188,
      "premarket_return_at_cutoff": 1.46
    }

From there, the strategy executes as follows:

1. Around 09:08 ET, get the day’s list of names
2. Before the open, short each one with a market-on-open order, which basically just drops your order into the opening auction where everyone trades at one price, so you skip the ugly bid-ask spread microcaps that would hurt you otherwise
3. At 14:00 ET, buy everything back

Since you’re in and out the same day, you never pay overnight borrow rates, which on these names can run north of 200% a year.

Now, you do have to pay for a locate, which is essentially a one-time fee to reserve hard-to-borrow (HTB) shares for the day. Almost every name on this list is HTB, so the program skips any name where that fee gets too expensive (more on that in a sec).

Step 1: The data

The model’s picks publish every morning as Alphanume’s Pre-Market Drop Risk dataset, which is the exact feed our live bot reads. The endpoint is part of Alphanume Pro, so you’ll need a Pro API key for the requests below.

Each row is one ticker on one morning, and the keys ones are:

• rank_for_date: that day's ranking, with 1 being the most likely to drop
• prob_drop: the model's probability of a 5%+ drop from open to close
• px_at_trading: the last pre-market price at or before 09:00 ET, which we use for sizing
• intraday_return_pct: the actual open-to-close move, filled in after the session so you can grade every pick

Pulling the morning’s basket is pretty simple:

import requests

API_KEY = "alp_your_key_here"
BASE = "https://api.alphanume.com/v1"

basket_request = requests.get(f"{BASE}/premarket-drop-risk?date=2026-09-28&min_price=1&api_key={API_KEY}").json()

for row in basket_request["data"]:
    print(row["ticker"], row["rank_for_date"], row["prob_drop"], row["px_at_trading"])

LABT 1 0.83 2.125
MSGY 2 0.695 8.188
PMAX 3 0.61 1.898
GYGY 4 0.6 1.274

That morning, all four names finished the day down, anywhere from -28% to -63% from the open.

Again, one good morning proves nothing, so before you trust this, it’s smart to run a quick backtest yourself. Fortunately, you can just as easily pull the full dataset going back to 2024:

import pandas as pd
import matplotlib.pyplot as plt

premarket_request = requests.get(f"{BASE}/premarket-drop-risk?min_price=1&api_key={API_KEY}").json()
history = pd.json_normalize(premarket_request["data"]).dropna(subset=["intraday_return_pct"])

daily_short_return = -history.groupby("date")["intraday_return_pct"].mean().sort_index()
cumulative_return = daily_short_return.cumsum()

plt.plot(cumulative_return.index, cumulative_return.values)

That’s pretty much it.

Going back a few years, we can model out a strategy that does everything above, where for all names >$1, we short all in equal-weight each morning:

So, now that you have a grip on what the strategy actually does and how it works, let’s get started on executing in the real-world.

Step 2: Get a TradeZero API key

We use TradeZero because it lets you buy locates on hard-to-borrow names straight through its API, and getting a live key only takes a few clicks (their API key guide has screenshots):

1. Log into the TradeZero portal and go to Trade → Platform Selection.
2. Pick Pro Bundle or Free Bundle, and turn on the API Trading add-on.
3. Sign the agreements on the Agreements page, including the API Trading Agreement.
4. Go to API Keys → API Key Management → Generate API Keys.

You’ll get a key ID and a secret, and the secret only shows once, so save it somewhere safe right away.

Step 3: The algorithm

Our script has three commands: check to test your keys, entry in the morning, and exit in the afternoon.

For sizing, since short-selling is heavily left-tailed (lots of small wins, occasional large losses), we stick to a constant 30% of NAV, where no individual name gets more than 10%, as follows:

DAILY_FRACTION_OF_EQUITY = 0.30
MAX_FRACTION_PER_NAME = 0.10

dollars_per_name = min(DAILY_FRACTION_OF_EQUITY * equity / len(basket), MAX_FRACTION_PER_NAME * equity)
shares = math.floor(dollars_per_name / price)

So on a hypothetical $10,000 account with five names, each one gets $600, and the 10% cap only really kicks in on days when the basket has just one or two names.

The locate check:

For a hard-to-borrow name, the bot asks TradeZero for a locate quote, rounded up to the next 100 shares since locates come in 100-share lots, and if the fee would eat more than 5% of the position, it cancels the quote and skips the name:

locate_shares = math.ceil(shares / 100) * 100

# ... request a quote for locate_shares and wait for TradeZero's offer ...

locate_cost = offer["locatePrice"] * locate_shares
position_value = shares * price
if locate_cost > MAX_LOCATE_COST_FRACTION * position_value:
    print(f"{ticker}: locate costs ${locate_cost:.2f} on a ${position_value:.2f} position, too expensive")
    requests.delete(f"{TRADEZERO_URL}/accounts/locates/cancel/accounts/{account_id}/quoteReqID/{quote_id}", headers=TRADEZERO_HEADERS)
    return False

requests.post(
    f"{TRADEZERO_URL}/accounts/locates/accept",
    headers=TRADEZERO_HEADERS,
    json={"accountId": account_id, "quoteReqID": offer["quoteReqID"]},
)

Interestingly enough, this check skipped the top-ranked name on that same September 28 morning, because LABT’s locate was $0.125 a share, and once you round up to a 100-share lot, on our small position that worked out to 11% of the trade.

While this isn’t totally necessary as sometimes the best positions are the ones with the most expensive locates, it goes a long way in managing overall execution costs.

Once the borrow is in hand, the order itself is a plain market-on-open sell:

order = {
    "symbol": ticker,
    "securityType": "Stock",
    "side": "Sell",
    "openClose": "Open",
    "orderType": "Market",
    "timeInForce": "AtTheOpening",
    "orderQuantity": shares,
    "route": OPENING_AUCTION_ROUTE,
    "clientOrderId": f"{ticker}-short-{int(time.time())}",
}
result = requests.post(f"{TRADEZERO_URL}/accounts/{account_id}/order", headers=TRADEZERO_HEADERS, json=order).json()
print(f"{ticker}: short {shares} at the open -> {result.get('orderStatus')} {result.get('text') or ''}")

The route is ARCA because on our account only ARCA and NYSE offered AtTheOpening orders.

At 14:00 (2PM EST), the bot buys back every short with a limit order 1% above the last price TradeZero shows, then waits 30 seconds, and anything still open gets cancelled and re-sent another 1% higher, for up to ten rounds:

for attempt in range(1, 11):
    # ... cancel any unfilled covers from the last round, then re-read what's still short ...

    # TradeZero serves no quotes, so the last price comes from its P&L feed.
    pnl_rows = requests.get(f"{TRADEZERO_URL}/accounts/{account_id}/pnl", headers=TRADEZERO_HEADERS).json()["pnl"]
    last_prices = {row["symbol"]: abs(row["exposure"]) / shorts[row["symbol"]] for row in pnl_rows if row["symbol"] in shorts}

    for ticker, shares in shorts.items():
        limit_price = round(last_prices[ticker] * (1 + 0.01 * attempt), 2)
        order = {
            "symbol": ticker,
            "securityType": "Stock",
            "side": "Buy",
            "openClose": "Close",
            "orderType": "Limit",
            "limitPrice": limit_price,
            "timeInForce": "Day",
            "orderQuantity": shares,
            "route": COVER_ROUTE,
            "clientOrderId": f"{ticker}-cover-{int(time.time())}",
        }
        requests.post(f"{TRADEZERO_URL}/accounts/{account_id}/order", headers=TRADEZERO_HEADERS, json=order)

    time.sleep(30)

We went with a 14:00 exit as opposed to just the close since, as of writing, TradeZero’s API doesn’t accept market-on-close orders.

In our own executions, we found that covering at 14:00 gave up about 3 points of annual return for a slightly better Sharpe ratio, so it’s a trade-off we’re willing to make.

Step 4: A $6 server

Although you can run this on your laptop, you have to keep in mind that it: sleeps, reboots for updates, and loses Wi-Fi. The opening auction has a strict cutoff and all of these calculations happen less than 25 minutes before it, so if you’re going to run this seriously, you need a real server.

We run ours on a DigitalOcean droplet, which is just a rented, always-on Linux machine that lives in a data center, and the 1 GB droplet runs $6 a month.

To get started (if you’ve never done this before, you should honestly just hand this part over to Claude/Codex):

1. Create a droplet with Ubuntu 24.04, the 1 GB plan, and an SSH key.
2. Log in and set the clock to New York time:

ssh root@YOUR_DROPLET_IP
timedatectl set-timezone America/New_York
systemctl restart cron
apt update && apt install -y python3-venv

3. Copy over the script (scp from your own machine works fine) and make a .env file with your TradeZero key ID, TradeZero secret, and Alphanume key:

mkdir bot && cd bot
# from your own computer, in another terminal:
#   scp production.py root@YOUR_DROPLET_IP:/root/bot/
python3 -m venv venv
venv/bin/pip install requests pytz
nano production.py   # paste your keys into the three lines at the top
venv/bin/python production.py check

check is read-only, since it just prints your TradeZero account and today's basket, so you know both keys work before anything trades.

4. Schedule it with cron, which is basically Linux’s built-in scheduler, by running crontab -e and adding these two lines:

5 9 * * 1-5  cd /root/bot && venv/bin/python production.py entry >> bot.log 2>&1
0 14 * * 1-5 cd /root/bot && venv/bin/python production.py exit  >> bot.log 2>&1

From then on, it starts at 09:05 every weekday, covers at 14:00, and writes everything to bot.log. This log is important as you can track execution times, PnL, and everything needed for a real timestamped track-record.

On market holidays the basket will come back empty, so the bot keeps checking until 09:20, prints that there are no names, and exits.

Final Thoughts

The full script is on GitHub, in the Pre-Market Quantitative Trading on TradeZero repo.

The way I’d start is to plug in your keys, run check, watch a few mornings with tiny size, and add the guardrails as you hit the problems they solve, which is pretty much how ours got built.

The one piece you can’t rebuild over a weekend is the daily list itself, and that’s what Alphanume Pro is for. It comes with the full Pre-Market Drop Risk history, the REST API the bot calls, and more than 25 other proprietary datasets just like this one.

If you want to follow us along for more research like this, you can see the rest of our posts over at Alphanume Research.

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

Somewhere between 70 and 100 reverse stock splits execute in the US every month, and almost all of them start as sub-$1 microcaps trying to game their way out of a Nasdaq delisting.

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”)
   * In the best case, it’s tied to a vague “AI” or “crypto” press release
   * 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.

A month after Alphanume Learn went live, one of the early learners sent me a progress update that made the whole launch click.

Before starting, they had never written what they considered a proper backtest. Seven days later, they were building new options-strategy research with proprietary data, using an agent to write the plumbing, and checking the assumptions before trusting the next 15-Sharpe result.

It wasn’t long before we had a follow-up call and I learned that he is currently doing very well.

That was one learner’s experience, and one week is obviously a tiny sample, but what I mainly care about was the change in what they could do: they went from just reading quant material to running a research process they could inspect, run again, and eventually deploy into the real-world.

I’ve heard similar stories from other people using Learn, where most quant content helped people know more things, but not necessarily do more things.

So, over the past few weeks, we’ve doubled-down and made some upgrades.

You Can Own the Course Now

When I first wrote about the curriculum on Medium, Learn had a few lessons and came bundled with an Alphanume Pro subscription.

The curriculum has since grown to 66 lessons across 12 modules, and the full course is now available on its own for $499 once. Your course access doesn’t expire, and every future revision and addition to the course is included.

If you finish in a month, revisit the volatility module next earnings season, and come back to the agent workflow six months later, the same purchase covers all of it.

For reference, premium algorithmic-trading education can cost several thousand dollars. Oxford’s six-week programme currently lists at $2,859, while QuantInsti’s EPAT begins at $7,799 for US buyers.

Most self-taught quants already have more material than they can finish: notebooks, saved threads, half a Python course, a strategy video they meant to reproduce, and a folder called backtests where every file sits on its own and answers completely different questions.

Learn gives those pieces an order, then makes you use them:

From our own experience and conversations, we know that self-taught researchers can lose months figuring out that order before they quit too early and move onto something else:

• You can learn pandas from one place, option mechanics from another, and backtesting from a third, then discover that nobody explained which timestamp you actually could have traded at or that your historical universe was contaminated by survivors only.
• If you’re serious about quantitative trading, you need to know those things before risking a single dollar.

The course gives the same exciting strategies you care about, but builds with those common mistakes in mind from the start.

By the time you reach the earnings screen or the dilution study, you already have a research database, a point-in-time mindset, and a checklist designed to ruin an obviously wrong result long before it reaches your account.

What the $499 Includes

The full Systematic Trading with Market Data syllabus runs from why an edge can exist to the machinery required to operate it.

You get:

• 66 lessons across 12 modules, taking roughly 18 hours at the planned pace.
• Interactive Python exercises that run in the browser against real market data.
• Quizzes and graded output, including questions designed to catch bad reasoning rather than reward memorizing vocabulary.
• Saved progress and a final capstone where you build and defend your own event study.
• The data required by the course exercises, so you can complete the curriculum without buying another data plan.
• Future course revisions and additions, included with the original purchase.

Having some basic Python knowledge helps, but it’s not a requirement. Since the course runs from the browser, you completely bypass the hours of Python environment setups, conflicting dependencies, broken kernels, and so on.

If you really wanted to, you could complete the entire thing from your phone.

By the end, you’ll have a lock on the market segments most people will never understand, let alone exist:

• Volatility and catalysts: IV/HV premium, IV rank, earnings moves, and 0-DTE structures
• Corporate events: dilution, shelf registrations, de-SPACs, defaults, and lock-up expirations
• Signals and portfolios: dividends, momentum, attention data, regime gates, sizing, and correlation
• Operations: scheduled delivery, agent-assisted research, code guardrails, and the final capstone

You can start the free module here, run the work, and decide from the actual experience whether the format fits how you learn.

If you already know you want the full sequence, you can buy permanent access for $499. Active Alphanume Pro members already have access and can simply sign in.

Both links stay open, so you can work through the free module before deciding.

Final Thoughts

The early Learn results have been gratifying because the strongest feedback has focused on real-world output.

People are talking about the strategies they can now deploy, the data they can query, and the agent workflows they can audit.

That’s exactly what I wanted the course to produce and I’m glad to see adoption have a real impact on people.

I’m also curious to see what more people end up building once the research process feels routine enough to be a launchpad for their own ideas.

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

Alphanume’s new MCP server gives Claude access to 25 quantitative trading datasets through one connector URL.

I built it because I kept hitting the same snag: Claude could write a decent backtest, then I had to stop, find the right dataset, check its schema, write the request, and explain when each observation became available.

Now, the model can handle that retrieval loop directly inside the conversation.

Quick disclosure before we get into it: I built Alphanume, so this is absolutely a product post. I also publish the methodology, samples, weak results, and caveats behind the data since even a frontier-model attached to questionable history just helps you produce questionable research faster.

The 60-Second Setup

The recommended Claude connection uses OAuth, which means there is no API key to copy into a config file. Here is the full setup from the current Alphanume MCP documentation:

1. Open Settings in Claude, then open Connectors.
2. Click Add custom connector.
3. Paste https://mcp.alphanume.com/mcp as the remote MCP server URL.
4. Click Connect and sign in with your Alphanume account in the browser window.
5. Return to Claude. The 25 Alphanume tools are now available in normal conversations.

The connector follows your signed-in Claude account across web, desktop, mobile, and Claude Code, so you only add it once (diagram below).

What Claude Actually Gets

An MCP server is basically just a tool menu. Each tool tells Claude what a dataset does, which parameters it accepts, and what fields come back.

You can ask a market question in plain English, and Claude decides whether it needs IV/HV Premium, historical optionable tickers, the S&P 500 risk regime, stock dilution records, or some combination of them. Alphanume returns the same rows available through the REST API, including the observation dates and point-in-time history.

To further break things down:

• Claude handles retrieval and assembly: it selects tools, constructs calls, joins results, and writes code.
• Alphanume supplies the research layer: fixed historical observations, derived market features, event records, and consistent response conventions.
• You own the research decision: assumptions, execution timing, costs, validation, and whether a result deserves capital.

Claude gets better evidence, and you still make the portfolio decisions.

Start With the Vol Screen

Here is the first prompt I would use. You can paste it into a fresh Claude conversation after connecting Alphanume:

Use the Alphanume MCP. On the latest settled date available to my account:

1. Retrieve the point-in-time optionable equity universe.
2. Find the 10 stocks in the richest decile of IV/HV ratio.
3. Use only finalized volatility observations.
4. Add the S&P 500 risk regime for that observation date.
5. Mark any stocks that also appear in Next-Day Movers.

Return a compact table with ticker, observation date, IV, HV, IV/HV spread,
IV/HV ratio, cross-sectional rank, risk regime, and mover status. State the
tool and filters used for each field. Do not recommend a trade.

Claude should reach for historical optionable tickers, IV/HV Premium, the S&P 500 risk regime, and Next-Day Movers.

What makes this useful is the saved time in the combination of the already useful datasets. You get names where options look rich, the market regime surrounding them, and a separate model’s view of whether each name may move unusually far next session.

Now Check What You Missed

High implied volatility usually has a reason. Sometimes the reason is obvious, and sometimes it’s sitting in a filing you didn’t even know to search for.

Run this second prompt against the tickers Claude just returned:

For the tickers in the prior table, use Alphanume to check the 30 calendar days
ending on each observation date for:

- dilutive filings and shelf registrations
- abnormal SEC filing intensity
- SEC trading suspensions
- disclosed cyber incidents
- FDA response events or advisory committee votes, where applicable

Tag each ticker as clean screen, known event risk, or needs manual review.
Show the event date and source tool behind every tag. Do not infer that an
event caused the volatility premium unless the data establishes that link.

The first screen shows what the options market is charging for uncertainty, next, I use the event overlay to see what might be driving it.

I separate them because a clean volatility premium and an event premium call for different work. A rich ratio with no nearby event might deserve a mean-reversion test, while a shelf registration or FDA date sends me back to the mechanism before I touch a payoff diagram.

Make Claude Show Its Work

The third prompt turns the screen into a research specification. I would keep this part strict because models are extremely happy to fill a missing field with a plausible assumption and continue typing.

Write a point-in-time backtest specification for this hypothesis:

Stocks in the richest IV/HV decile behave differently after removing names
with identified event risk.

Requirements:
- use the historical optionable universe as it existed on each date
- use only data available before the stated entry time
- use finalized IV/HV observations and preserve publication timestamps
- paginate until every requested row is retrieved
- separate event-free and event-tagged cohorts
- report coverage changes and missing observations
- include realistic costs, slippage, spread, borrow, and assignment assumptions
- state which price or option-chain fields must come from another vendor
- do not fabricate option prices or calculate a Sharpe from unavailable data

Produce the research design first. Then write modular Python for the data pull,
joins, validation checks, and analysis.

This is where I save the most time, because Claude can inspect field definitions, build the loader, preserve the observation-time rules, and generate the boring validation checks in the same conversation.

I use Alphanume for the research layer, then pull quotes, surfaces, or adjusted prices from another provider like Massive when a trade-level options backtest needs them. I also make Claude list missing inputs before it writes the backtest.

There Is Evidence Behind All of This

We maintain a public proof page with the full scoreboard, including sample periods, tests, charts, clean results, and nuanced ones.

The studies relevant to this workflow found:

• IV/HV Premium: seller edge sorted from -9.4 to +5.1 vol points across IV/HV-ratio quintiles, a 14.5-point spread before costs.
• S&P 500 Risk Regime: forward 10-day realized volatility averaged 19.0% in risk-off against 12.3% in risk-on, while annualized returns were nearly identical. The signal measures volatility state and should be used for risk scaling.
• Next-Day Movers: selected names realized a 4.8% median absolute move against 2.4% on a normal day.
• Stock Dilution: the published sample had a -14.9% median one-month return, with 71% of dilutive filings lower.

Those are historical gross findings under the published methodology. I’d rerun them with spreads, slippage, borrow, and path risk, then keep testing as regimes change.

Final Thoughts

One of the first problems we ran into with Alphanume was that even if we had an expansive dataset catalog, it would take a lot of work for an trader to understand each one, integrate and test each, and only then, plug it into a larger strategy.

The new MCP makes this process at least 10x faster, while giving you substantially more breadth in how much you can test and ultimately deploy.

We might be biased, but it really is as simple as pointing your desired LLMs at our datasets, and just simply asking questions. Go back and forth with your agent on this a few dozen times and it makes it very unlikely that you won’t be able to put together a profitable strategy of your own.

The free Alphanume account gives you a rolling 30-day window of delayed data at 60 requests per minute, with the latest observation reserved for Pro. That’s enough to connect Claude, run the workflow above, inspect the output, and decide whether the data belongs in your process.

If it does, Pro opens the full history and raises the limit to 600 requests per minute.

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

I’ve spent years deep in quantitative trading research, and I’ve also been a heavy user of AI models since the first public releases, back when the impressive trick was writing a limerick.

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.

This piece first ran on Alphanume Research (alphanume-research.com), where all of our work lives.

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
   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
   * No “reward if 2+ Sharpe“ targets.
   * 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
   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
   The grader counts every experiment in the trajectory and deflates the reward accordingly.
   Ten clean experiments that led to a Sharpe of 1.4 outscores 400 experiments that wound up with a 2.1
5. Robustness probes
   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.

This essay was originally published at Alphanume Research, the research arm of the Alphanume dataset platform. Everything we publish there is available to read right now, including this piece’s follow-up work as the environment gets built. Subscribing by email is the reliable way to catch it.

For most of this industry’s history, there was exactly one way to become a quant: a desk hired you, and a senior trader spent two years beating the bad habits out of you.

You didn’t pick the syllabus. You sat where you were told, watched what you were told to watch, and got asked why does this trade exist? about four hundred times before anyone let you price one.

The strange part, looking back, is how little of that apprenticeship was math.

The math was assumed, but what the desk actually transmitted was order: what to trust, what to distrust, and which skill has to exist before the next one can be stacked on top of it.

The self-taught path has no desk, and you can see the result on any self-taught quant’s hard drive. They all look the same: a backtests folder with nine half-finished notebooks, an indicator strategy that worked for six months and then quietly stopped, three abandoned Coursera specializations in stochastic calculus.

All of the material, in whatever order the internet shipped it.

The self-taught crowd splits into two camps. One grinds measure theory for a year and never places a trade; the other is live by Friday with an RSI crossover and a dream.

Both wash out for the same reason: the sequence.

So, we wrote the sequence down, and then we built it.

Alphanume Learn is our new interactive course platform at learn.alphanume.com, and its first curriculum, Systematic Trading with Market Data, is this exact sequence: twelve modules, 65 lessons, from why edges exist at all to running an automated book.

That means volatility and earnings, the SPX 0-DTE strike band, dilution from S-1 to effectiveness, de-SPACs and corporate defaults, dividends and momentum, alt data, and a final module on automating the whole thing with Claude.

Every lesson is interactive: real Python running in your browser against live Alphanume data, exercises that grade themselves, a knowledge check at the end of each module. Module 1 is free with no account, and the homepage has a runnable demo of the earnings study if you want to poke the format first.

What follows is the whole syllabus, in the order a desk would actually teach it, and why each module sits where it does (map below). Steal the order even if you never sign up; it’s the part that took longest to figure out.

Let’s get into it.

1. Who’s Forced to Trade?

The first thing a desk hands a new hire is a question: why would any edge exist at all, in a market full of people smarter than you?

The answer is that a surprising share of what moves markets is scheduled, disclosed, and queryable:

• Index trackers have to buy at the rebalance, on the rebalance date.
• Insiders are locked up until an expiration that’s printed in the filing.
• SPAC holders can redeem, on a schedule.
• A CFO at the bottom of the financing ladder has to issue, at whatever the price is.

We split edges into structural and statistical, give you a three-part test for a researchable event (recurring, dated, disclosed), and install the four-step loop everything else runs on: hypothesis, data, measurement, attack.

All theory, no code, by design. It’s also the free module.

2. Plumbing Before Alpha

Now the tools, and only now, because a toolkit makes no sense until you know what it’s for.

A reproducible Python environment. A SQL database as the research shelf. Git as the research journal, so six months from now you know why you changed that filter.

Then the anatomy of a market-data API: auth, the {count, data} envelope, and the raise_for_status() line every beginner skips and later regrets. JSON to DataFrame in five lines.

That ingestion skeleton gets reused by every module after this one.

3. Your Backtest Is Lying to You

Before your first strategy, you learn how results deceive, because a beginner with a backtester is a danger to their own account.

Event windows and day 0 come first. Then abnormal versus raw returns: a stock down 10% means nothing in a month where the market fell 12%.

Then the three ways backtests lie:

• Survivorship: your universe only contains the names that lived.
• Delisting: the shorts that went to zero quietly vanish from the data.
• Look-ahead: you traded on a number that didn’t exist yet.

You build a point-in-time universe to kill all three, and the module ends with the honest-results checklist (tails, regime concentration, sample size, costs, borrow) that later modules invoke by name.

4. Expensive Needs Three Numbers

The first real trade, and it opens on a loss: the 48-vol straddle you sell because vol mean-reverts, that prints 61 two days later.

The lesson is that “expensive” means nothing until it’s anchored to three numbers:

• The IV/HV premium: are you being paid relative to what the stock is actually doing?
• IV rank against the name’s own 52-week band: is it stretched for this name?
• Vol-of-vol as the sizing dial: gentle drift or knife fight on the way back?

The capstone puts numbers on it. Selling every straddle indiscriminately captures roughly 0 vol points. Rich names only: +4.6. Rich and stretched, IV rank at 70 or above: +12.5.

The edge lives in the conditioning.

5. The Straddle Is a Forecast

Every pre-earnings ATM straddle is an encoded forecast: the market’s estimate of the move, sitting on the screen, priced and tradeable.

And forecasts have track records. Some names overprice their earnings move every single quarter, and those track records are queryable, quarter by quarter, name by name.

It’s Module 4’s machinery pointed at Module 1’s favorite kind of event. Earnings are the purest scheduled catalyst on the calendar: recurring, dated, disclosed.

You finish by building the pre-earnings screen for the coming reporting week, which is the first time in the sequence you produce something that tells you what to do next Tuesday.

6. Two Integers a Day

At 10:30 AM, a model publishes a strike band for SPX: a lower strike and an upper strike.

The whole module is those two integers and how much playbook fits inside them. Condors sold around the band, butterflies centered inside it, verticals placed off its edges.

The health checks matter more than the structures, though. The rolling containment rate tells you whether the band is still earning its keep, and regime gates decide when the whole thing sits out.

The band’s width, tracked day over day, turns out to be a volatility time series in its own right.

7. Desperation Leaves a Paper Trail

The deepest module in the curriculum, because nobody else teaches this end to end.

It starts with the last-ditch financing ladder: by the time a company sells dilutive equity, it has been turned down for everything cheaper, which makes the raise a one-way message. Then the mechanics of how new shares actually reach the tape, S-1 through EFFECT.

Then the short-selling mechanics, taught honestly:

• Locates, and whether your borrow even exists.
• Borrow fees as a daily carry cost.
• Recalls, where your lender can end the trade for you.
• The dividend liability nobody warns you about.

You run the post-filing drift study yourself, then meet the uglier cousins: ATM programs, shelf registrations, toxic financing.

8. Fragile by Construction

De-SPACs are a cohort the structure itself makes fragile: sponsors get paid for closing a deal before the clock expires, good deal or not.

So the trade is patient. Fade the post-completion basket against an index leg; the gap is invisible on any single day and hard to miss after a quarter.

Lock-up expirations get their own treatment, because they’re the rare supply shock with the date literally printed in the prospectus, months in advance.

And it closes on corporate defaults as an equity event class, the terminal rung of the ladder Module 7 introduced.

9. Now Buy Something

Okay, so after two short-biased modules, the book needs a long side.

Dividends first, starting with who really pays the dividend. Naive dividend capture is a coin flip until you screen for recovery odds, and the screen is the whole trade.

Then cross-sectional momentum, one of the most documented factors in the literature, with real mechanisms behind it: underreaction, herding, and the reconstitution flows Module 1 promised you.

You close by replicating a monthly top-10 momentum basket, weighted by rank slot rather than equally.

You now know what a fragile long looks like, because you just spent two modules learning to short them.

10. Watch What They’re Reading

Prices are one sensor. This module adds the rest:

• Wikipedia page views, converted to z-scores, as an attention gauge: when a sleepy ticker’s page traffic suddenly spikes, someone is curious, and it pays to ask why.
• EDGAR filing bursts, which cluster before announcements.
• The daily movers slate, framed honestly: it flags which names are moving, and the direction is your job.

Every signal gets sliced by sector, because an attention spike means something very different in biotech than in utilities.

This sits late in the sequence on purpose. Alternative data is where beginners drown first, and by now you have Module 3’s checklist to keep every shiny new signal honest.

11. Temperament Is a Position

Everything so far was one study at a time. Now the studies become sleeves, and the sleeves become a book.

Sizing and concentration come first, then the uncomfortable part: “uncorrelated” sleeves stay uncorrelated right up until the day they don’t, and that day is the one you size for.

Then the P&L path itself. Event-driven books carry negative skew, long quiet stretches punctuated by sharp drawdowns, and the core discipline is deciding in advance when you size down, so the decision isn’t made mid-drawdown by your adrenal glands.

One regime flag gates the whole book.

The desk version of this module was a senior trader watching your face during a drawdown. The self-taught version has to be written down.

12. Make It Boring

Production is boring on purpose.

One flat file. Pull, rank, format, send. Scheduling and delivery, so the screen you built in Module 5 lands in your inbox before the open without you touching anything.

Then the modern part: using Claude for idea generation and code generation, with guardrails. You treat it as a junior analyst rather than a slot machine, and you never let it grade its own homework.

The capstone is the whole curriculum compressed: build your own event study, end to end, and defend it against the Module 3 checklist.

Final Thoughts

Look back at the sequence and the desk logic is visible in every seam.

Theory before tools, so you know what the tools are for. Measurement before trades, so you know which results to distrust. Vol before events, the short side before the long, single studies before a book, and automation dead last, once there’s something worth automating.

The material was always out there. The order was the part you used to need a hiring process for.

That’s the part we packaged.

Module 1 is free at learn.alphanume.com, the first lesson takes about ten minutes, and the other eleven modules are included with Alphanume Pro, alongside full access to the data platform the exercises run on.

The exercises pull from the same endpoints our Pro members already trade off. The material is the research process behind the platform, written down in order.

And if you’d rather run the syllabus above on your own, with your own books and your own data, that works too. Either way, start at module one.

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

Queues, workers, a database, a cloud console with forty tabs. So the signal stays a browser bookmark you open when you remember to.

And a signal you have to remember to check is a signal you’ll forget.

Fortunately, there’s a better way. A short Python file and a scheduler that runs it once a day.

No framework, no queue, no classes.

By the end of this you’ll have a next-day-movers slate landing in your inbox every morning before the close, pulled from one Alphanume endpoint.

Let’s build it.

What next-day-movers actually is

next-day-movers is a daily, model-ranked set of equities most likely to make a large move the next session.

The model scores a liquid, optionable universe on implied vol, realized vol, and vol-structure features, then hands back the names sitting at the top. It regenerates every day at 3:30 PM ET, and every row is point-in-time, so what you pull is what the model actually flagged that afternoon.

It’s a short slate. About five names per date, not a screen of fifty.

You hit it like any other Alphanume endpoint:

requests.get("https://api.alphanume.com/v1/next-day-movers?api_key=alp_...")

Same envelope as everything else on the platform, a count and a data list of rows:

{"count": 5, "data": [ ... ]}

Each row carries four fields: date, ticker, return, and absolute_move.

The free tier gives you a rolling 30-day window of delayed data, which is everything you need to build and test this. Today’s live row is reserved for Pro.

One wrinkle to know before the code makes sense. On the newest date, return and absolute_move come back null until that next session closes.

The freshest slate is the names with their moves still pending, which is exactly the list you want emailed to yourself before close.

A few names it actually called

Before wiring anything up, it’s fair to ask whether the list is worth automating. A few of the names it flagged recently, all reproducible on a free key:

date         ticker   next-session move
2026-06-30   SOC      +42.66%
2026-06-26   SLS      +24.71%
2026-06-26   FCEL     +23.95%
2026-06-25   FCEL     +21.98%
2026-06-16   RXT      +21.37%

Cherry-picking the winners is easy and dishonest, so here’s a full slate. On 2026–06–30 the model flagged five names, and every one of them moved:

ticker   next-session move
SOC      +42.66%
FCEL     -11.44%
SLS      -10.21%
AXTI      -9.85%
OUST      -4.04%

The biggest was +42.66%, the smallest -4.04%.

Across the full history, about 49% of flagged names moved more than 5% the next session, about 21% moved more than 10%, and the median absolute move was around 4.8%.

So treat it as a volatility screen. Plenty of names move a little, a meaningful share move a lot, but the model doesn’t call direction for you.

The script

The logic is short and flat. Pull the endpoint, keep the latest date, sort that day’s slate, format it into text.

import requests
import pandas as pd

resp = requests.get(
    "https://api.alphanume.com/v1/next-day-movers",
    params={"api_key": "alp_..."},
)
resp.raise_for_status()
df = pd.json_normalize(resp.json()["data"])

The raise_for_status() line is the one beginners skip and later regret. If the key is wrong or the endpoint is down at 6 AM, you find out right there instead of getting a silent, empty email.

Now keep the newest slate and sort it by size of expected move:

latest = df["date"].max()
slate = df[df["date"] == latest].sort_values("absolute_move", ascending=False)

Then format the names into a plain-text table. The move column reads pending on the newest date, since return is still null until that session closes:

rows = [f"Movers for {latest}", ""]
for _, r in slate.iterrows():
    move = "pending" if pd.isna(r["return"]) else f"{r['return']:+.2f}%"
    rows.append(f"{r['ticker']:<6} {move}")

body = "\n".join(rows)
print(body)

Run it against a free key today and you get the live slate for the upcoming session, moves still pending:

Movers for 2026-07-08

AXTI   pending
BE     pending
FCEL   pending
SLS    pending
SOC    pending

That print is your test harness. Point latest at an older date instead and the same code fills in the realized moves, so you can eyeball the feed for a week before you trust it with your morning.

The only change between the version that prints and the version that emails is the last step: send body instead of printing it.

Zoomed out, the whole thing is five steps and one file (diagram below): a scheduler fires, the script pulls the endpoint, formats the slate, sends it over SMTP, and it lands in your inbox.

Sending it to yourself

Email out of Python is the standard library plus a login. Gmail is the path of least resistance.

import smtplib
from email.message import EmailMessage

msg = EmailMessage()
msg["Subject"] = f"Movers for {latest}"
msg["From"] = "you@gmail.com"
msg["To"] = "you@gmail.com"
msg.set_content(body)

with smtplib.SMTP_SSL("smtp.gmail.com", 465) as server:
    server.login("you@gmail.com", "your_app_password")
    server.send_message(msg)

The one thing that trips everyone up: your_app_password is not your Gmail login password. Google blocks that.

You generate a 16-character App Password at myaccount.google.com/apppasswords, which requires 2-Step Verification turned on first. Paste that into the script and leave your real password out of it.

Prefer Outlook or Zoho? Both work the same way, with an app password, over a slightly different connection.

Outlook is smtp-mail.outlook.com on port 587, Zoho is smtp.zoho.com on port 587, and both use STARTTLS instead of SSL. The only code change is swapping the SSL connection for a plain one that upgrades:

with smtplib.SMTP("smtp-mail.outlook.com", 587) as server:
    server.starttls()
    server.login("you@outlook.com", "your_app_password")
    server.send_message(msg)

That’s the entire production script. Pull, rank, format, send.

Putting it on a server

The script works on your machine, which means it works when your machine is on and you remember to run it. The point was to stop remembering.

For that you want it on a box that’s always awake. We use PythonAnywhere, on the paid Developer tier at $10/month, and the setup is three steps:

1. Upload the one production file and paste in your API key and app password.
2. Create a Scheduled Task that runs the file once a day.
3. Pick the time carefully. PythonAnywhere schedules in UTC, so as of the time of writing, 15 minutes before the close will be 19:45.

That’s it. The task fires every evening, and the email is waiting when you sit down.

Final Thoughts

None of this is specific to next-day-movers.

Swap the endpoint and the same pull-rank-format-send skeleton mails you an IV-rank screen, an earnings vol calendar, or a momentum basket instead. The Alphanume envelope is always {"count": N, "data": [...]}, so the code barely changes when the question does.

The real upgrade is smaller than the model or the email. It’s moving a signal out of a browser tab you have to remember to open and into a place that reaches you on its own.

Grab a free key at alphanume.com, get the print version working against last week’s slate, and once you trust it, give it a server and let it run.

The full code for this experiment can be found via the Alphanume Strategy Lab on GitHub.

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