TradingHub is a self-hosted platform that runs 8 Freqtrade bots plus a handful of Django-native algo bots on Binance, all in dry-run mode, coordinated by what I call an AI control plane. The problem I wanted to solve wasn't "make money" — it was "can I orchestrate dozens of trading signals, ML models, and LLM opinions into one auditable decision pipeline without ever risking real capital?" So everything you read here is paper-trading. No real money has touched this system, and nothing in this article is financial advice.
That constraint shaped every design choice. Paper-trading means I can be reckless with experiments and rigorous with the plumbing, which is exactly the trade-off a solo builder wants when learning a domain as unforgiving as algorithmic trading.
The shape of the system
At the bottom are the bots. Eight Freqtrade instances run in dry-run on Binance, and alongside them sit Django-native bots implementing the usual suspects: DCA, grid, trend-following, and an RSI strategy. Each produces signals. None of them act on their own.
Above the bots is the Alpha Engine, the orchestrator that decides whether anything actually happens. It takes weighted signals from every source and runs a consensus calculation, then pushes the result through 6 safety gates and an 11-check risk engine before any (simulated) order is allowed. The gates and checks are the boring, load-bearing part of the whole project. A signal can be confident, popular across bots, and still get rejected because position sizing, drawdown, or correlation rules say no. That layering — generate freely, approve conservatively — is the core idea.
The LLM layers
This is the part I had the most fun with, and the part I trust the least, which is a healthy combination.
On top of the numeric stack I bolted several LLM layers, all running through Gemini via OpenRouter. The first is a straightforward analysis agent with access to 19 tools — it can pull market data, read bot state, and reason about conditions. The second is the one people ask about: an 8-agent bull/bear debate. Half the agents argue the case for a position, half argue against, and the disagreement itself becomes signal. A position the bulls and bears both hate is easy to skip.
There's also a 5-member investor-persona panel — agents prompted to reason like Buffett, Burry, Wood, Dalio, and Simons — that emits its own weighted opinions, and a "genome evolution" loop that mutates strategy parameters over time. I want to be honest about what this is: it's an experiment in whether structured LLM disagreement produces better-calibrated inputs than a single model's confident take. I don't have verified performance numbers to claim it works. What I can say is that the debate format surfaces reasoning I'd otherwise miss, and because it's all paper-trading, a bad LLM call costs nothing but compute.
CPU-first ML, on purpose
The ML signal stack is deliberately CPU-friendly. GARCH (via the arch library) handles volatility modelling, XGBoost does the gradient-boosted predictions, FinBERT runs sentiment over news and social text, and an Isolation Forest watches for anomalies and liquidation events. Every one of these runs comfortably without a GPU.
That was a constraint, not an accident. I wanted the whole thing to deploy on a cheap, GPU-less VPS, so I avoided architectures that demand accelerators. The honest caveat: there are two more models in the codebase — a Temporal Fusion Transformer and a reinforcement-learning agent (stable-baselines3 + gymnasium) — that are not trained yet. The scaffolding is there; the weights are not. So when I say "ML stack," picture a working CPU-first core with two aspirational slots still empty.
The control plane
What makes it a platform rather than a script is the orchestration. Over 60 Celery Beat scheduled tasks keep the system moving: fetching data, running models, refreshing debates, recalculating risk. An ErrorLog plus self-healing logic catches and retries failures, and Telegram alerts ping me when something needs a human. There's also an autoresearch loop fed by 242 markdown strategy specs — research notes that an evolution process reads, tests, and iterates on, with a Claude-vs-Codex "arena" comparing approaches. It leans heavily on the same AI-assisted workflow I use across all my projects.
The frontend is a React/shadcn dashboard — 34 pages — with WebSocket live updates for monitoring, performance, the debates, and a Polymarket prediction-market integration. It's a single-user, self-hosted tool, not a multi-tenant product.
The stack
- Backend: Python 3.12, Django 5.1 + DRF + Channels, Celery + django-celery-beat.
- ML: scikit-learn, statsmodels,
arch(GARCH), XGBoost, LightGBM,transformers(FinBERT), stable-baselines3 + gymnasium (RL, untrained). - Frontend: React 18 + Vite + TypeScript + Tailwind + shadcn/ui + TanStack Query + lightweight-charts.
- Infra: PostgreSQL 16, Redis, Nginx, Docker Compose (16 containers), GitHub Actions CI.
- APIs: Freqtrade, OpenRouter (Gemini), Polymarket, web3, optional Interactive Brokers.
A lesson learned on secrets
One thing worth flagging honestly: during a review I found that a README had at some point exposed an admin credential. I won't reproduce it here, and the takeaway is the obvious one — documentation is code, and a credential pasted into a setup guide is a leaked credential. If you build self-hosted tooling, scan your docs the same way you scan your source. It's an easy mistake to make when you're moving fast solo, and an easy one to prevent with a pre-commit secret scanner.
Where it's at, and what's next
TradingHub is an MVP. It's live-deployed in the sense that it runs continuously in paper mode, with a production Docker Compose, certbot and backup tooling, and CI — but "live" here never means real orders. The system-state docs are dated to early 2026, and I keep them current because the orchestration is complex enough that I'd lose track otherwise.
What I can verify: the architecture, the stack, the gate/risk layering, and the CPU-first ML core. What I can't verify and won't claim: real trading performance, PnL, or how much of the LLM and untrained-ML functionality is genuinely operational versus aspirational. The TFT and RL models are the obvious next step — training them is the difference between a clever pipeline and a complete one.
If there's a thread running through this project, it's the AI-assisted build process itself. I wrote about that approach in how I ship 11 products solo with an AI-assisted dev workflow, and TradingHub is one of the 11 products I'm building as a solo founder. If you want to see the rest of what I'm working on, take a look at my projects.
One last time, because it matters: this is a paper-trading sandbox. Nothing here is financial advice.