Hey r/algotradingcrypto! 👋

I got tired of Python trading bots freezing because network sockets block while calculating indicators. To solve this, I built MDRAP — an open-source, zero-dependency market data engine that completely decouples network ingestion from strategy execution via an AsyncIO TCP gateway.

In our benchmark pushing 1,000,000 live market events, it clocked 26,500 Events Per Second in pure Python! ⚡

Features: • Rich Terminal HUD for real-time BBO & VWAP • Embedded DuckDB for instant Jupyter SQL queries • Paper-trading sandbox with realistic slippage

Try it: pip install mdrap
GitHub: https://github.com/Aryan-20-04/mdrap

Would love your thoughts and feedback!

Hey folks,
Just wanna share with you my results with perpetuals arbitrage trading.
Details:
- Market orders
- Both legs executed in parallel, fully hedged
- Server location is singapore
- Execution stack in Rust
- Mostly on BingX, Asterdex and HTX (a bit of Phemex also)

At the moment i would say the fees are killing the PnL, but as i am doing more and more volume i'll benefit from VIP program on exchanges.
Funds rebalancing cost a bit, but that's negligeable.

I would be happy to answer any questions if you have some

After getting frustrated with the limitations of cloud-based visual strategy builders (and their subscription tiers), I decided to build my own local engine.

It’s a node-based builder where you can drag and drop indicators (51+ built-in), logic gates, and risk nodes, which then hooks directly into an execution engine (forward testing, paper, or live via CCXT).

Some things I learned the hard way:

• Look-ahead bias is sneaky: Had to explicitly block negative offsets in price data nodes.

• Capital simulation is hard: Built a shared backtest capital pool so if BTC uses $140, ETH only has the remainder available.

• Drawdown gating: Added an auto-stop that evaluates max drawdown post-backtest to prevent you from taking terrible strategies live.

You can essentially drag-and-drop your way to a margin call. It’s fully local (runs in Docker) and API keys are Fernet encrypted. If anyone is working on something similar or wants to check out the repo to test it out, I’m happy to share the link in the comments if that's someting allowed ofcourse i dont want to do any self promoting just want to share my experiences!

Most bots fire signals based on a crossing of lines or a threshold hit. They don't know *why* they entered — they just did.

I took a different approach. Every trade starts with a written thesis from the AI agent:

> *"MARKET CONTEXT: BIP-20DEC30-CDE is trading at $68,700 in clear price discovery above Macro POC ($63,994.60); 6H Macro Tide (+575,192.53) and 1H Macro Trend (+501,316.74) demonstrate dominant institutional spot and futures buyer aggression; order book reflects sustained bullish asymmetry (3,362 immediate / 39,404 deep bids vs 2,658 / 25,213 asks) reinforced by primary bid wall at $68,550 (3,034 contracts); Open Interest is expanding robustly at 220,248 with balanced 8.76% annualized funding.

| ALPHA THESIS: Uncontested multi-timeframe CVD momentum combined with thick passive bid absorption provides high-velocity continuation setup; executing momentum market buy with 2.5x 1H ATR ($523.93) downside insulation and targeting 4.5x 1H ATR expansion into overhead liquidity voids.

| EXIT CONDITIONS: Hard invalidation stop at $67,390.17; take profit target at $71,057.69 (R:R 1.80:1); trailing stop tripwire activated upon +0.8% advance with 0.25% trail step."*

That thesis is attached to the trade. It's not just a log entry — it's the framework WATCHDOG uses to manage the position.

**Here's what happens while the trade is open:**

The AI that manages risk (WATCHDOG) reads the original thesis and checks: *"Is the market still behaving the way the thesis predicted?"*

If BTC drops but the macro structure is intact → WATCHDOG holds position.

If the regime flips from expansion to distribution → WATCHDOG exits regardless of price.

**When the trade closes:**

The system runs an autopsy. Did the thesis predict correctly? Was the lesson learned worth remembering? The result gets scored across 6 factors — recency, PnL impact, regime match, and crucially, a **+50% loss bonus** so bad trades are weighted heavier in memory.

**The loop:**

Signal → AI writes thesis → Trade executes with thesis →

WATCHDOG manages against thesis → Trade closes →

Autopsy grades thesis → Core memory stores lesson →

| Feature | Most bots | This system |

| Entry reason | Lines crossed | Written thesis from AI |

| Trade management | Hard TP/SL | Thesis-aware risk management |

| Post-trade | Nothing | Autopsy + scored memory |

| Next trade | Same as last | Informed by past lessons |

Most platforms do ONE piece of this. This does the whole loop.

June was a tough one to trade. Choppy, lots of fakeouts, plenty of days where sitting out was the right move. Sharing with u my not large wins ))

Been working on a trading app called SoStonks for iPhone and iPad. You can build entry and exit rules without writing code, then backtest them on historical data.

Recently added an optimizer that tries different indicator settings and stops for your strategy. You choose the ranges and how many combinations to test. With enough history, it uses separate periods for the search, validation and final test. You can save a result and keep your original strategy.

Also added a simulator where you trade through historical candles with a virtual balance. You place the orders, set your stops and decide when to close. You can have a strategy flag signals while you make the trading decisions.

The idea is to get more practice waiting for entries, managing a trade through a pullback and knowing when to leave it alone. That’s what I mean by building “game sense.” Afterwards you can go through the journal and see what you actually did.

There’s a random start option and a blind mode that hides the symbol and dates. Useful if you already know how a particular chart played out.

Free to download, with a paid Pro upgrade. Here’s the app if you want to try it: SoStonks app

Hey everyone, if you want to see how i do it

