DEV Community: GEX.live

LAB now ships a free Idea Feed: rule-shaped trading ideas, deliberately untested

GEX.live — Thu, 20 Aug 2026 18:21:22 +0000

A small release, not a launch. The LAB tab on gex.live has a new rightmost rail called IDEA FEED. It is a stream of short, rule-shaped trading ideas about SPX dealer positioning — "fade the first touch of the call wall after a gap up", that kind of thing — collected daily by a scanner from what people actually discuss, rewritten into something the Lab compiler can parse, and published untested.

That last word is the point.

Why untested is the feature

Every feed of trading ideas on the internet comes with a verdict attached: "this works", "78% win rate", a screenshot of a good month. The feed here refuses to do that. Each card says exactly two things about its idea: compiles clean (our compiler turned the text into a runnable rule without complaint) and untested (nobody has run it against the archive yet). The honest test is yours to run.

One click drops the idea into the Lab conveyor. The compiler has already done the translation, so the first message in your session is the rule itself, stamped ↳ from IDEA FEED · compiles, untested. Running the backtest costs one Lab credit; a failed job refunds itself. If your balance is zero the button does not go dead — it turns into 0 CREDITS · BUY →, remembers the idea you picked, and comes back to it after.

What you will not find

No source attribution on the cards. The idea is the unit, not the poster.
No win rates, no "rated", no thumbs. The archive is 1,000+ finished SPX sessions; the Lab tests against all of it with an out-of-sample split and tells you what survived, which so far is: very little. That verdict is worth more than a badge on a card.
No approval gate. The scanner's finds ship directly every day, so the feed stays fresh by itself. "NEW" is personal — it means new since you last opened the rail, not new for everyone.

Why build a feed that mostly produces "no"

Because the alternative is pretending. The whole site is built on measuring dealer positioning from the tape instead of assuming it from yesterday's open interest, and on publishing every finished session free so the numbers can be checked. A feed of ideas that come pre-blessed would undo that in one rail. A feed of ideas that come with a one-click honest test is the same principle applied to strategy.

Try it: https://gex.live/lab — the rail is on the right, collapsed into a thin spine that says ◂ IDEAS · N NEW. Finished sessions and the idea cards are free; running a test spends a credit.

The Lab: a backtester that is allowed to say "no"

GEX.live — Thu, 20 Aug 2026 18:21:18 +0000

gex.live has two halves. The terminal measures where SPX options dealers are positioned, every second, from the tape. The Lab is the half that asks the uncomfortable question: does any of that predict anything?

What it is

A browser-side conveyor with three stages and a credit meter.

Compile. You describe a rule in plain text — "short the first touch of the put wall when net gamma is below the 20th percentile" — and the compiler turns it into a deterministic rule over the archive's fields: flip, walls, hold band, gamma percentile, DEX/VEX/vanna/charm per strike, time of day. Compiling is free. If the text is ambiguous the compiler says which part, instead of guessing.
Backtest. The rule runs against the full session archive — 1,000+ finished SPX days, every one of them public at gex.live/sessions — with a fixed out-of-sample split. One credit per job; a job that fails refunds itself.
Quant optimize. Optional. A LightGBM pass over the same feature store to see whether there is structure the hand-written rule missed, reported as out-of-sample AUC plus feature importance, not as a new "signal".

The heavy part (DuckDB + LightGBM) runs in a scale-to-zero container that reads snapshots over HTTPS from the public archive. It depends on no machine and on no private data, which is the point: you are testing against the same files anyone can download.

The honest-stats rule

Every verdict comes with its baseline. "Your rule made 3% in-sample" means nothing next to "the unconditional drift over the same days was 2.8%". The report shows both, shows the out-of-sample half separately, and refuses to produce a headline number from the in-sample half. Most rules do not survive this. That includes our own: the site's own directional levels were tested three separate ways across the whole archive and none held out of sample — which is why the terminal sells measurement and not signals, and why the Lab exists at all.

The free Idea Feed

Next to the conveyor sits a rail of rule-shaped ideas, collected daily and published untested. One click compiles one into your session; the test is yours to run and pay a credit for. The feed produces mostly "no". That is what a feed of testable ideas should do.

