Teaching a trading desk to run itself

I bought vendor bots and let them run on the same platform with no brackets and no oversight. An early wave of evaluation accounts died. Nothing about that was the machine's idea.

The first strategy the model drafted never held to a bracket: 99% of its exits were reverse, flatten or sync churn, so an edge was structurally impossible. Six evaluation accounts and a wave of sims went with it. The model wrote it; I approved it without asking for evidence first.

The fan-out treated accounts at one firm as independent and placed opposing positions across them. The firm polices the trader, not the account, and closed three. Rule born that day: one actor per firm, one direction per fleet.

A language model chose trades on real evaluation accounts with zero track record: −$810 in a day, a profit factor of 0.29 measured afterward. It is permanently dead and a tripwire keeps it dead. The entries were the AI's; letting an unproven method touch real accounts was my call.

A server-side stop survived the close and fired overnight, and the naked position poisoned a trailing peak. A guard's grace clock reset on every run, so it never acted. Both were code the model wrote and I merged.

I hand-managed exits on evaluation accounts and closed them at the worst prices while untouched sibling accounts survived. The ledger's one lesson: no account died from a proven signal held to its bracket.

The weekend stand-down walked a hard-coded list of contract months that had already rolled. It saw nothing, reported all flat, stood the connections down, and left nine accounts naked into a weekend. Hard-coded contract spellings are banned from every safety path since.

A trading-platform repair rewrote its own configuration and took a broker connection and its stored login with it. The desk grew a machine-local vault for prop-firm logins so no repair can erase them again.

A gate that existed only in a code comment. The comment described the check; the function underneath never made it. Reviewed, fixed, and the pattern named so it gets hunted.

A panic flatten read the position, sent an offsetting order, re-read before the first fill landed, and sent another. A long six on a simulation account became a short six. Flattens now settle before they offset.

A dead order interface read as zero positions, and guards acted on positions they could not see; one real position spent the night naked. The reader now returns unreadable as its own answer, and every consumer treats it as not flat.

A local language model quietly consumed the trading machine's memory until the platform itself began failing. Diagnosed remotely from state files; the brain moved to the cloud with automatic failover the same afternoon.

Full-size contracts traded by hand in the first minutes of the open on a funded account, breaching its consistency rule. The desk's job expanded to gating hand clicks with the same policy as its own orders.

The live cash account sat unprotected because of a bug in guard code, caught at six in the evening. The guard was fixed and a second, independent net added behind it.

I clicked a button that doubled whatever was open; the broker had to reject it for margin. The button had no account awareness at all. My click, the model's guardless button; it now refuses before it sends.

The one account holding real cash was classified as simulation by the desk's own tables, so real money was getting simulation-grade alerts. Reclassified, verified on the machine, and the alert tiers split: real money screams, simulation whispers.

Lane cuts were made from estimated P&L rather than real fills, and jailed strategies that were fine. Released, root-caused, and the rule written: a cut from a prop account never rests on a guessed exit price.

A session spent twenty steps diagnosing an outage that was the scheduled Friday shutdown, restarted the platform, and triggered an unnecessary cleanup. Nothing was forgotten; nothing was checked. The preflight command that prints intent beside state exists because of this.

The position sentinel tried to add a stop to a live position that already had one. Same day, a safety property with an impossible default kept the whole chart trade panel from loading. Both were the model's code.

A halted desk came back armed after a reboot because a flat check failed open. The halt was restored and the check made to fail closed; a system that cannot verify flat now assumes it is not.

The platform's chart froze and a broker reconnect took thirteen minutes, with third-party add-ons the prime suspects. It set the definition of super reliable that the code is now measured against.

A mid-session platform crash, then an upgrade whose database migration silently failed on an empty file: no connections, no templates, no accounts. Recovered by script, saved logins included. The vendor add-ons were dropped for good.

Five reviewers, five slices, and the findings were mine to own: a control token served to the public tunnel, the evidence ledger wiped to zero bytes by a scheduled rebuild, a stand-down that knew half the firms and reported the rest flat, a readiness check crying wolf for two days, and a firm's ownership dropped by the morning stand-down so twenty-two evaluation accounts spent the day invisible. Every one is now a test.

One audit recommendation changed the operator's own workflow: rotating that exposed token. It broke his chart alerts for an evening and was reverted on his word. Closing a leak is the desk's job; changing how a person works is his decision, and it does not hide inside a bulk approval.

A strategy override had quietly expired two days earlier, and a simulation-only day cap was gating the real-money fan-out. Nothing placed and nothing said so. Expiry abolished, the cap scoped to sims, and every refused leg now reports itself.