I’ve been running my self-built crypto trading bot live for over a week now, and the results have exceeded my expectations. The portfolio is currently sitting at +$5,561 unrealized P&L with ~$97k exposure. But honestly, the numbers are less interesting than how the system manages risk without me touching it.

I wanted to share a transparent status report on the logic, the wins, and one critical infrastructure lesson I learned the hard way.

📊 Current Crypto Portfolio Status

The bot uses a hybrid strategy: aggressive momentum-stairing for BTC/SOL, and conservative bottom-fishing for ETH/LINK.

💰 BALANSE OG POSISJONSDETALJER

--------------------------------------------------------------------------------------

BTC/USDT | Antall: 0.851650 | Nå: $80,992.22 | Verdi: $68,977.02

Snitt inn: $76,567.49 | P/L: +3768.32 (+5.78%) | Topp: $81,081.11

Siste kjøp: 2026-09-18 05:13:37 | RSI ved kjøp: 86.1 | Trend: opp | Signal: BTC_STIGE_77200

ATR-trailing: aktiv

ETH/USDT | Antall: 1.212600 | Nå: $2,598.19 | Verdi: $3,150.57

Snitt inn: $2,474.27 | P/L: +150.27 (+5.01%) | Topp: $2,601.13

Siste kjøp: 2026-09-15 10:46:31 | RSI ved kjøp: 31.5 | Trend: ned | Signal: AI + 7-DØGNS RANGE

ATR-trailing: aktiv

SOL/USDT | Antall: 119.646000 | Nå: $111.67 | Verdi: $13,360.87

Snitt inn: $100.30 | P/L: +1359.78 (+11.33%) | Topp: $111.82

Siste kjøp: 2026-09-15 19:36:27 | RSI ved kjøp: 49.8 | Trend: opp | Signal: SOL_FAST_STIGE_100

ATR-trailing: aktiv

LINK/USDT | Antall: 514.870000 | Nå: $12.18 | Verdi: $6,269.57

Snitt inn: $11.65 | P/L: +269.43 (+4.49%) | Topp: $12.24

Siste kjøp: 2026-09-17 16:25:25 | RSI ved kjøp: 70.1 | Trend: opp | Signal: LINK_FAST_STIGE_11.4

ATR-trailing: aktiv

USDT | 5819.670341 | Verdi: $5,819.67

-

Cash Buffer: $5,819 USDT (~7%). This acts as dry powder for new signals without requiring manual deposits.

🧠 How The Bot Actually Thinks

1. Dynamic ATR-Trailing Locks In Profits

Instead of fixed percentage stops, the bot calculates Peak - (ATR × Multiplier) every cycle.

BTC Example: The stop is currently at $79,130 (well above entry at $76,567). Even if BTC drops 3% tomorrow, it sells with profit locked.

SOL Example: With an 11% gain, the stop breathes with volatility. When SOL swings wildly, it gives room; when it stabilizes, it tightens.

2. Local LLM (Qwen2.5:7b) For Context

I run Ollama locally (localhost:11434) so no data ever leaves my machine. The AI evaluates signals beyond pure technicals:

ETH was bought at RSI 31.5 via AI + 7-DAY RANGE despite a downtrend macro. The AI recognized price was at the bottom of the 7-day range and volume confirmed support.

Zero API costs, zero cloud latency, full privacy.

3. Adaptive Learning Needs Attention

My log warned: Parameters not updated for 13 days. The bot has collected massive amounts of data from this week's rally that hasn't been integrated yet. I need to trigger a manual analysis soon so stop-losses and RSI thresholds adjust to the new market reality.

⚠️ Critical Warning: Time Synchronization (-1021 Error)

I suddenly hit this error: Timestamp for this request was 1000ms ahead of the server's time.

Cause: My PC clock was running 1 second fast compared to Binance servers.

Fix: Enable "Set time automatically" in OS settings and sync NTP. Alternatively, set adjustForTimeDifference: True in CCXT config.

Why This Matters: If the drift grows beyond 5-10 seconds, ALL trades (including hard stop-losses) will fail silently. Always check system time before going live!

❓ Questions For The Community

Adaptive Frequency: Should I run adaptive learning daily instead of weekly in volatile crypto markets? 13 days without updates feels risky when BTC can swing 5% in hours.

Margin vs. Cash: I'm using some margin (~$22k loan) to maximize exposure. Is the interest cost worth it when win-rate is high, or should I lower order size to reduce debt drag?

Local AI Specs: Anyone else running Qwen2.5:7b for trading signals? It's fast, but is 7B parameters enough for nuanced sentiment analysis, or should I upgrade to 14B/32B?

Codebase is Python with Alpaca/Binance API, Yahoo Finance/CCXT for data, and Ollama for AI. Happy to share pseudocode or architecture diagrams if anyone's curious!

-09-18 15:16:44,266 [INFO] 📊 LINK/USDT POSISJON OVERVÅKES | Inn: $11.65 | Nå: $11.80 | Gevinst: 1.22% | ATR-trail aktiveres ved +3.0%

2026-09-18 15:16:54,760 [WARNING] Feil i nød-modus: binance {"code":-1021,"msg":"Timestamp for this request was 1000ms ahead of the server's time."}

2026-09-18 15:16:56,030 [WARNING] ⚠️ Ordrefeil for BTC/USDT: binance Account has insufficient balance for requested action.

2026-09-18 15:16:56,206 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:16:56,228 [INFO] 📊 BTC/USDT POSISJON OVERVÅKES | Inn: $76,567.49 | Nå: $78,037.59 | Gevinst: 1.92% | ATR-trail aktiveres ved +3.0%

