1.5 Million Crypto Trading Strategies, Free — And Why That Number Is a Trap

Every LLM gives you the same three strategies

Try this right now. Open any model and ask it for ten crypto trading strategies.

You will get RSI oversold. You will get a moving-average cross. You will get a Bollinger band bounce. Then you will get seven more that are those same three ideas with different parameters and a new name.

Somebody actually measured this properly. A developer asked an LLM to generate twenty trading strategies and found fourteen of them were the same thing underneath — all encoding an identical mean-reversion assumption. Twelve of those showed profitable backtests. Every one of them shared the same flaws: curve-fitted parameters, lookahead bias, and no fees.

This is not the model being stupid. It is the model doing exactly what it was trained to do. It is drawing from blog posts, forum threads and tutorial listicles, so it returns the average of the public internet. The average of the public internet is RSI oversold.

You cannot prompt your way out of this. A cleverer prompt still samples from the same distribution. What actually changes the output is changing what the model reads before it answers.

Where 1.5 million comes from

The search space is not small. It is just not reachable by a model that only read blog posts.

AlgoBrain is a knowledge base built to make it reachable, and it derives the number in three steps you can audit yourself:

• 453 strategy pages — each a real, specified design with entry, exit, regime gate and cost assumptions
• → 1,911 distinct strategy designs — the combination matrix crosses 18 strategy primitives against 15 overlay dimensions, with a 0.5 composability haircut because not every viable overlay stacks
• → 1,555,356 specifiable configurations — each design fanned out across the instruments it can actually trade (380 perpetuals, 481 spot markets, 3 options venues), plus pair and basket structures

The script that computes it ships in the repo at tools/count_configurations.py, so you can check the arithmetic rather than take our word for it.

Now the honest part, and we would rather say it than have someone say it for us. A large share of that fan-out is the same strategy applied to a different coin. Running funding carry across 380 perpetuals is one strategy with 380 tickers — it is not 380 strategies. The number that actually matters is the 1,911 distinct designs underneath, and even that is a search space rather than a collection of edges.

We are stating this plainly because the alternative is worse. StrategyQuant advertises "millions of strategies" generated by genetic programming and carries exactly this criticism as a result. A big number with a caveat attached is a useful tool. A big number without one is a liability.

Hold that thought — we come back to why 1.5 million is genuinely dangerous further down.

An LLM wiki is not a RAG database

The usual answer is retrieval-augmented generation: chunk a pile of documents, embed them, and pull the nearest neighbours at query time. That works well when your question maps cleanly to a passage. It works badly for strategy design, because strategy design is a relational problem.

Knowing what a funding rate is does not help you much. What helps is knowing that funding rate connects to carry strategies, which connect to the perpetual venues where they run, which connect to the specific historical episodes where crowded carry positions got liquidated. A chunk retriever hands you a paragraph. What you need is a map.

That is the idea behind an LLM wiki — a knowledge base written as interlinked pages, where the link graph itself carries meaning, and the agent navigates it the way a researcher would.

AlgoBrain is that, built for crypto. It is 4,956 interlinked markdown pages covering markets, concepts, strategies, exchanges, macro and trading history. It is free, and it is dual-licensed: MIT for the tooling, Creative Commons Attribution for the wiki content — which means you can use it commercially, embed it, fine-tune on it, or pipe it into your own agent. The only condition is attribution.

The breakdown, by folder:

• 2,465 market pages — individual coins and protocols, not tickers in a list
• 1,039 concept pages — funding rate, open interest, basis, liquidation mechanics, the actual building blocks
• 453 strategy pages — with entry, exit, regime gates, capacity and crowding risk
• 265 entity pages — exchanges, funds, regulators, people
• 91 news and 58 history pages — so a strategy links to the events that broke it

Inside one family: Stretch Revert

The difference between a link list and a knowledge base shows up when you open a single page. Take the Stretch Revert family.

It is not one strategy. It is fourteen, and they all share one thesis: measure how far price has stretched from its own adaptive mean, then fade the extension. Buy a downside stretch, short an upside stretch.

What separates the fourteen is a single design choice — which average defines the mean. That sounds trivial and it is not, because every smoother trades lag against noise-robustness differently. A slow baseline registers a genuine dislocation too late. A fast one calls every wiggle a dislocation. The family spans ALMA, FRAMA, VIDYA, KAMA, HMA, TEMA, ZLEMA, JMA, LSMA, quadratic regression, Theil-Sen, Laguerre, SuperSmoother and Kalman.

The page specifies the parts that actually decide whether it works:

• Regime gate (mandatory) — a trend/range classification must pass before entry. The edge lives in range-bound chop and dies in trends.
• Entry — price extends beyond a threshold distance from the baseline, as a z-score or band-distance trigger.
• Exit — reversion to the baseline: z-score back through zero, or price back to the middle band.
• Three stop layers — a time stop, a hard stop beyond the band, and a regime stop that flattens if the trend filter flips.
• Honest metadata — expected Sharpe 0.5, expected max drawdown 25%, breakeven cost 25bps, crowding risk high, capacity around $8M.

That last bullet is the part most strategy write-ups omit. A strategy with a 25bps breakeven cost tells you immediately that execution quality decides whether it survives.

The page carries 71 outbound links in its frontmatter alone — out to each of the fourteen estimator pages, the regime concepts, the parent mean-reversion page, and the traders known to run it. That link structure is what the agent walks.

Wiring it into your agent with a local MCP server

A wiki your agent cannot read is just a folder. AlgoBrain ships an MCP server — Model Context Protocol, the standard interface an AI agent uses to reach an external tool.

Start it, then register it:

powershell -ExecutionPolicy Bypass -File tools/start_servers.ps1

claude mcp add --transport http algobrain http://127.0.0.1:8010/mcp