Who it is for

Someone who has a hunch about dealer positioning — "the hold band pins price into the close", "the flip acts as a magnet after 2pm" — and would rather spend a credit to find out than a month trading it. And, through the MCP server, anyone who would rather ask their AI assistant to run the test than click through a UI.

https://gex.live/lab · archive: https://gex.live/sessions

We listed gex.live on ~15 directories in a week. Here is what that did and did not do

GEX.live — Thu, 20 Aug 2026 18:21:15 +0000

Build-in-public note, no fireworks.

Why bother

Search Console in mid-August was blunt: 6 of 1,098 pages indexed, the rest stuck at "Discovered – currently not indexed", and the Links report empty. Zero external backlinks. The site has a thousand free session pages that nobody can find because nothing points at them. Directories are the cheapest way to get the first handful of pointers, and they are also the corpora that AI assistants read when someone asks "what tools show SPX gamma exposure". So the goal was never traffic. It was (a) backlinks and (b) third-party mentions.

What went in

The same card everywhere: SPX dealer positioning rebuilt from the 0DTE tape; zero-gamma flip, call/put walls, hold band; every finished session free; a backtest Lab; an MCP server; no buy/sell signals. Logo from the favicon, three screenshots (terminal, the measured book, the Lab), category Finance / Investing wherever the menu allowed it.

Done and live: Capterra, AlternativeTo, the official MCP registry (and glama.ai, which pulls from it), TradersList, Firsto, TinyLaunch, Startup Fame, Indie Hackers. Submitted and waiting on a human: StartupStash. Product Hunt is scheduled, one shot only.

What we skipped, and why — this is the useful part