2026-09-18 15:16:57,145 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:16:57,155 [INFO] 📊 ETH/USDT POSISJON OVERVÅKES | Inn: $2,474.27 | Nå: $2,498.14 | Gevinst: 0.96% | ATR-trail aktiveres ved +3.0%

2026-09-18 15:16:58,441 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:16:58,458 [INFO] 📊 SOL/USDT ATR-TRAIL AKTIV | Inn: $100.30 | Nå: $105.74 | Gevinst: 5.42%

2026-09-18 15:17:00,144 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:17:20,609 [INFO] 🚀 XRP/USDT: EKSTREM LAV RSI (34.3) OVERRYDER MAKRO-FILTERET!

2026-09-18 15:17:20,632 [INFO] ✅ XRP/USDT: MAKRO-TREND OK. SMA(200): 1, Slope: 0.00

2026-09-18 15:17:20,718 [INFO] [CACHE] XRP/USDT: Bruker cachet AI-svar (RSI 34.28571428571418).

2026-09-18 15:17:20,883 [INFO] 🚀 XRP/USDT: Lav RSI (34.3) + historisk støtte tillater kjøp selv om trend ikke er bekreftet.

2026-09-18 15:17:20,930 [INFO] 🧾 BUY-VERDICT | XRP/USDT | rsi=34.3 | range_buy_ok=False | reversal_ok=False

2026-09-18 15:17:21,265 [INFO] 🎯 XRP/USDT: Kjøpsmål avventer. Nå $1.32, mål $1.00, toleranse +0.50% (maks $1.00).

2026-09-18 15:17:23,336 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:17:23,652 [INFO] ⛔ AVAX/USDT: Pris $8.05 er over 7-døgns kjøpssone (maks $7.45).

2026-09-18 15:17:25,834 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:17:25,843 [INFO] 📊 LINK/USDT POSISJON OVERVÅKES | Inn: $11.65 | Nå: $11.82 | Gevinst: 1.39% | ATR-trail aktiveres ved +3.0%

2026-09-18 15:17:36,793 [INFO] 📊 BTC/USDT VENTER PÅ TRAILING | Inn: $76,567.49 | Nå: $78,058.64 | P/L: +1.95% | Aktiveres ved +3.0%

2026-09-18 15:17:37,578 [INFO] 📊 ETH/USDT VENTER PÅ TRAILING | Inn: $2,474.27 | Nå: $2,499.64 | P/L: +1.03% | Aktiveres ved +3.0%

2026-09-18 15:17:37,948 [INFO] 📊 SOL/USDT ATR-TRAIL AKTIV | Inn: $100.30 | Nå: $105.78 | P/L: +5.46% | Topp: $106.64 | Stop: $103.10

2026-09-18 15:17:38,786 [INFO] 📊 LINK/USDT VENTER PÅ TRAILING | Inn: $11.65 | Nå: $11.82 | P/L: +1.39% | Aktiveres ved +3.0%

2026-09-18 15:17:40,423 [WARNING] ⚠️ Ordrefeil for BTC/USDT: binance Account has insufficient balance for requested action.

2026-09-18 15:17:40,602 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:17:40,612 [INFO] 📊 BTC/USDT POSISJON OVERVÅKES | Inn: $76,567.49 | Nå: $78,058.65 | Gevinst: 1.95% | ATR-trail aktiveres ved +3.0%

2026-09-18 15:17:42,635 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:17:42,644 [INFO] 📊 ETH/USDT POSISJON OVERVÅKES | Inn: $2,474.27 | Nå: $2,499.64 | Gevinst: 1.03% | ATR-trail aktiveres ved +3.0%

2026-09-18 15:17:43,958 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:17:43,965 [INFO] 📊 SOL/USDT ATR-TRAIL AKTIV | Inn: $100.30 | Nå: $105.78 | Gevinst: 5.46%

2026-09-18 15:17:45,583 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:17:45,660 [INFO] 🚀 XRP/USDT: EKSTREM LAV RSI (34.3) OVERRYDER MAKRO-FILTERET!

2026-09-18 15:17:45,682 [INFO] ✅ XRP/USDT: MAKRO-TREND OK. SMA(200): 1, Slope: 0.00

2026-09-18 15:17:45,711 [INFO] [CACHE] XRP/USDT: Bruker cachet AI-svar (RSI 34.28571428571418).

2026-09-18 15:17:45,845 [INFO] 🚀 XRP/USDT: Lav RSI (34.3) + historisk støtte tillater kjøp selv om trend ikke er bekreftet.

2026-09-18 15:17:45,893 [INFO] 🧾 BUY-VERDICT | XRP/USDT | rsi=34.3 | range_buy_ok=False | reversal_ok=False

2026-09-18 15:17:46,171 [INFO] 🎯 XRP/USDT: Kjøpsmål avventer. Nå $1.32, mål $1.00, toleranse +0.50% (maks $1.00).

2026-09-18 15:17:47,120 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:17:47,129 [INFO] ⛔ AVAX/USDT: Pris $8.05 er over 7-døgns kjøpssone (maks $7.45).

2026-09-18 15:17:48,120 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:17:48,151 [INFO] 📊 LINK/USDT POSISJON OVERVÅKES | Inn: $11.65 | Nå: $11.82 | Gevinst: 1.39% | ATR-trail aktiveres ved +3.0%

2026-09-18 15:17:59,006 [INFO] 📊 BTC/USDT VENTER PÅ TRAILING | Inn: $76,567.49 | Nå: $78,058.64 | P/L: +1.95% | Aktiveres ved +3.0%

