A trading system that runs itself.

Buzz watches the markets around the clock, decides when to get in and out, and places every order on its own. Nobody sits at a screen.

Eight separate strategies run at the same time across two accounts, and everything they want to do has to pass a risk layer that can overrule them.

It took years of nights and weekends, and most of what I built got deleted along the way.

Two accounts, two rulebooks.

The two accounts do different jobs, and a strategy automatically picks up the rules of whichever one it runs on.

• One takes same-day and event trades
• The other holds positions for days at a time
• Trading-hour limits apply to one and not the other
• Weekend and news handling differs on purpose
• No rule is ever set per strategy by hand

Eight strategies, one catalogue.

Each strategy is a self-contained method with its own entry, exit and risk settings. They deliberately cover different markets so they don't all win or lose together.

• Stock indices, metals, currencies and crypto
• Opening-range, trend, carry and breakout methods
• The live list is generated from the catalogue, never typed by hand
• If one is running but missing from that list, it shows up as a fault

It watches, and it waits.

Before a session opens it marks the levels that matter. Then it watches — all session, without a break — and does nothing at all until price actually reaches one of them.

• Draws the session's key levels before the bell
• Watches without pause — no fixed check-in times to miss a move
• Waits for a level to actually be taken instead of guessing early
• Sizes each trade off how far away the exit sits, not a fixed number
• Works on the broker's clock, never the computer's
• What it reads the market on is kept apart from where it trades

Nothing trades unless it's on the list.

Every account keeps an explicit list of which strategies are allowed to open a position. Anything not on it gets refused by name — including a strategy added later, which is exactly when a permissive default would do damage.

• It can stop a position being opened, but never stops one being closed
• Exposure is counted net, so a hedge isn't punished twice
• The same market can't be entered twice at once
• Each strategy is capped on how many positions it may hold

It shrinks itself when it's losing.

As losses deepen, the system cuts its own position sizes in stages, and eventually stops opening anything at all until things recover.

• First threshold — position sizes are cut
• Second — cut much further
• Third — it stops opening new trades entirely
• Measured against the algorithms' own results, not the account balance
• If that baseline turns out to be wrong, it resets itself

It knows when not to trade.

Some of the worst outcomes come from trading at the wrong moment rather than picking the wrong direction. These rules cover the moments.

• Closes out ahead of scheduled economic news
• Refuses to trade a market that isn't properly open
• Weekend handling changes with the account's stage
• Widens stop distances when volatility spikes
• Anything traded by hand is left completely alone

It places the order, then tidies up after itself.

Sending the order is the easy half. Most of the work happens afterwards — getting protection attached, chasing what actually filled, and clearing away everything that didn't.

• Rests a limit or stop order at the level rather than chasing price
• Attaches the protective stop the instant it fills — then checks it's really there
• Cancels orders left sitting unfilled past their window
• Sweeps every three minutes for late fills and anything that drifted
• Closes trades that have outstayed their time instead of letting them run on
• Clears out leftovers — half-filled, orphaned or duplicated
• Trusts the broker's own record of a position, never the "ok" it replied with

Running isn't the same as working.

A program can be running and still be doing nothing useful. This layer checks each part is genuinely alive by looking at whether it's still producing fresh output.

That rule exists because a monitor once compared the wrong account's data and blocked a restart hundreds of times across fifteen hours without raising an alarm.

• Health is judged on recent activity, not on whether a process exists
• Data files are checked as belonging to the right account before use
• Watchdogs flag stale prices and stalled connections
• Audit tools are read-only, so checking can never make things worse

Most ideas get killed.

Nothing goes live on a backtest alone. A strategy has to survive several rounds of testing and a spell on simulated money first — and it keeps being re-tested afterwards.

• Years of historical data behind every test
• Simulated and shadow runs before anything is armed
• Re-validated on a schedule once it's live
• Alerts when a running strategy starts to decay
• Failures get written up and retired, not quietly re-tuned

The whole thing fits in your pocket.

Everything reports into one place, and any part of it can be stopped from a phone.

• Current positions and performance at a glance
• Market open and close alerts
• Daily and weekly summaries
• A message the moment something drifts
• Any strategy can be halted remotely

Built for accounts that don't give second chances.

Funded trading accounts come with limits that end the account if you break one even once — a maximum you can lose in a day, a maximum overall, a minimum number of days traded, and restrictions around weekends and news.

Almost all of the risk design above exists to respect those limits automatically instead of depending on someone watching a screen. It behaves differently while an account is being evaluated than it does once it's funded.