Back to the galaxy

01 Algorithmic & AI Trading Systems

Bots that trade.Logs that don’t lie.

Fully automated Python trading engines wired to live news feeds, trained on real trading-class material, and journalled to a web dashboard you can open from anywhere. The bot trades. The journal proves it.

24/7
runs in Dockerauto-restart, no babysitting
0
hallucinated ordersreach the broker
100%
of decisions journalledfills, skips & rejections
4
live demoson this page

02 Capabilities

SIX THINGS THAT MAKE THE BOT ACTUALLY WORK.

In production, not in a backtest. Each part is built to survive real markets, bad data and a model that occasionally makes things up.

01

Fully Automated Python Engine

The trading core is pure Python — connects to your broker API, runs the strategy loop, executes orders, handles retries and reconnects. Runs 24/7 in a Docker container with auto-restart, no babysitting required.

Python 3.12asyncioBroker SDKDocker
02

Live News API Integration

Pulls real-time market headlines and macro events from sources like Polygon, Alpha Vantage, NewsAPI, and Benzinga. Sentiment is scored and fused with price action so the bot trades on what's actually happening, not yesterday's chart.

PolygonNewsAPIBenzingaSentiment
03

Trading-Class & Mind Materials

Your course notes, mentor playbooks, and the psychology behind disciplined trading are ingested as the bot's knowledge base. The model learns rules it can quote — entries, exits, risk caps, position sizing — not just patterns it guessed at.

RAGVector DBRule Encoding
04

Web-Based Trade Journal

Every move — entries, exits, the news the bot saw, the reasoning it gave — is written to a clean web dashboard. Open it on any device. Search, filter, replay. No CSVs, no terminal logs. Your performance history, readable.

PostgresRealtime UIExport
05

Self-Improving Learning Phase

A nightly review loop replays the day's trades, scores what worked and what didn't, and adjusts confidence weights for setups, time-of-day, and news categories. The bot gets sharper at reading your market, not a generic one.

Bayesian UpdateWalk-ForwardAuto-Tune
06

LLM RAG or ML Backbone

Two brains, your call. Hosted LLM (Claude / GPT) with a RAG layer that reasons in natural language and trades like a disciplined human, or a classical ML model (gradient boosted trees, LSTM) for pure-signal latency-sensitive setups. Either way, the Python execute engine has final say.

Claude APIGPT APIXGBoostLSTM

03 Live demos Simulated market

WATCH IT TRADE.

Same logic, simulated money. A real strategy loop, a real safety layer and a real journal — running on a simulated market in your browser. Nothing here is financial advice.

Demo A · Paper trading

A strategy loop you can steer.

The price ticks, headlines arrive with a sentiment score, and the bot decides: enter, skip or wait. Every trade is sized to your risk, protected by a stop, and written to the journal below.

  • Breakout + news or mean-reversion strategy
  • Risk per trade, confidence gate and a daily loss cap
  • Inject a headline and watch the bot react

Simulated prices · demo only · not financial advice

paper account · NVDA (simulated) · 1mBot online
Equity$100,000
P&L$0
Win rate—
Trades0
Positionflat

        

Demo B · Zero hallucinations

The LLM suggests. The Python engine decides.

LLMs hallucinate. They can invent ticker symbols, miscount lots, or talk themselves into oversized positions. That's fine — because the LLM never touches your broker. Pick a proposal, or edit the JSON yourself, and run it through the engine.

  • Hard position-size and daily-loss caps enforced in code, not prompts
  • Ticker whitelist + market-hours check before every order
  • Structured JSON output from the LLM — anything malformed is rejected
  • Two-tier confirmation: the model's confidence is also a gate
  • Every rejection is logged to the journal with the reason
execute_trade.py — the safety layerArmed
LLM proposal (JSON)

          

    Demo C · Risk lab

    Size the trade. Stress the strategy.

    Position size comes from your risk, not your mood. Then the same edge is played out 40 times over 100 trades — so you can see the drawdowns before your account does.

    • Position sizing from account, risk %, entry and stop
    • Monte Carlo equity paths with median, worst case and drawdown
    • The same maths the bot uses before every order
    risk lab · position size + monte carloLive
    100 trades per path · simulated

    04 Architecture

    HOW THE DATA BECOMES A TRADE.

    Scroll through the pipeline. Red packets are hallucinated proposals — watch the safety gate stop them.

    1. 01
      Market + News

      Price ticks from the broker, headlines from news APIs, macro calendar events. Normalised into a unified stream with timestamps, source, and confidence.

      polygon.io · alpha_vantage
    2. 02
      LLM + RAG Brain

      Retrieves relevant rules from your trading class & mindset notes. Reads the news, scores the setup, proposes an action with a written rationale and confidence.

      claude · gpt · vector_db
    3. 03
      Python Safety Engine

      Validates the trade against hard rules — position size, risk caps, market hours, instrument whitelist. Rejects or trims anything the LLM hallucinated.

      execute_trade.py
    4. 04
      Journal & Learn

      Order writes to the broker. Every detail — inputs, reasoning, fill, P&L — writes to Postgres. The web journal updates live. The nightly loop reviews.

      postgres · web_journal

    05 Web Journal

    EVERY MOVE, LOGGED.

    The bot writes a structured entry for every action it considers — not just fills. Skipped setups, rejected hallucinations, take-profits, partial closes. Trades from the simulator above appear here live.

    journal.riddleholding.com — liveBot online

    06 Pick Your Brain

    LLM WITH RAG, OR A TIGHTER ML MODEL.

    Option A · The Reasoning Trader

    API-Based LLM + RAG

    A hosted Claude or GPT model with a retrieval layer over your trading class, mentor notes, and historical journal. It reads the news, recalls the rule, writes the rationale, proposes the trade.

    • Trades like a disciplined human
    • Explains its reasoning in plain English
    • Easy to coach with new written material
    • Hallucinations are caught by the Python engine
    • Latency: ~1–3 seconds per decision

    Best for: swing trades, news-driven setups, daily review

    Option B · The Signal Engine

    Pure ML Model

    Classical machine learning — gradient boosted trees, LSTM, or a custom ensemble — trained on your historical signals and labels. No language, no narration. Pattern in, probability out.

    • Sub-millisecond inference
    • Deterministic and back-testable
    • Self-hosted, no LLM API costs
    • Easier to certify for regulated use
    • No prose explanations — pure numbers

    Best for: intraday, scalping, latency-sensitive plays

    // You can also run both — LLM for daily macro, ML for intraday execution. I've shipped that hybrid before.

    07 Build Process

    HOW I SHIP A TRADING BOT.

    1. 01Strategy Capture

      I sit with you, your class notes, and your existing playbook. Every rule becomes a testable spec.

    2. 02Data & Backtest

      Historical price + news data assembled. Strategy back-tested across multiple regimes before any live capital.

    3. 03Paper Trading

      Bot runs live but trades a simulated account for 2–4 weeks. Journal proves it follows the rules under real conditions.

    4. 04Live Deploy

      Capital allocated in stages. Safety caps tight at first, widened as the journal shows consistent behaviour.

    5. 05Learn & Iterate

      Nightly review loop tunes confidence weights. Monthly model retraining. New class material rolls in as RAG context.

    08 Contact Open to full-stack roles · Dresden / remote

    Let’s build something
    people don’t log off from.

    Daanriddle@gmail.com