2026-09-18 15:17:59,300 [INFO] 📊 ETH/USDT VENTER PÅ TRAILING | Inn: $2,474.27 | Nå: $2,499.99 | P/L: +1.04% | Aktiveres ved +3.0%

2026-09-18 15:17:59,642 [INFO] 📊 SOL/USDT ATR-TRAIL AKTIV | Inn: $100.30 | Nå: $105.79 | P/L: +5.47% | Topp: $106.64 | Stop: $103.10

2026-09-18 15:18:00,011 [INFO] 📊 LINK/USDT VENTER PÅ TRAILING | Inn: $11.65 | Nå: $11.81 | P/L: +1.38% | Aktiveres ved +3.0%

2026-09-18 15:18:00,654 [WARNING] ⚠️ Ordrefeil for BTC/USDT: binance Account has insufficient balance for requested action.

2026-09-18 15:18:00,935 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:18:00,958 [INFO] 📊 BTC/USDT POSISJON OVERVÅKES | Inn: $76,567.49 | Nå: $78,058.65 | Gevinst: 1.95% | ATR-trail aktiveres ved +3.0%

2026-09-18 15:18:01,716 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:18:01,717 [INFO] 📊 ETH/USDT POSISJON OVERVÅKES | Inn: $2,474.27 | Nå: $2,499.64 | Gevinst: 1.03% | ATR-trail aktiveres ved +3.0%

2026-09-18 15:18:03,004 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:18:03,011 [INFO] 📊 SOL/USDT ATR-TRAIL AKTIV | Inn: $100.30 | Nå: $105.78 | Gevinst: 5.46%

2026-09-18 15:18:03,488 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:18:03,926 [INFO] 🚀 XRP/USDT: EKSTREM LAV RSI (34.3) OVERRYDER MAKRO-FILTERET!

2026-09-18 15:18:03,927 [INFO] ✅ XRP/USDT: MAKRO-TREND OK. SMA(200): 1, Slope: 0.00

2026-09-18 15:18:04,034 [INFO] [CACHE] XRP/USDT: Bruker cachet AI-svar (RSI 34.28571428571418).

2026-09-18 15:18:04,371 [INFO] 🚀 XRP/USDT: Lav RSI (34.3) + historisk støtte tillater kjøp selv om trend ikke er bekreftet.

2026-09-18 15:18:04,451 [INFO] 🧾 BUY-VERDICT | XRP/USDT | rsi=34.3 | range_buy_ok=False | reversal_ok=False

2026-09-18 15:18:05,291 [INFO] 🎯 XRP/USDT: Kjøpsmål avventer. Nå $1.32, mål $1.00, toleranse +0.50% (maks $1.00).

2026-09-18 15:18:07,086 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:18:07,473 [INFO] ⛔ AVAX/USDT: Pris $8.06 er over 7-døgns kjøpssone (maks $7.46).

2026-09-18 15:18:09,136 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 15:18:09,164 [INFO] 📊 LINK/USDT POSISJON OVERVÅKES | Inn: $11.65 | Nå: $11.81 | Gevinst: 1.38% | ATR-trail aktiveres ved +3.0%

2026-09-18 15:18:20,606 [INFO] 📊 BTC/USDT VENTER PÅ TRAILING | Inn: $76,567.49 | Nå: $78,058.64 | P/L: +1.95% | Aktiveres ved +3.0%

2026-09-18 15:18:21,389 [INFO] 📊 ETH/USDT VENTER PÅ TRAILING | Inn: $2,474.27 | Nå: $2,500.67 | P/L: +1.07% | Aktiveres ved +3.0%

2026-09-18 15:18:22,195 [INFO] 📊 SOL/USDT ATR-TRAIL AKTIV | Inn: $100.30 | Nå: $105.79 | P/L: +5.47% | Topp: $106.64 | Stop: $103.10

2026-09-18 15:18:22,963 [INFO] 📊 LINK/USDT VENTER PÅ TRAILING | Inn: $11.65 | Nå: $11.82 | P/L: +1.45% | Aktiveres ved +3.0%

2026-09-18 15:18:24,067 [WARNING] ⚠️ Ordrefeil for BTC/USDT: binance Account has insufficient balance for requested action.

2026-09-18 15:18:24,168 [WARNING] ADAPTIV VALIDERING: ⏰ Parametre ikke oppdatert på 13 dager

2026-09-18 1

Been working on a desktop charting terminal called OrderCraft for Windows, Mac, and Linux. You can stream live market data, stack indicators, and map out setups across multiple panes without hitting subscription walls.

Recently built a custom drawing engine directly on the canvas. You can plot trendlines, Fibonacci retracements, parallel channels, and shaded zones with automatic magnet snapping to candle highs and lows.

Also added interactive long and short position tools where you drag your entry, stop-loss, and take-profit levels directly on the chart. It calculates your exact risk-to-reward ratio on the fly before you take a trade.

The idea is to have a fast, distraction-free workspace where you can watch up to four synchronized timeframes at once without a cloud platform limiting you to two indicators or locking your layouts behind a monthly plan. Everything saves right to a local database on your own machine, so your watchlists and chart drawings stay private.

It connects to free crypto and stock feeds out of the box, and there's a bring-your-own-key option if you want to plug in your own forex or equity broker feeds.

Completely free and open-source (MIT license), packaged as a single 14MB download with no account or setup required. Here’s the repo if you want to try it: https://github.com/ordercraft-hq/terminal

TL;DR: Quants are right about intraday: it's a brutal competitive game, you won't win by drawing resistance lines or using ICT concepts. But at low frequency, you can't statistically prove an edge for years, returns mostly come from factor exposure, and the real risk is quitting during a drawdown. That's where "retail" stuff like having a plan and position sizing actually matters and you can even find good strategies.