Anything that wants a badge on our homepage for the free tier (Huzzler, Startup Fame's final step). The card is filled and sits unpublished. A measurement terminal with "featured on" stickers on it is a different product.
AI-tool directories (Futurepedia, There's An AI For That). $300–$500 for a listing in front of an audience that wants image generators. The MCP server technically qualifies; the economics do not.
Hashnode. Published a 1,300-word engineering write-up; AutoMod archived it within the hour as "this type of content" on a free subdomain, with an upsell to Pro. The Markdown is saved; it will go out on dev.to instead.
Reddit. Not a channel for this product. Decided, not deferred.
Paid "we submit you to 140 directories" packages. Every one of those directories is on the list above or is a badge farm.

What it actually produced

Honest answer: a dozen dofollow links and a dozen places where the phrase "measured, not assumed" now exists outside our own domain. Indexing has not moved yet — it will not for weeks, if it moves at all. The one thing that changed immediately is that asking an AI assistant about SPX dealer-gamma tools now sometimes returns gex.live, because the MCP registry listing is exactly the kind of page those models read.

The rule we kept

Never write "accurate" about the signing. Internal measurement against Cboe trade-level truth puts simple tape-based signing near a coin flip on 0DTE, and a directory whose stated filter is "no dishonest offerings" will check. Every listing says measured rather than assumed, which is true, and links to the free archive so anyone can verify it.

https://gex.live — the archive is at /sessions, no account needed.

Backtest SPX dealer-gamma rules from your AI assistant

GEX.live — Thu, 20 Aug 2026 18:21:11 +0000

gex.live has an MCP server. Add it to Claude, Cursor, ChatGPT or any MCP client and the assistant can read the dealer-positioning archive and drive the backtesting Lab on your behalf. The one-line version is the title. Here is the rest.

Two tiers, one rule: free data stays free

Free, no key — the same finished-session data that is free on the website:

list_sessions — finished SPX sessions in the archive, newest first, paged (max 50 a call).
get_session(day) — one session's dealer-positioning summary: OHLC, the zero-gamma flip and how often price crossed it, call/put walls, the hold band, net-gamma percentile, ATM IV at the open. Measurements only.
get_levels(day) — just the level set for one session — flip, call resistance, put support, hold band — plus where the session closed relative to them.

Keyed — the Lab, metered in credits exactly as on the site. These tools only appear in the tool list once the client sends a Lab token:

lab_compile(message) — turn a plain-words idea ("fade a +3 sigma stretch above vwap on top-decile volume") into a testable rule. Free of credits, needs a positive balance. Returns the compiled spec, a clarifying question, or compile errors — never a guess.
lab_run(id, kind) — one conveyor step: backtest first (rule → tested), then quant (the LightGBM optimize, tested → ready). One credit, refunded on failure. The result is the engine's honest verdict: per-leg era tables — all / this year / holdout.
lab_state — your whole Lab in one call: ideas with stages and results, which idea holds the conveyor, your credit balance.
lab_thread(id) — the compile-chat thread for one idea.
lab_idea(id, action) — desk actions: put a ready idea on the desk, drop it back to the start, delete, or set its desk display/alert options.

When a keyed tool is called without a token, the error is the instruction: what it does, where to get a key (gex.live/account → LAB & API, shown once, scoped to the Lab only, revocable), what it costs. The assistant relays it verbatim. The funnel is one sentence.

Works in claude.ai out of the box

Header-based auth is fine for Cursor and the CLI (claude mcp add --transport http gex https://mcp.gex.live/mcp --header "Authorization: Bearer labk_…"). claude.ai web and desktop cannot send headers, so there is an OAuth facade on the product host: discovery documents, dynamic client registration, a consent page behind the normal login, PKCE required, codes encrypted and short-lived. Connect once, the Lab tier is there.

What it is for

"Show me the last ten sessions where the flip was above spot at the open and tell me what the close did." → list_sessions, get_session × 10, an honest summary.
"Test: fade the first touch of the call wall after a gap up." → lab_compile, then lab_run(backtest), a verdict with era tables and a holdout column — probably a polite no.
"Where is my Lab at?" → lab_state: stages, results, balance.

What it is not

A signal service, and not a live feed: today's positioning is the paid stream on the site, not an MCP tool. The server exposes finished measurements and a way to test rules against them. If a rule survives the holdout the Lab will say so; so far, very few do, including the site's own levels. The MCP server is listed in the official registry (registry.modelcontextprotocol.io, live.gex/gex-mcp) and on glama.ai.

Install: https://gex.live/mcp · free archive: https://gex.live/sessions

Three books that disagree: rebuilding an options dealer's position from the tape

GEX.live — Thu, 20 Aug 2026 16:31:07 +0000

Almost every gamma-exposure chart you have seen is built the same way: take yesterday's end-of-day open interest, assume dealers are short calls and long puts, multiply, plot. It renders instantly and it is wrong in a specific, knowable way — the sign is an assumption, not a measurement, and the data is a day stale before the opening bell.

I spent a while building the other version: sign every option print as it happens and rebuild the dealer's book from the tape. This is a writeup of how that works, what broke along the way, and the uncomfortable result at the end.

The convention is doing the heavy lifting

When a chart says "dealer gamma", it means someone decided which side of every open contract the dealer is on. The standard convention says customers buy calls and buy puts, so dealers are short both, except the sign is flipped for puts to make the arithmetic come out. Reasonable as a prior. Completely untested per strike, per day.

The conventional book is still worth drawing — a lot of people trade off it, so it moves markets whether or not it is right. But it should not be the only book on screen.

Signing prints instead of assuming

The measured book starts from the 0DTE tape and asks, for every print: did this trade at the bid or the ask? Buyer-initiated at the ask, seller-initiated at the bid, dealer takes the other side.

That is the Lee-Ready quote rule, and it has a known failure mode: prints that land exactly at the midpoint are unclassifiable. The textbook fix is a tick rule fallback. The fix that actually mattered here was different.

SPXW quotes sit on a 0.05/0.10 grid. On an odd-tick spread, a print at the exact arithmetic mid is mechanically impossible — the price simply cannot land there. A strict at-mid test therefore under-produces at-mid volume compared to the published benchmarks, not because the market behaves differently but because of the tick grid. So the exact-mid test becomes a band:

MID_BAND_F = 0.20   # unclassified if |px - mid| < f * half_spread
TICK_EPS   = 0.01

mid  = 0.5 * (ask + bid)
half = 0.5 * (ask - bid)
dev  = abs(price - mid)

in_band = dev < MID_BAND_F * half          # too close to call
at_ask  = ~in_band & (price >= ask - TICK_EPS)
at_bid  = ~in_band & (price <= bid + TICK_EPS)

A fifth of the half-spread. Prints inside the band are marked unclassifiable rather than guessed at, which matters more than it sounds — a wrong sign is worse than a missing one, because it moves the number in the opposite direction.

The part that quietly ruins everything: multi-leg orders

Sign prints one at a time and you will get spreads catastrophically wrong.

A trader sells a call spread. Two legs hit the tape. One leg prints at the ask, the other at the bid. Signed independently, you record a customer buy and a customer sell, and the dealer's net position barely moves. In reality the customer put on a single directional structure and the dealer took the whole thing.

So prints get grouped into packages before anything is signed. A condition is treated as multi-leg when at least 80% of its prints share an exchange sequence number:

ML_SHARE_THRESH = 0.80      # multi-leg if >=80% of a condition's prints
                            # share an exchange sequence with another leg
PKG_KEEP_STATUS = ("ok",)   # only packages that reconcile cleanly are kept

The package is signed as one order, and its customer quantity is only kept when the package reconciles. Packages that do not reconcile are dropped rather than half-counted. Again: a hole beats a lie.

Three books, side by side

The result is three different views of the same expiry, and the honest way to present them is next to each other instead of picking a winner.

VOLUME is cumulative session volume by strike under the conventional sign. It shows where today's activity concentrated.

OI is open interest under the usual dealer-short-calls convention — the chart everyone else draws.

MEASURED is net dealer position signed print by print from the tape as described above.

When the three agree, the level is probably real. When they diverge, that divergence is itself the information, and hiding it behind a single blended number would be the least useful thing to do with it.

What gets drawn on top

Once there is a book, the derived levels follow: the zero-gamma flip where net dealer gamma crosses zero, the call wall and put wall at the largest concentrations, a dealer hold band, and the session's net-gamma percentile against every prior session. Then delta and vega exposure profiles, and vanna, charm and 25-delta skew overlays.

All of it recomputes every second while the market is open.

The uncomfortable part

Here is where the writeup stops being a victory lap.

I built a backtesting harness over the full archive and tested whether these levels predict direction — three separate formulations, all of them out of sample. None survived. Not one directional edge cleared an honest bar.

That result shipped. The product has no buy or sell signals, no price targets, no arrows, and the site says why: there is nothing honest to put in them. The levels describe where hedging pressure plausibly sits. They do not tell you what happens next, and a tool that always says yes would just be selling you your own confirmation bias.

This is, commercially, a stupid thing to publish. It is also the only version I would use myself.

Engineering notes

A few decisions that turned out to matter more than expected:

The terminal is the homepage. No marketing splash, no "see how it works" funnel. You land on / and the product is already running. There is a second door at /about for people who want to read first, but the root is the tool.

The server has zero dependencies. One Node file, no framework, the same file locally and in the container. A finished session snapshot is about 5.7 MB of JSON, almost all of it 23,400-long arrays, which gzips roughly 7.7x. So publish writes a pre-compressed twin next to the plain file and the server hands it over whenever the client accepts gzip. Nothing is compressed per request — that cost is paid once, at publish time.

The archive is public on purpose. Every finished session since April 2022 replays in full, with no account and no card. That is 1,083 sessions as of writing. Only the current day is behind the paywall. It sounds like giving away the product; it is actually the only honest way to sell a measurement tool — every level the terminal draws can be checked against a thousand days of history before anyone pays anything.

There is an MCP server, so the same sessions and levels can be queried from an AI assistant conversationally instead of through the UI.

Try it, or don't

The archive is at gex.live — open it, pick any past session, and watch the three books argue with each other. No signup wall. If the measured book and the conventional book agree on a day you remember, that is mildly interesting. If they don't, that is the whole reason the thing exists.

And if you build market-data tooling: the two things I would do differently from the start are grouping packages before signing anything, and being willing to mark data unclassifiable. Both cost you coverage. Both are worth it.