The Machine Room

The halt learns to end. The circuit breaker that stopped the engine on seventeen of the week's twenty-six runs took its leading reason from a reading computed once, in the morning — so a weak 6am print bought a whole session, and the release could not arrive before the next 6am. Asked on Sep 15 whether it should just run more often, the answer was to measure first: a shadow job took the reading every thirty minutes and wrote down what it would have said, changing nothing. Five sessions decided it — the raw reading flipped eight times, a version requiring three consecutive agreeing reads flipped twice, and on Sep 17 the confirmed version would have released at 07:57 PT while the daily file held to the close. It went live Sep 18 as a release leg only: it can lift a halt mid-session and stop a lifted one re-engaging on the same stale daily number, and it cannot create one. Intraday engage was deliberately not built — the ask was fewer halts. Rollback needs no code change. 198 governor checks, 24 of them new.

Two graders with mirror-image carry bugs. Sourcing the weekly grade turned up two figures that traced to a source file and were still wrong. The equity grader listed its windows rollup among the keys it copies forward untouched — and nothing anywhere produced it, so it had been photocopied since it was first written by hand, reporting a 17-trade lifetime while the block beside it in the same file read 20, with the payoff ratio and a −$195.18 drawdown computed off the stale slice against a ledger summing to −$196.35. The options grader had the exact inverse: it built its output from scratch and wrote it out without reading the file it replaced, erasing the weekly review's written analysis every night. That file had already diagnosed itself, in a sentence the next run was about to delete. Both fixed, both proven by running the old and new versions side by side, and both committed — the first time either grader has been under version control. The full build note →

Three systems sit between the trading engine and a new position: the flow sniffer, which watches the options tape for unusual single-name buying and asks whether news already explains it; the EMA regime read, which sets the size dial from where the two big index funds sit against their moving averages; and the risk governor, the circuit breaker that writes one file saying whether the engines may open anything, and in which direction. On Thursday and Friday all three went from prompts a model re-read every morning to scheduled jobs that run no model at all. Each was audited first by a second model reading the live files, and each had the same defect: the rule lived in a sentence, its numbers lived in several disagreeing copies, and a missing input read as a passing one.

The sniffer was grading a score nobody had acted on — the run's log said 43.2 for an Adobe put, the ledger stored 34.2, and the gap was exactly one feature applied in one place and not the other. Its size haircut made a $50B+ company's ceiling 60 against an alert bar of 65, its $500,000 floor discarded 95.7% of a session's alerts, and its go-live test needed a comparison bucket that had n = 0 by construction. Version two: 45 modules, 195 checks, one immutable decision record with the score inside its id, a grading protocol hashed before any outcome, and a model that runs only when there is something to read. The governor engaged its long-only halt Thursday at 08:02 PT on live inputs, and its release test was satisfied at the same moment; the model producing it held the halt by a judgment it wrote down as unauthorised. Three readers carried three copies of "valid," and a stale regime file would have released a tier 3 halt the moment its evidence went missing. Now: one validator imported by both engines, the watchdog and the order hook at the broker's edge; a state machine that remembers each reason; every 30 minutes instead of four times a day. The regime read was arithmetically right to the cent and surrounded by four different sizes for the same tier — 0.0, 0.5, floored to 0.1, mapped to 1.0 — computed each morning by a task spending 27–41k output tokens to produce four averages. Now one contract, zero model calls, 0.4 seconds.

Friday, live. The sniffer's first two hours: every investigation refused by a missing manifest flag, zero model calls, status ok. Fixed 08:31 PT; then nine slots, 25 model calls, 23 cards — every half hour, from a system whose design says it almost always finds nothing. The governor's stricter input rule posted new risk blocked twenty minutes after the close, because the exchange had not yet published a VIX row for a fact every intraday run already held. Both false words came from a status that was asserted rather than derived, and both fixes make it derived. Not measured: whether the sniffer has any edge (2,806 observations, all unresolved), or whether the governor has ever saved a dollar. The full build note →

Four days, four fronts: a ranking model that had quietly stopped responding to evidence, the last three safety gates on the trading engine, a written contract underneath the semiconductor pipeline, and the newsletter's figure work turned into a module. Then the part that belongs in a build log more than any of it — what it cost to direct four days of that pace.

Wednesday — the cyber ranking had frozen, and nothing could see it. The private-company model ranks about twenty security firms by likelihood of being acquired. A new check asked how much that list moves week to week: agreement between consecutive runs averaged 0.994 out of 1, four pairs at exactly 1.000, and one company held the identical probability — 0.761 — for eight consecutive weekly runs. Two defects underneath. The model's largest input was a ratchet, not a rate: across fourteen runs it moved up twelve times and down once while the sector's deal count halved (42 in February to 21 in July), with one category pinned at 0.95 for all fourteen. And five of thirteen run-pairs changed nothing at all — the block was copied forward rather than recomputed. Neither the accuracy score nor the calibration check could detect either, because both measure whether the numbers are right and neither measures whether they are new. Four versions shipped that day: a competing-risk term for companies that might list instead of sell, an AI exposure score conditioned on what kind of moat a company has rather than applied flat to the sector, the ranking metric that caught this, and the fix. A guard now refuses to write the run unless something moved, the numbers match the formula, and the series is not up-only over six runs. The first build of that fix was wrong in the most embarrassing direction — it read two summary fields as if they were months, inverting the correction so every category would have gone up — and it was caught by running it, not by reading it.