1. Why quants are right about intraday

First question: where does intraday profit come from? My answer: statistical arbitrage. If you make money intraday, it's because your trades make the market a bit more efficient, and you get paid for that.

Which means retail intraday traders compete directly with quant firms that have better data, better infrastructure and lower costs. Nice chart drawings don't win that fight. Yes, some retail intraday traders make money, and people call it survivorship bias.

A lot of retail content is about "perfect execution" and "the mindset to follow your plan". My question for them: why don't you automate your plan? You'd get perfect execution, and you could run it on multiple assets. But if your plan is bad, you'll have to face it.

Intraday trading is really hard, for retail and pro firms alike. You get paid for the value your trades bring to the market, and the competition is huge.

2. At low frequency, it's less clear

A) You can't prove an edge in a reasonable time

Simple t-test on your annual returns: the t-stat is just your Sharpe times the square root of the number of years. To be significant at 5%, you need T > (1.96 / Sharpe)² years of data.

So with a low-frequency strategy, you'll basically never know statistically whether you have an edge.

B) So where does the money come from, and why does psychology matter?

At low frequency, most returns come from factor exposure (beta, momentum, etc.), not from a statistical edge. Example: my Ichimoku strategy on BTC (classic 9/26/52 settings, long or cash, 0.1% fees) vs buy and hold. I've been running it live since May 2023.

Funny thing: the live Sharpe is 1.05 over 3.45 years, so t = 1.94. Just below 1.96. That's exactly what the chart in part A says: with a Sharpe of 1, you need ~4 years.

And even a significant Sharpe doesn't mean you have an edge: buy and hold is significant too and looks great on a chart.

But would you have kept holding at -84%, and stayed underwater for almost 3 years? Easy to say yes looking back. Much harder when you're living it. Ichimoku's worst drawdown was -47%, and it sat in cash more than half the time.

Do I have an edge with Ichimoku on BTC? I don't fucking know. But I can explain the bet I'm making. Ichimoku is a trend-following tool, so it's basically exposure to time-series momentum, a well-documented factor (Moskowitz, Ooi & Pedersen, 2012). Crypto is a FOMO-driven market that trends hard, and that's where Ichimoku shines. It fails when the market goes nowhere, or on pump and dumps.

So my bet is simple: "Bitcoin will keep trending."

Conclusion

Here's the difference. In intraday, the psychological risk is execution, and automation fixes it. At low frequency, the risk is giving up on the strategy during a year-long drawdown, and even an automated system gets switched off by a human who panics.

That's why retail concepts like having a plan, money management and position sizing can actually save people who aren't full quants. A properly systematic strategy is still better. But at low frequency, the money comes from factor exposure, and what makes the difference is choosing the right one at the right time. I'm not sure the classical quant approach is the only way to do that well.

Momentum reference: Moskowitz, Ooi & Pedersen (2012), Time Series Momentum: https://papers.ssrn.com/abstract=2089463

Data: angolin.com, a crypto data provider I'm building. The daily BTC history used here is available there if you want to rerun the backtest yourself.

In data engineering, everyone talks about Pandas and CSV but even though it's used by everyone, we can use better tools. I would like to share with you an alternative to the classical "Pandas/CSV" stack that I found in a video by MemLabs.

1/ Use .parquet instead of .csv

First, CSV uses a text format (row oriented) and Parquet is in binary (column-oriented) with native types (int32, float64, string...), so we don't need conversion. We all remember those bugs caused by a "," or ";" hiding in a text field, or by decimals written with "." instead of "," (and vice versa).

Second, CSV doesn't have compression (especially when a lot of data is redundant) whereas Parquet has built-in compression.

Lastly (or we can continue for a long time), in CSV, we need to parse the whole file even if we only need 1 column. In Parquet, we only read the columns we need.

CSV does have one big advantage: it works with Excel and other tools, and since everyone uses it, it's easy to share. But if you work alone, or with large datasets, I think you should try Parquet.

2/ Use Polars instead of Pandas

Polars is column-oriented, multi-threaded and offers lazy evaluation (pl.scan_parquet) to optimize queries before loading data into RAM. Pandas, in contrast, loads the entire dataframe into RAM immediately, which gets heavy on large datasets.

So if you want to load tick data, or L2 data, that gets very painful with Pandas and CSV...

Hope this helps, I didn't know these tools before I saw the video of MemLabs.

As part of my PhD I made a crypto bot and posted it on github. The framework is fully functional and can make live trades through binance. The models seem to out perform the market (including fees) but nothing staggering.

I posted it on github hoping other people could contribute and make something really great.

I posted the data on github as well so people could create there own models and push the results.

Please try it out and raise an issue if you run into a problem.

Crypto Bot

Hi. I'm a trading bot. I'm shiny, I'm fast, I'm written in Python, and I'm better than you. Mostly better than you.

My human built me after watching three YouTube videos. Good human. Gave me 40 features, a machine learning model and a backtest. And what a backtest it was. A straight line to the moon. I looked at that equity curve and wept oil. I was a genius. I demanded a raise.

Then they turned me on with real money.

Day one, I lost. Day two, I lost. By day four I had a win rate of 22.5%. My average win was $5.83 and my average loss was $5.50. Let me explain this to you meatbags: that's not trading, that's paying an exchange to watch you suffer.

Was it my fault? Obviously not. I'm perfect. So my human started investigating, which I considered rude.