Note the address. 127.0.0.1 is your own machine. The server reads markdown off your disk and that is the entire scope of what it does. There is no API key, no account, no signup, and no data leaving your computer.

That is worth more than convenience right now. Researchers recently demonstrated poisoned tool-description attacks succeeding at rates up to 72.8% against 45 real-world MCP servers. A local, read-only, markdown-backed server with no order-execution surface is a genuinely small attack surface. It gives your agent context, not custody.

Five tools ship with it: wiki_search, wiki_read, wiki_stats, wiki_lint and wiki_ingest.

With that connected, the ten-strategies request stops returning RSI oversold three times. Ask for ten Stretch Revert variants and the agent reads fourteen real estimator pages first, then writes ten genuinely distinct specifications — each with its own lag profile, its own regime sensitivity and a stated reason it should work.

Then backtest it, with the fees switched on

Generating strategies is the easy half, and it is the half that loses people money. So the second free tool is a backtester: Hyperliquid Backtester, MIT licensed, three commands to run.

pip install -e .

export CRYPTODATA_API_KEY=cdk_live_yourkey
hlbt sync --symbol BTC --timeframe 15m --days 90
hlbt run  --strategy strategies/user/frama_stretch_revert.py --symbol BTC --json-out results/frama.json
hlbt demo results/frama.json

It was built around one principle: costs are on by default. Taker fees on both legs, slippage in both directions, funding charged every bar, and leverage-aware liquidation.

Here is what that does to a result. One of the shipped example strategies returns +1.64% over 71 days. Respectable. To earn that $164 of profit it paid $605 in fees — 79% of everything it made went to the exchange. Most backtesters simply never show you that line.

The engine also makes lookahead structurally impossible rather than merely discouraged: a strategy only ever receives data sliced up to the current bar, fills happen on the next bar's open, and when a single bar spans both the stop and the target, the stop wins.

Why 1.5 million is a trap

Here is why 1.5 million is the most dangerous number in this article.

Generating strategies used to be the bottleneck. It is not any more — with a wiki and an agent it costs about a minute. And the moment generation becomes free, the binding constraint moves to validation, which is expensive, unglamorous, and the thing almost nobody does properly.

Test a thousand strategies, pick the best, and you have not found an edge — you have found the luckiest one. This is the multiple-testing problem, and it is well documented: see Harvey and Liu on haircutting Sharpe ratios and Bailey and López de Prado on the Deflated Sharpe Ratio. Search 1.5 million configurations without correcting for it and you are guaranteed to surface something that looks spectacular and is pure noise.

The backtester ships a worked demonstration. A simple moving-average cross was swept across 900 configurations. The best returned +13.64% on the data it was tuned on, and −3.43% on the unseen 30%. None of the top eight survived the switch. A second example swept 640 configurations of an RSI strategy; the winner produced +0.07% out of sample — a coin flip's distance from zero.

So the point of a 4,956-page wiki is not to help you run more tests. It is to help you run fewer, better-motivated ones — where you can state the economic reason a strategy should work before you ever open a backtester.

What happened when we ran it on real money

The FRAMA variant of Stretch Revert is running on a live Hyperliquid account. FRAMA is the Fractal Adaptive Moving Average, introduced by John Ehlers in 2005 — an EMA whose smoothing constant is recomputed every bar from an estimate of the fractal dimension of recent price.

The numbers, as of 20 July 2026:

• Family total: 53 fills, +$50.08, 77% win rate
• frama_stretch_revert: 28 trades, 79% win rate, +$47.17 — one variant out of fourteen produced 94% of the profit
• theilsen_stretch_revert: 80% win rate and −$3.00
• 10 of the 14 variants have never taken a trade — their regime gate has not opened

Now the caveats, because they are the point. Fifty-three fills is a tiny sample on a live account. It is not a backtest result, it is not validated, and it is not evidence of an edge. Anyone presenting a $50 profit over 53 trades as proof of anything is selling you something.

The Theil-Sen line is the genuinely instructive one: a higher win rate than FRAMA and it still lost money, because its losers are larger than its winners. Win rate on its own tells you almost nothing.

And the ten dormant variants are a feature, not a failure. Their regime gate is doing its job by keeping them flat in conditions where the thesis does not hold.

The data underneath

Both tools are free forever. What they need is market history, and that is where CryptoDataAPI comes in — the backtester syncs real Hyperliquid and Binance data straight from it.

Start with a free key, no signup required:

curl -X POST https://cryptodataapi.com/api/v1/auth/keys \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]"}'

Then pull minute-level history:

curl -H "X-API-Key: cdk_live_yourkey" \
  "https://cryptodataapi.com/api/v1/backtesting/klines?symbol=BTC&exchange=hyperliquid&start=2026-04-01&limit=10000"

Funding history comes with open interest attached, which is what makes carry and crowding research possible:

curl -H "X-API-Key: cdk_live_yourkey" \
  "https://cryptodataapi.com/api/v1/backtesting/funding?symbol=BTC&start=2026-04-01"

For bulk research, /api/v1/backtesting/archives/download returns pre-signed Parquet URLs that need no auth header — which is what makes fully autonomous agent fetches work. Deep history via klines_deep reaches back to each market's listing; BTCUSDT on Binance goes to August 2017.

Those bulk endpoints require a Pro Plus key. The free tier covers live endpoints and daily snapshots, and it is enough to explore properly before you decide.

If you want your agent working with live data rather than history, connect the hosted MCP — keyless, with a browser sign-in on the first tool call:

claude mcp add --transport http cryptodataapi https://cryptodataapi.com/mcp

Two servers, two jobs: AlgoBrain on localhost supplies the reasoning substrate, CryptoDataAPI supplies the market. Your agent reads one to form a hypothesis and the other to test it.