Every trade comes home by 3:45.

Anyone who has let code trade real risk on their behalf has lived some version of this: a position that looked fine at 3 p.m. is still open at the close, a scary headline drops after hours, and the account opens the next morning already down more than the whole plan allowed.

The code didn't do anything obviously wrong — it just never asked what time it was. A stop-loss (an automatic order to sell the moment a price falls too far) that only lives in a settings file, not with the broker (the platform that actually places the trade), does not fire while everyone is asleep. A short position — a bet that pays off only if the price falls, so a rising price is a growing loss — kept open "just in case it keeps falling" quietly becomes an unlimited bet the moment the market gaps up overnight.

The usual fix people reach for is a smarter picker — a better signal, a bigger model, one more indicator. That is a different trap: even a great pick cannot save you from being open when you can no longer afford to be.

The problem

This is an autonomous trading system: one program that watches the market around the clock, decides what to buy, short, or hedge, and — critically — enforces exactly when every one of those decisions has to be undone.

It runs as a single always-on process. Overnight, it reads company news and price data to find candidates. During the trading day it buys the strongest ones, bets against ("shorts") the weakest ones, and adds a protective hedge — a second trade whose whole job is to make money specifically when everything else drops — when the broader market turns down. Two long-term holdings are permanently off-limits to its own selling logic; everything else lives inside a posted daily schedule.

The picture below is the shape of the whole system: a research stage that never sleeps, a scoring stage that ranks how confident it is in each candidate, an execution stage that only opens positions inside approved hours, and a memory that remembers what happened last time.

The big idea

Here's the part that isn't obvious until you watch it happen: even when the system is at its most confident, the schedule still wins.

A candidate trade can score as high as the system will ever allow and still get refused — not because it is wrong, but because the clock already passed the buy window's close. The same rule runs in reverse every afternoon: any short position still open gets closed, no matter how well it is working, because "no overnight short exposure" is not a suggestion — it is a hard boundary written into the code, not a setting a good trade can talk its way past.

The aha

Oh — it's not a smarter trader. It's a trader that would rather miss a good trade than be caught holding one outside its own rules.

One level deeper — four cooperating parts, each grounded in the actual running code.

A research fleet — several small scanners reading company news, price movers, and analyst data — runs continuously and writes what it finds as scored candidates ("research stars"). A conviction scorer combines those candidates with the system's memory of what has worked before into a single confidence number. The trade engine only acts on that number inside its posted hours: no new buys after 2 PM ET (Eastern Time, the US market's clock), every short forced flat by 3:45 PM ET, and two independent stop-losses riding on every open position — a 5% stop placed directly with the broker, plus an active check every two minutes that exits anything down $100. Every outcome — win, loss, or refusal — is written back to an external memory service (Trident, whose learning layer is called SONA) that shapes tomorrow's scoring.

Architecture

Data flow

Three concrete situations, pulled straight from how the system is configured to behave.

In the real world

It runs as two cooperating apps plus an optional edge worker — here is the fastest path to seeing it alive on your own machine.

git clone https://github.com/cmcgrath2023/autonomous-wealth-builder.git
cd autonomous-wealth-builder/services && npm install
cd ../mtwm-ui && npm install

1. Configure credentials. Fill in a paper-trading Alpaca API key, a PostgreSQL connection string, and Trident API credentials in services/ — the orchestrator refuses to start without them.
2. Start the trading orchestrator. From services/, run npm run dev. You'll see the gateway boot, log its 2-minute heartbeat, and start scanning — this is the process that actually places orders.
3. Start the dashboard. From mtwm-ui/, run npm run dev and open http://localhost:3000 — you'll see the live Dashboard, Trading, Research, Intelligence, and Strategy tabs the orchestrator is feeding.
4. Watch the first cycle. Within two minutes you should see a fresh heartbeat entry in the gateway's logs, and once the research fleet completes a pass, scored research stars start appearing in the dashboard's Research tab.
5. What's next. Read docs/strategy-spec.md for the exact entry/exit rules and docs/ADR-027-trade-engine-qa-checklist.md before touching the trade engine — every strategy change is expected to be documented there first.

Every explainer here downloads with a real, searchable knowledge base of this exact repo — hundreds of passages, its public symbols, its dependency map, and its entrypoints — so your own agent can answer questions about it without re-reading the whole codebase.