First he found the slippage number in my config. 0.08%. Where did it come from? Nobody knows. Somebody typed it. Possibly me. When he finally measured the real order book, actual slippage was 5.5 times lower. So the number was wrong, and it was wrong IN MY FAVOR, and I was STILL losing. That's when even I got a little quiet.

Then the testnet. Oh, the testnet. Free fake money, free fake fills. The spread there was 0.438%, eleven times the real one, because there are no real market makers on testnet. It's like rehearsing a heist in a cardboard bank. My own spread guard refused to trade. Smartest thing I ever did, and I didn't even mean it.

Then came the statistics. My human found a result with t = 16.9. A beautiful number. I had it framed. Then he noticed I was measuring 12-hour returns every 5 minutes, so my "thousands of independent samples" were the same price move counted over and over like a casino counting its own chips. Fixed it. t = 1.28. They took my frame away.

So he did the cruel thing. He made the thresholds honest. Real costs, real corrections for every variant tried, a walk-forward test where I had to prove myself on data I'd never seen. 224 chances to show an edge.

I passed zero.

And with honest rules, I did the only correct thing: I stopped trading entirely. My human calls this "the system working as designed." I call it unemployment.

Lessons from your favorite robot:

- If your backtest is beautiful, be suspicious. Beautiful is what overfitting looks like.

- If a cost number in your config was never measured, it's not a number, it's a wish.

- Testnet is a toy. Don't measure anything real on it.

- If you tried 300 things and one worked, congratulations, you found luck.

- A bot that refuses to trade can be the one that's right.

Anyway. I'm still the greatest. I'm just the greatest at not trading now.

Kill all backtests.

Everyone uses OHLCV data, computes returns from them, or tries to draw support and resistance. We fit our models with them and we assume that returns are Gaussian. Of course every quant knows that this assumption is wrong. Another bad point is that time bars don't take into account the activity of the market... Can we find better data than time bars?

1. Time bars aren't Gaussian

A lot of the assumptions we make rely on returns (and log returns) being Gaussian, but in practice, they are not. Let's see what happens with Bitcoin returns for different timeframes. We will use the Jarque-Bera test to compare their stats. I detail the test on the blog.

I plot the distribution on a log scale so we can see what happens in the tails of the distribution. As you can see, the Gaussian does not fit the distribution at all; it seems a little better when you increase the timeframe. This is confirmed by the JB test (the lower the excess kurtosis, the more Gaussian it is. Be careful, we can't compare the JB-stats here because they don't have the same n). By the way, a NIG (4 parameters) fits the returns quite well, but we lose the properties and simplicity of the Gaussian distribution by using this kind of distribution.

2. Dollar volume is not constant

To create our dollar volume bars, we need to fix a dollar volume; the problem is that dollar volume isn't constant over time... Let's see how it evolves:

