I've been building trading bots for a while. Nero X is the newest, and I just finished two months of paper trading with it. It came out green, the per-trade edge landed almost exactly where the backtest predicted, and it ran 43 sessions without a single crash. Here's the full story — what it does, what it earned, and how it proved itself.

What Nero X does

Nero X trades BSOL, the Bitwise Solana ETF, on the Alpaca API. It's long only and intraday only — flat every night and every weekend, by design. There's no overnight exposure, and an independent guard thread makes sure nothing stays open past 15:55 ET.

Every morning at 10:30 ET it scores the day. The inputs are how Bitcoin and Solana moved during the first trading hour — BTC's first-hour return and acceleration, how far SOL is lagging BTC, where SOL sits in its own range, and the previous day's Nasdaq close. A frozen logistic model turns those into a score, and the bot only trades the top ~20% of days. The rest of the time it prints SKIP and stays in cash. That selectivity is the whole point: it waits for the setup it was built for and ignores everything else.

When it trades, the rules are fixed and simple:

• Entry: a passive limit order at the bid — it earns the spread instead of paying it. Unfilled in 10 minutes? Skip the day.
• Stop: −0.75%, resting at the broker so it's enforced even if the bot goes down.
• Trail: once a trade reaches +0.50%, the stop trails 0.60% below the running peak.
• No profit target. Winners are never capped — the trail lets them run.
• End of day: hard flatten at 15:55 ET.

If you read the model's weights, its thesis is “BTC is rallying and SOL hasn't caught up yet.” It's a lag/catch-up trade with a specific mechanism behind it — not a generic momentum chase.

Built to be trusted

Before it ran a single live session, the strategy went through validation that was deliberately designed to break it:

• Nested walk-forward on 1,047 SOL sessions (2021–2026). Every parameter — stop width, trail settings, selectivity — was chosen inside the training window only, then applied blind to the next block. No tuning on the full history.
• Frozen, then tested on an instrument it had never seen. The model was trained on SOL data ending the day before BSOL existed, then applied to BSOL's own price history with zero refitting.
• Real costs, measured not assumed. BSOL's actual spread at 10:30 ET — 0.096% — was pulled from live quote data and charged in every backtest.

The frozen out-of-sample result on BSOL: 42 trades, 59.5% win rate, +0.216% per trade. The SOL backtest and the BSOL transfer agreed with each other — and that agreement is what earned it a live run.

Two months on paper: green, and on target

July 20 to September 17, 2026 — 43 trading sessions on a $1,000 Alpaca paper account.

Three things stand out.

The fire rate was 21% against a 20% target. The classifier is doing exactly what it was designed to do — sitting out four days in five and only engaging when the setup is there.

The edge per trade landed on the prediction: +0.225% live vs +0.21% backtested. That's the number that matters most, because it's the one that compounds. Win rate was lower than the backtest — 4 of 9 — but the asymmetric exit design absorbed that completely. Losers are cut at −0.75%; winners run. The +1.72% on September 14 is what happens when the trail is allowed to do its job. Fewer wins, same expectancy is the signature of a well-built exit, and it's exactly what showed up.

The worst trade was −0.86%, right on the backtest's −0.85%. The downside behaved precisely as modelled.

Every trade, in order:

Look at the losers: −0.05%, −0.10%, −0.14%. Three of the five were near-scratches. The trail arms fast and gives very little back. Only one trade in nine hit the full stop.

What the paper period hardened

This is why you paper-trade before you go live: the market finds the edge cases a backtest can't. Nero X found three, and every one is fixed in the version you can download.

The broker-side stop. The first build checked the stop by polling the price every 15 seconds. On July 21 the price dipped through the stop level for six seconds — between two polls — and recovered. The bot never saw it. The fix moved the protective stop to rest at the broker, where it triggers on any print and keeps working even if the process dies. That single change also closed the tail-risk scenario where a VM outage leaves a position unprotected.

The exit race. Alpaca cancels orders asynchronously. On August 3 the bot cancelled its stop, tried to sell one second later, and the broker said the shares were still reserved. The independent end-of-day guard caught it and flattened seven seconds later. The fix: wait for the broker to confirm the shares are free before selling. The guard thread — which I'd built as a belt-and-braces measure — earned its place twice during the run.

Real fill prices. A partial fill on August 5 revealed the P&L logger was reading a quote instead of the actual fill. Fixed to use the true weighted execution price, partials included.

Three edge cases, all caught on paper, all closed. The shipped bot is the hardened one.

What held up

The fill assumption — the one that matters most. Nero X's entry is a passive limit at the bid. If that doesn't fill, there's no trade. Live: 92–94% of entries filled, the spread held at 0.096–0.099%, and the filled days were not systematically worse than the unfilled ones. The core execution assumption survived contact with the market.

The machinery. Zero crashes in 43 sessions. Three Alpaca API outages — timeouts and 500 errors — survived without intervention. Every 10:30 decision fired within four seconds of the mark. It ran on a free-tier Google Cloud VM at about 100 MB of RAM, which the deploy scripts set up for you.

Before you run it

Nine trades is a small sample — enough to confirm the machinery and the fill assumption, not enough to nail down the long-run return with precision. Run it on paper first; it's free, and the whole point of the design is that it costs nothing to watch. And know what it is: a selective, low-exposure tactical bot that's in cash most days. It's built to compound a small, consistent edge with tightly controlled downside — not to ride a trend. Over the same two months BSOL itself rallied hard; Nero X isn't trying to catch that, and it isn't exposed when it reverses either.

What you get

Nero X is available now on my Ko-fi shop. The package is the complete, hardened bot:

• The bot itself — one Python file, no framework, runs on 100 MB
• The frozen model — no ML dependencies at runtime
• A live web dashboard: next action with countdown, today's prediction explained feature by feature, position and trailing stop, full history
• Deploy and health-check scripts for a free-tier GCP VM, with the exact settings that keep it at $0/month
• The complete paper-trading record — every trade and every fix
• Sixteen research scripts that built and validated the model, plus a list of everything I tested and rejected so you don't have to

Everything is documented well enough that you can retrain it, point it at a different instrument, or reuse the validation harness for your own ideas.

What's next

Nero X is done and shipping. The next project is Nero DX: longer horizon, broader universe, and a specialised LLM in the loop. I'll write that one up the same way when it's ready.

Not financial advice. Start on paper.

Joel Stafford

My profession is online marketing and software development (10+ years experience), a lot of AI related projects nowadays, check my latest works here. But my real passion is reading books both fiction and non-fiction. I have several favorite authors like James Redfield or Daniel Keyes. If I read a book I always want to find the best part of it, every book has its unique value.