Module 1: Setting up

Python, a free paper account, real market data and your first chart.

• 1.1

  What you'll build and how the desk works

  The three ideas the whole desk rests on: learn, pass the exam, or sit on the bench.

  8 min
• 1.2

  Python and an editor, the easy way

  Install Python, VS Code and the four libraries the course uses.

  10 min
• 1.3

  Your free Alpaca paper account and API keys, kept safe

  A paper account: real prices, pretend money. Make your keys and connect without putting them in your code.

  8 min
• 1.4

  Getting market data: prices, bars and timeframes

  Download 60 days of hourly bars, keep only finished bars, and save them to a file.

  12 min
• 1.5

  Your first script: read prices, draw a chart

  Twenty lines: load your bars, add a 50-hour average and draw the chart that seeds your first agent.

  10 min

Module 2: Your first agent

A rule-based agent, an honest backtest, stops and sizing, a machine-learning agent and your first paper order.

• 2.1

  What an agent is: your first rule-based agent

  An agent is four decisions: whether to trade, which way, how much and when to get out. Build the simplest one.

  10 min · free
• 2.2

  An honest backtest: costs, no peeking, and a fair comparison

  Replay history bar by bar, pay for every trade, never use a price before it existed, and compare with simply holding.

  course
• 2.3

  Stops, targets and position size

  Size each trade so a stop-out costs 0.5% of the account, and give every trade a stop, a target and a time limit.

  course
• 2.4

  A machine-learning agent, and the first sign of overfitting

  Let a small model learn its own rule from four features, then test it on data it never saw. Compare with a dumb guess.

  course
• 2.5

  Your first paper order

  Run the agent's decision on live bars and send a real order to your paper account, only when something needs to change.

  course

Module 3: The exam

Why one good backtest proves almost nothing, how luck fools you, and how to test an agent the way the desk does.

• 3.1

  Why one good backtest proves almost nothing

  Pick the best settings on one stretch of history, then test them on the stretch after. Watch the result shrink.

  course
• 3.2

  Luck: the more you try, the better the best looks

  On pure noise, the best of 1,000 random rules looks brilliant on training data and earns nothing after.

  course
• 3.3

  Walk-forward testing

  Learn on one window, skip a gap, test on the next, and slide forward. Many small exams instead of one.

  course
• 3.4

  A score and a pass mark

  Turn many windows into one score that rewards consistency, and set a line below which an agent is benched.

  course
• 3.5

  How the desk's exam works

  Three exams, a margin to unseat a champion, validation windows it never saw, and a live reality check.

  course

Module 4: Benching rules

When an agent should stop, how to protect what it holds, and what it takes to come back.

• 4.1

  When to bench an agent, and what it costs

  Re-sit the exam on recent windows only, bench below the line, and see what the bench costs and saves.

  course
• 4.2

  Protecting what a benched agent holds

  The desk's own rule: tighten each stop the moment an agent is benched, and close what's left after four weekdays.

  course
• 4.3

  Coming back off the bench

  A benched agent keeps learning. It returns only when a new version passes a check on data it never learned from.

  course

Module 5: Risk

Sizing by risk instead of by money, hard limits no agent can learn around, and what happens on a bad day.

• 5.1

  Size by risk, not by money

  Put the same money in a calm stock and a wild coin and you risk five times more on one. Size each trade by what it can lose.

  course
• 5.2

  Limits the agents can't touch

  A guard outside the agent that vetoes oversized, overcrowded or badly timed orders, and always lets a position close.

  course
• 5.3

  Bad days, bad weeks and the kill switch

  Three layers that slow, then stop, a losing account, and why a human resets the last one.

  course

Module 6: Running it live on paper

Turn the script into a service that runs every hour, keep an honest record, and publish it.

• 6.1

  From a script to a service

  Wrap the agent in a loop that runs a few minutes after every hour, never decides the same bar twice, and survives errors.

  course
• 6.2

  Keeping a record you can trust

  Pull every filled order and the daily account value straight from the broker, not from your own notes.

  course
• 6.3

  Publishing your record honestly

  Turn the two files into a simple public page, and the rules that make a record worth believing.

  course

Module 7: Building a desk

Several agents working together, how alike they are, and how to split the money between them.

• 7.1

  Why a desk beats a single agent

  Agents that think differently lose at different times. Measure how alike they are, and see what combining them does.

  course
• 7.2

  Splitting the money

  Equal shares, or more to whoever has been doing well lately? Test it the honest way, using only the past.

  course
• 7.3

  Rules between agents

  One account, many agents: no fighting over the same stock, a cap on any one stock, and one set of brakes for everyone.

  course

Module 8: Final project

Build your own agent, put it through the exam, run it on paper and publish its record.

• 8.1

  The brief, and the exam your agent must pass

  One ready-made exam. You change one function: your agent's idea. It must pass walk-forward testing before it trades.

  course
• 8.2

  Improving it without fooling yourself

  Every change you try is another try. Keep a log, test on a second market, and stop when the evidence says stop.

  course
• 8.3

  Run it, publish it, and the certificate

  Thirty days on paper with Module 6's service, a public record, and how you earn the course certificate.

  course

All eight modules are written; the full course, with lesson videos, opens in early 2027. Reserve the founding price.