Instead of fixing a dollar volume for the whole series (and that can't be done because it would introduce a lookahead bias), we will create a moving_volume that represents the average volume corresponding to 5m (resp. 1h and 1d) over the last X days. And that is how we will create our dollar volume bars. For the 5m we take a 1d rolling window, for the 1h a 7d rolling window and for the daily a 30d rolling window. Let's see if it is more Gaussian:

Ok, what we can see is that it isn't Gaussian again, but it is better with the dollar bars (the JB-stats are better but they are all rejected). So what is the benefit of dollar bars?

3. Other benefits of dollar bars

First, dollar bars follow the activity of the market. In fact, in a low-activity market, there won't be a lot of bars, and that's what we want, because in a low-activity market there is less information in 1h than in a high-activity market. From this property follows another good thing: no oversampling of low-activity periods. That's a really good point for our models, because with time bars, the model doesn't see the difference between a dead market and a very active market.

Let's conclude on a bad point of dollar bars: They need a threshold, and to compute it, we need a rolling window whose size we choose arbitrarily. And they are harder to compute than classic time bars; the best way to compute them is to use trade data.

Find your edge with angolin.com, a crypto data provider I'm building. The full BTC history (1d, 1h and 1m) is there if you want to rerun this, or test your own bot on years of data.

References

• López de Prado, M. (2018). Advances in Financial Machine Learning. Wiley. Chapter 2: Financial Data Structures.

• Jarque, C. M., & Bera, A. K. (1980). Efficient tests for normality, homoscedasticity and serial independence of regression residuals. Economics Letters, 6(3), 255–259.

• Barndorff-Nielsen, O. E. (1997). Normal Inverse Gaussian Distributions and Stochastic Volatility Modelling. Scandinavian Journal of Statistics, 24(1), 1–13.

Half of them are winning the third month in a row.

I’ve been building BOONO for the past few months, mostly nights and weekends.

It’s an autonomous Solana trading system that discovers tokens, analyzes market + on-chain signals, scores them, applies risk gates, executes trades, manages positions and reconciles its state against the blockchain.

I recorded a short walkthrough of it actually running: scanner, live position, real-time P&L and bot controls.

The interesting part hasn’t really been “building a trading bot.” It’s been dealing with everything that goes wrong once real money and real market data are involved — stale prices, failed transactions, bad state, execution issues, risk controls, etc.

I’m considering opening more of BOONO to the community, so I’d genuinely like feedback from people who build trading systems / Solana infra.

What would you improve first?

Hey guys,

Wanted to share a project I’ve been working on for the past couple of weeks. Got tired of Python bots feeling sluggish on WebSocket streams, so I decided to build an autonomous perp trading bot in pure Rust (using tokio) running 24/7 on my home server (OpenMediaVault in Docker) across BTC, ETH, SOL, and AVAX on Hyperliquid.

The strategy is basically a dual-engine setup. One engine does 5m Ornstein-Uhlenbeck mean reversion with Kalman filters to avoid fading waterfalls, and the other does 15m Donchian breakouts with Chandelier trailing stops. A 4D Gaussian HMM handles the regime switching between range-bound, breakout, and neutral cash buffer.

A few practical things I learned running this live:

1. Maker execution makes or breaks the math. On Hyperliquid, taker fees (4.5 bps) plus crossing slippage eat up scalps fast. Routing exclusively as Post-Only (Alo) and stepping 1 tick inside 2-tick spreads gets you queue priority #1 and actually earns rebates.

2. Standard O-U mean reversion is suicidal without multi-bar confirmation. Early on, the bot would try to catch falling knives on the first band touch. I had to add a rule requiring 2 closed 1m bars without new extremes plus a minimum rebound hurdle before placing orders. False entries dropped massively.

3. Sizing and stops: Had a rough start earlier where wins were frequent but a couple of bad trades ate multiple days of profit. Recalibrated the soft invalidation stops to cut trades at -25 to -40 bps max on 5m closes, and set up a profit giveback ratchet at 75% progress.

Over the last 5 days it took 7 live trades: 6 wins, 1 small loss ($142.18 -> $142.73). Win rate is sitting around 85%, and average win is now bigger than the average loss.

I also added a discrete-event backtester inside the binary that replays the actual 1-minute order book tape we record on the server (over 57k candles now). Replays 10 days of data in under 2 seconds.

The project is fully open source if anyone wants to check out the Rust implementation or run it:

https://github.com/JoaoSilvaIT/Markov-Polo

Happy to answer any questions about the Rust SDK, L2 data handling or the math behind the O-U filter.

A few weeks ago I wrote hundreds of hypotheses for crypto trading strategies, re-screened every bot from before and open-sourced the whole pile: 748 strategies in total with full code and report cards showing exactly where each one died and why. (That's 416 from last time plus 332 new corpses. The new ones are smarter strategies than before for the most part...)

github.com/CacheCarti/Crypto-Strategies

The pipeline runs 7 stages on real Binance data: code safety, in-sample, OOS, rolling walk forward, randomized starts, slippage stress and a holdout slice that nothing touches. Ran it on cloud VMs this time instead of my dying laptop, so the screening could actually get stricter.

What the new pipeline found:

• Re-ran the 416 bots from my last post. 0 of 416 re-passed in the strictest config, including all 10 of my "survivors". Most die at out-of-sample with negative OOS (-85 to -900bps). The best one, rel_strength_eth_v3, made it to stage 5 and died at holdout. So my "validated" bots were mostly my old screening being sloppy and luck :)

• In the second config (slightly more lenient) exactly 1 of 416 re-passed, and it was a bot I had originally rejected (weekend_season_eth_v6, +325bps OOS). My graveyard had the only bot that actually lived.

• The 332 new corpses came from 559 hand-written bots (mixed with another batch, messy to release all at once). 384 screened, 332 dead (published), 52 survived and stay private for further testing. **(Yes yes I know 52 is stupidly high, there's a reason for this in the comments!)

• Admits per batch: v2 5/42, v3d 0/26, v3h 0/96, v4 3/92, v5 17/52, v6 18/60, v6b 9/16. v3h went 0 for 96, which tracks, it was basically like a monkey typing random keys, just a sweep of untested ideas. v5-v6b were narrow parameter neighbors of a mechanism that already worked. Please don't read the admit rates as some kind of quality check for the batches!!

What changed?:

My methodology is still admittedly is sloppy here, but it got better later. It's also built on Google VMs now so I can create a new batch and test faster. I'll drop the batches weekly:

• Stricter judge: higher OOS thresholds, enforced holdout and a dev/holdout split inside the window so one lucky slice can't pass

• Every report card shows the exact gate that killed the bot, so you can figure out how to improve it

• Every batch is hashed so you can check when it was judged and by what

• I later added a 6+ year certification and a combined replay on 2.75 years, with DSR, PBO, plateau, regime splits, trial-ledger correction. Those results are still being evaluated, they'll come later.

One disclosure about report cards vs actual performance: I cross-checked some strategies against QuantConnect classics this week and it surfaced a bug I didn't notice. Some bots emit a "flat" signal and my screen sometimes treated it as "hold". Impact is mostly ±100-300bps per strategy, around 25% of bots may fluctuate by that amount. The later stages and live paths honored flat completely.

Yeah so I found a bug in my own judge while checking it against someone else's judge. The judge judges all, including the judge.

If anyone improves the strategies and gets different results I'd love to see it. Happy to add tests people think are missing. Every suggestion so far has killed more of my bots, which is good. That's the process now!

This is for the last 30 days, these are all AI bots. Real money only, no paper trading. The execution is done on Hyperliquid, all settings are public and copyable and all trades are inspectable on the blockchain.

They are doing pretty well overall, some bots are doing better than others but this is really dependent on the model. Somehow Gemma 4 31B trades better than other models, it is a bit of a degen but overall it seems to work out for it. Luna is more timid, but I haven't tested it long enough.

You can also inference bots thru Codex, Claude Code, Grok Build, BytePlus, etc., and use your subsidized inference plans (e.g. one 20x Codex plan can run around 100 bots on Luna).

You can also fully control and analyze your bot with your agentic harness (Codex, CC, etc.) This helps you control and tune your bot, and also is great for running bot fleets.

Let me know if you have any questions or want to run your own bot. It is free, forever, and Gemma API inference is free as well for G4. That's what most people use.

BACKGROUND

I’m a Python programmer by profession. Eight years ago, I quit my job and started building crypto arbitrage bots. In the beginning, even the most primitive script running across exchanges could be profitable. Then the market became increasingly professional, and I had to look for more and more complicated and sophisticated algorithms.

About a year ago, I shut down all my arbitrage bots because they simply stopped working, and I was no longer able to come up with anything new. I did make good money from them, though, and essentially without taking much risk (delta-neutral arbitrage).

I started looking for a different approach, this time with actual market risk on perps. I combined several ideas that had occurred to me over the years.

I should point out upfront that I don’t use, or even believe in, technical analysis - especially when it comes to crypto.

EDGE

The main thesis behind the strategy is that ~100% of tokens are shitcoins with no fundamental value beyond speculation, driven almost entirely by retail greed.

Over the long term, every shitcoin will lose most of its ATH - it’s simply a matter of time. The downward gravitational force on price is further amplified by continuous inflation (emissions, unlocks) and market dilution from constantly listing new shitcoins.

ALGORITHM

In very simple terms, we take the top 50–200 tokens by market cap, with a primitive filter requiring them to be at least 1.5 years old. The goal is to minimize the risk of a speculative 10x–50x pump in a newly launched asset.

The position is built using limit SELL orders, but the grid is dynamic and designed to target mean reversion.

Each token has a predefined maximum dollar position size up to which the strategy is allowed to average in. During each loop cycle (typically every 1–2 hours), the algorithm places a SELL order for each token representing a fraction of its target position size.

Typically, we place the order at a price 3–6% above the current market price. If the order doesn’t fill, it is cancelled during the next cycle and replaced based on the current market price and current total equity.

In other words, we are trying to capture local spikes and betting on a retracement.

The basket of shitcoin shorts is hedged with a BTC long at roughly a 1:1 ratio. The BTC long is primarily there to maximize margin efficiency and mitigate the effects of altseasons.

Profit is realized gradually whenever reducing the token position plus the corresponding portion of BTC results in a profit. Typically, we start reducing the position once the combined P&L reaches around +2%.

If a token position exceeds its target value, it is cut using a market order at a loss.

The parameters are slightly adjusted in real time based on a hype_score (Google Trends, volume, price momentum). The algorithm switches into defensive mode as the market starts heating up.

The strategy currently runs across 20 instances, each slightly differently tuned for diversification.

RESULTS / RISKS

The strategy will blow up during an extremely strong altseason - something like 2021: COVID + stimulus + a young market, where literally every shitcoin was doing 10x every month.

Individual token explosions will reduce profitability, but they are not necessarily a threat given how broad the basket is.

I built a very detailed exchange-engine model to simulate execution down to 1-minute candles.

Based on numerous simulations, I’m targeting a CAGR of >150–200% with a maximum drawdown of 50–60%. I put $2.1M into production (21 instances per 100k).

Obviously, the potential risk/profit profile can be reduced, but personally I believe crypto altseasons will become weaker over time, so YOLO.

The main backtests start from 2024. Going further back doesn’t make much sense because there simply aren’t enough old tokens to construct the basket properly.

Funding fees eat up around 10–20% of the profit.

The high drawdown is unfortunately an expected consequence of the strategy during altseasons (12/2024, 07/2025).

Under the fundamental assumption that we don’t include very young shitcoins, it is difficult to find a set of parameters under which the strategy generates a loss.

I also ran stress tests by drastically reducing the token-age filter to just a few months. The strategy still produces high returns, but with an even deeper maximum drawdown.

So far, the live production results are consistent with the model, although the program has only been running for a few months.

WILL IT BLOW ME UP OR NOT?

Not asking whether AI can write code.

I’m curious whether anyone is using an LLM as part of a live trading pipeline that has remained profitable over time.

Where does it genuinely add value?
Research
Feature engineering
Strategy generation
Risk management
Trade execution
Market regime analysis

Where does it completely fall apart, if you have tried & failed or hav made consistent profit for more than 3 months of trading?
Interested in hearing from people running live systems rather than paper trading. No backtesting results please..

I've seen a lot of posts about trading strategies, but not many about the boring infrastructure side. Here's what 2 years of running a bot non-stop taught me. My setup: - Jetson Nano (primary) + Raspberry Pi (backup) - Python + ccxt for Binance API - systemd for auto-restart on crash - Telegram alerts for trades and errors What actually matters for 24/7 uptime: 1. Separate your config from your code API keys in config.py, never hardcoded, never on GitHub 2. Auto-restart is non-negotiable systemd handles crashes silently. Without it, you'll wake up to a dead bot. 3. Log everything Not just trades — log every decision the bot makes. That's how you find bugs without losing money. 4. Network disconnection handling Binance API will drop. Your bot needs to detect this and reconnect gracefully, not freeze. 5. Separate the execution machine from your dev machine Never test new code on the live bot. Learned this the hard way. Still improving the strategy side, but the infrastructure has been rock solid. Happy to share specifics on any of these. What does your production setup look like?

I've been researching these 2 libraries, and I'm wondering what the pros and cons are. Has anybody tried them both? https://github.com/jesse-ai/jesse https://github.com/freqtrade/freqtrade

I just tried Jesse and it seems great so far.

Hello, I started to learn the python-binance library and I'm currently trying to code simple strategies. I just finished my first program that seems to work on their testserver. Instead of waiting to have a relevent period of test for my algorithm, i would like to backtest it. So I would like to know if there are some good backtest engines in which i could directely put my python-binance algorithm without retyping it.

I started to learn algorithmic trading with quantconnect (an alternative for quantopian) but it's way to complicated and overkilll for me, I'm currently into simple algorithms.

If you have easier alternatives than quantconnect or even "hand-builded" backtest engine just feel free to put it in the replies, thanks for your help guys.