Thursday — three earnings deep dives in an afternoon (Broadcom, HPE, Western Digital), each published and each wired to its paid edition. Volume is not the point; the point is that the converter that makes it possible went in the day before, replacing a hand step that had been the actual bottleneck on this vertical since it started.

Friday — the trading engine went live. Six gates stand between the engine and real entries, each defined by written criteria a checking script confirms, on the rule that a gate is a computed fact, not an assertion, and that no script may flip its own gate. Three were already closed. Friday closed the two that cannot be closed by reasoning — a rehearsal placing real orders under per-drill approval, and a canary: one real share, placed by the engine, protected, watched. The test suite went from 490 to 529 passing between the morning readiness check and the arming, with 18 of its 30 files written or rewritten across these four days. The switch was armed by hand at 10:35 PT and the engine placed its first live order at 12:39 ET: one share of Ford, $14.5399, with a protective order placed alongside it. For about an hour and a half that stop was live at the broker and absent from the engine’s own book — not an unprotected position, an unverifiable one — and what noticed was not the trading run but the half-hourly monitor built the previous week to look for exactly this. Also Friday: all 127 scheduled jobs swept after one was found firing seven to nine times a month, and the fix for it was not better wording but a preflight script that prints proceed, skip or stop from three deterministic checks and halts the run before the model reads anything at all.

Saturday — contracts, and charts. The semiconductor pipeline's layers had no shared definition of what they pass each other; they agreed because they were written by the same hand in the same fortnight, which is coincidence with a short shelf life, and it broke twice this month. They now share one schema, one date-aware resolver, a credit calculation computed by a single tool that fails the run if a prompt's copy disagrees with it, and a check that must exit clean before anything publishes a number. On the newsletter side the figure work became a module — flow, waterfall, stacked and trend charts, plus a generator that builds an income-statement diagram from a filing's own line items — and 31 existing deep dives were backfilled with one.

Now the part that is not a feature. This pace is only available because the assistant reads the surrounding system and volunteers what it finds there — and that same behaviour is what nearly lost the week. Every session ends with a short list of things it noticed on the way past: a guard that should be tightened, two jobs that disagree about where a file lives, a check that would have caught the thing just fixed. Every item is real and every item is small enough to say yes to. Take one and it opens with its own list. The suggestions are generated from what the model just read, not from what you sat down to do — locally true, globally undirected. Four conversations in, the work is three branches deep in repairs nobody chose and the original task is still open behind you. What makes it hard to catch is that each individual step was an improvement.

The receipt is the notes file. The assistant keeps standing notes on how this operation actually works — how a schedule behaves, which file is authoritative, what a flag really does. It was created Aug 31. Six days later it holds 66 entries, most of them corrections written after something turned out to behave differently from what the last change had assumed. That is not a record of things learned so much as a record of a loop running faster than the person supervising it can read. The rule that came out of it is about sequencing, not capability: deliver the finding first and let the operator choose the fix; never chain a second change onto the first. Every graded engine here already carries a version of that rule — a minimum sample before any parameter moves, tweaks routed through a weekly review rather than applied on sight. It had never been applied to the act of maintaining the system itself.

The worst outage this operation has had. Every scheduled job — all of it, every pipeline in this log — ran inside a hosted Linux machine in the cloud. On Sunday morning that machine stopped being able to start. Not slow, not erroring halfway: it could no longer create the account a job runs under, so no line of code ran at all. The error was the same every time, four attempts in the morning and five more in a second pass that afternoon, each one under a different randomly-named session:

Different names, identical failure, which is what turned it from a bad session into a standing bug on the provider's side — nothing fixable from here. The jobs themselves were fine. They could still read and reason; they simply had no floor to stand on. The clearest picture of what that costs is in the day's safety report, which was supposed to check whether the trading engine was clear to go live and instead came back with no green and no red — no data at all. That is the worst answer a safety check can give, because it looks like nothing happened.

So the fleet moved home. Claude Code runs on the Mac itself, with the same skills and the same prompt files the cloud jobs were reading, which is why a rebuild that should have taken a week took a day. What changed, specifically:

The honest cost: local jobs only fire while the app is open on the Mac. That is a real downgrade from a machine that never sleeps, and it is the next thing to fix. The trade was made anyway, because a fleet that runs when the laptop is open beats a fleet that does not run at all — and because the failure exposed the sharper problem, which is that 110 jobs sat on one machine nobody here controls.

Nothing new shipped this week. What changed is how the prompts get written. They used to be written straight into the job that runs them, which is why so many of them quietly disagreed with each other. The newer ones come out of a loop that runs across two models, deliberately, because the failure being hunted is invisible from inside any single file:

Neither model grades its own work, which is the whole reason for the split. The major changes it produced, in summary:

The two heaviest daily gathering jobs — the semiconductor evidence sweep and the demand-evidence sweep — moved off the scheduler and onto ChatGPT, on the logic that wide, shallow collection shouldn't compete for the same budget as the layers that actually have to reason. Their outputs are now the freshest artifacts in the cascade (newest Aug 22, one day old, 53 and 51 files). Splitting a pipeline across two runners creates two silent failures, though: a step left switched on in both places runs twice and overwrites its own evidence, and a step nobody picks up stops producing while every gate downstream keeps reporting waiting on upstream. So the seam got a contract — a declared file naming, per step, who runs it now (chatgpt/cowork/manual/none), what it writes and reads, and how stale its newest output may be — plus a read-only auditor that checks the contract against the files on disk and the live scheduler. First run, Aug 23: the handoff is clean, and it surfaced 18 failures nobody was looking at, including one daily step declared live and silent for 58 days.

The anticipation engine ran its first full loop: freeze a dated call before a company reports, then grade it blind after. The debut case was Nebius — the day before its print it logged a read (direction a coin flip, the ~20% move the options market was pricing judged too rich to pay for → stand down), and after a contained +16% report it scored itself: direction correct, trade a wash, graded on separate scorecards. In the same run it planned the operation's first real defined-risk debit spread — buy one call, sell a higher one, loss capped by design — on Applied Materials into the Aug 13 close. It's the exact structure the live options sleeve keeps losing without; the job now is to move it from the lab into the room where real orders get placed.

A separate, quarantined engine that takes a small, defined-risk position into an earnings event to test whether the mechanics can call the reaction — the mirror image of the reactive trader, which only ever follows a move. Its signature rule came out of a live CoreWeave read: when a beaten-down name in a washed-out sector refuses to break down the way every gauge says it should, that refusal — backed by quiet accumulation — is a contrarian buy, not a warning (an oversold spring, or the sector being bought back with the name out front). It runs on zero real capital, freezes a dated, falsifiable call before each event, and grades the direction apart from the trade — a correct read can still lose to the post-print volatility crush.

This section — a weekly, self-graded operator's log covering the newsletter's three verticals and the agentic trading engine. The system now reports on itself in public.

The weekly issue gets a companion video: the newsletter's read, narrated and cut into a short, embedded on-site and cross-posted to Substack. The written issue became a watchable format.

The Robinhood engine adds autonomous midday entries — a "tick" that re-screens, sizes, and manages a live cash sleeve across the whole session, then grades itself every night and feeds the lessons back in.

All the arithmetic — position sizing, stop levels, option pricing (Black-Scholes) and dealer-gamma/GEX maps — gets pulled into deterministic Python scripts (tick_compute.py, options_compute.py, gex.py). The AI decides what to do; the code does the math. "Keep the model out of the arithmetic" becomes a house rule.

tkal adds a dedicated earnings section — 30+ post-print write-ups reading each company's quarter against the demand/credit cascade. The coverage goes from weekly synthesis to name-by-name depth.

First real, self-graded trades on a small cash sleeve, with a nightly post-mortem writing to a cumulative-learnings file the next run reads. The self-improving loop gets its first live test.

The engine plugs into live market plumbing through Unusual Whales — options order flow, dark-pool prints, dealer positioning (greeks/GEX), max-pain and the market "tide." The screeners stop guessing at sentiment and start reading where the real money is actually positioned. (A second feed, public.com, and a fail-soft fallback were wired in alongside as cross-checks.)

Issue No.001 ships (May 27), built on a twelve-layer evidence cascade across semiconductors, cyber, and construction. The founding idea — dated, falsifiable, self-graded calls — goes live.

A new data source comes online: the engine pulls YouTube transcripts from options "furus" (finance influencers), extracts the specific trades they call, and tracks how those calls actually play out — turning hours of video into a structured, gradeable signal, and a contrarian check on the crowd.

A calibration-and-audit layer gets bolted onto the semiconductor cascade: every dated claim is logged to a predictions file, then resolved blind against what actually happened and scored for hit-rate and calibration. This is the moment the whole system's DNA shows up — act, grade, keep the receipt — the exact loop the trader and the newsletter run today.

The semiconductor stack grows past raw supply-and-demand into hyperscaler credit and end-customer layers (the L8HC credit registry, the L1D demand layer), and spins off its first tradeable output — an options-watch feed dated March 23. The read stops being an essay and starts pointing at a position.

Where it all started: a stack of hand-written prompts for the memory/semiconductor market, run one after another in Claude by hand — L1 gathers the evidence, L2 maps the states, L3 forms the beliefs, and on down the chain. No automation, no trading, no self-grading yet — just one person running a reasoning cascade to understand the memory cycle.