How the machine actually runs

By now you know the idea: the crowd overpays for weather surprises, and a good forecast can spot when a price is out of line. This chapter is about the boring, important part — the actual machine that does this, hour after hour, without a human babysitting it.

Think of everything in the last eight chapters as a recipe. This chapter is the kitchen: the equipment, the timers, the fire extinguisher on the wall. A recipe that only works when a chef is standing over it isn't much use. We want something that cooks the same dish correctly at 3 a.m. as it does at noon — and that never sets the building on fire.

A fair warning before we start: this chapter is going to sound impressive, and the machinery genuinely is fast and careful. But speed and cleverness are not where the money comes from. The edge — if it exists — lives entirely in one thing: our forecasts being better calibrated than the crowd's (Chapter 6). All this engineering does is make sure we can act on a good forecast without being picked off, and never bet the farm on a single opinion. Keep that in mind whenever a number below looks slick. The plumbing is not the profit.

01 — The always-on loop

The heart of the system is a loop: a short list of steps the machine repeats forever. A loop is just "do these things, then start over." Every 5 minutes, the machine wakes up and runs four steps.

Two terms there deserve a plain definition. A market is a single yes/no question you can bet on. An order book is the running list of every price people are currently willing to buy or sell at — like the bid and ask board at a stock exchange, or the stack of offers at a busy fish market. Reading the book tells us what the crowd is charging at this exact second.

The forecast in Step 2 isn't one weather model's guess. It's an ensemble — many independent forecasts run together and averaged, the way you'd trust the average of 122 thermometers more than any single one. Ours combines roughly 122 members from three major forecasting systems (GFS, ICON, and ECMWF), reading temperatures at about 80 curated weather stations we've hand-picked for reliability.

The forecast is also the expensive step, so we don't redo it needlessly. Full weather models only publish new runs a handful of times a day — the underlying picture of tomorrow's high in Chicago does not change between 12:00 and 12:05. So the machine caches its forecasts: it computes an ensemble once, holds onto the answer, and reuses it until a genuinely new model run lands. Sitting behind that cache is a circuit breaker — a simple rule that says "if we're asking the upstream data source too often, stop and wait." That protects us from getting rate-limited or banned by the weather providers, which would be a silent, self-inflicted way to go blind. The order book, by contrast, is refreshed constantly, because that is the thing that changes second to second.

So there are really two clocks running at once, and it's worth separating them. The 5-minute loop is the slow clock — the sweep that re-discovers markets and refreshes forecasts. Underneath it runs a fast clock that never sleeps for five minutes: a persistent connection to the exchange that reacts to price changes in milliseconds. We'll get to that fast clock in Section 04. For now, hold the picture of a patient sweep on top of a twitchy reflex.

02 — Fake money first (paper trading)

Here's the part most people skip, and it's the most important. Right now, the machine places no real bets. It runs the full loop — real markets, real prices, real forecasts — and makes real decisions. But the money is fake. This is called paper trading: you write your trades down on paper (or, these days, in a database) as if they were real, then check later whether they would have won.

Why bother deciding correctly with pretend money? Because an edge — a genuine, repeatable advantage over the crowd — is easy to imagine and hard to prove. Anyone can look at last week and invent a story about why they'd have won. Paper trading forces the machine to commit to a decision before the outcome is known, then keeps an honest scorecard. If the edge is real, it shows up in the paper record. If it was a fantasy, paper trading catches it before a single real dollar is at risk.

Crucially, the paper account is now a full lifecycle, not just a wishlist of trades. When the machine finds a cleared edge, it opens a position and records the price it paid. That position is then held across cycles — the 5-minute loop doesn't forget it, doesn't re-open it, doesn't panic-sell it. It waits. When the real weather station reports and the market settles, the position pays out (or expires worthless) exactly as it would have with real money, and the resulting profit or loss flows into the shown balance. The equity you see on the dashboard is the real fake result of real decisions carried all the way to the real outcome. That end-to-end honesty is the whole point: a paper trade that never settles proves nothing.

Here's a worked example to make it concrete. Suppose a market asks "Will the high in Chicago land in the 88–89°F bucket tomorrow?" Our ensemble says that bucket's true probability is about 42%. The exchange's best offer to buy YES is 32¢ — meaning the crowd is pricing it at 32%. That's a 10-point gap, and it's on the right side: we think it's more likely than the price implies. The machine buys, say, 50 shares at 32¢ — $16 of (paper) capital committed. Then it waits, sometimes a full day. When the station finally reports a high of 88°F, the market resolves YES; each share pays $1. The 50 shares return $50, against $16 paid — a $34 paper profit, which lands in the equity curve. Had the high come in at 91°F instead, the shares would have expired at $0 and the $16 would have been a realized loss. Either way, the scorecard is honest, because the machine committed before the weather was known.

We've already used this discipline on the trickiest piece — how a market settles (Chapter 7). Getting the payout wrong is a silent way to lose, so we replayed our settlement logic against 220 real market-days of history to confirm it matches how the exchange actually paid out. It did.

Now the honest, uncomfortable part about how often the machine actually trades. These weather markets are not empty — every one has tens to hundreds of thousands of dollars of resting offers to sell. But that depth is overwhelmingly one-sided: it's market-makers stacking sell walls, with thin bids underneath. And wherever the price is a real, contested number — somewhere between roughly 10¢ and 92¢ — the market is already efficiently priced, because those market-makers are good at their job. That leaves most of our apparent "edges" sitting against 0.1¢ dust on unlikely tail buckets — prices so tiny they aren't real offers, and our minimum-price gate (Chapter 8) correctly refuses to touch them. When you run the filters honestly, only about 2 of ~18 real edges survive the gates.

The consequence is that most cycles place zero trades, and that is the correct behavior, not a bug. The genuinely two-sided, tradeable window tends to open roughly a day before resolution, and it slams shut as resolution nears and the outcome collapses to near-certainty. A patient machine that does nothing on 99 cycles and acts on the 100th is behaving exactly as designed. Discipline looks boring from the outside.

03 — The dashboard

A machine making silent decisions in the dark is not something you should trust. So the loop writes down everything it does, and a dashboard — a live web page of charts and numbers — shows it to a human in plain view. A dashboard is just a window into the machine: which markets it looked at, what its forecast said, what the crowd was charging, what it decided, and how the paper account is doing.

The point isn't decoration. It's accountability. If the machine starts behaving oddly — chasing bad markets, or disagreeing with reality — a person can see it on the dashboard and pull the plug. You can't supervise what you can't see.

The dashboard is also where the paper P&L becomes legible instead of a raw number. Because positions now open, hold, and settle on their own, the balance and equity curve you see there are telling a real story: this is what the strategy would have done to $1,000, carried through actual weather outcomes. And it's where the "zero trades is fine" nuance stops being an abstract claim and becomes something you can watch — you'll see the machine survey eighteen edges, reject sixteen at the gates, and hold its fire. When it does act, the exact market, our forecast, the crowd's price, and the size all sit there in the open, ready to be second-guessed by a human.

04 — Speed (and why it matters)

Prices move. A price that was mispriced when the loop started reading it can be fair by the time the loop finishes thinking. So the machine has to be quick. But before the numbers, one design decision matters more than any of them: how the machine hears about a price change.

The naive way is polling — every so often, ask the exchange "what's the price now?", like phoning a shop every minute to ask if a coat's gone on sale. It's simple, but it's always a little stale: the sale could have started and ended between two calls. The better way is a WebSocket — a single phone line you open once and leave open, so the shop calls you the instant the price changes. That's what polyAether uses: a persistent WebSocket connection to the exchange's order books that pushes every change to us the moment it happens. We're not asking; we're listening.

The piece that listens is what we call the reactor — a small always-running component whose only job is to catch each incoming book update and, in milliseconds, re-check whether that change created or destroyed an edge. This is the fast clock from Section 01. When a market-maker pulls a sell wall, or a new best bid appears, the reactor sees it and re-evaluates before most humans could refresh a browser tab. It doesn't wait for the next 5-minute sweep. The sweep finds new markets and refreshes forecasts; the reactor watches the ones we already care about, continuously.

Here are the real numbers, and what each one means.

Let's put those units in human terms. A millisecond (ms) is one-thousandth of a second — a blink is about 100 of them, so reading a book at ~23 ms is roughly a fifth of a blink. A microsecond (µs) is one-millionth of a second, a thousand times smaller still. The decision itself — comparing our forecast to the price and sizing the bet — takes about 0.2 µs. In the time it takes you to say the word "go," the machine could make millions of those decisions.

Where does the ~23 ms actually go? Almost all of it is the network — the round-trip for data to travel over the internet, which is bounded by the speed of light and the wires in between, physics we can't cheat. To shave it where we legally can, the server sits at a Cloudflare edge location just a few milliseconds from the exchange, so our packets have the shortest honest path. But even at its fastest, moving a bit across the world will always dwarf the time to think about it. That's why the decision — the part that's genuinely ours — is essentially free by comparison. The machine spends almost all its time listening to the world, and almost none of it making up its mind.

Now the honest caveat, because this is exactly the kind of number that gets oversold. For fast financial markets, being a microsecond quicker than a rival is the entire game — you're racing other computers to the same trade. Weather is not that game. The information that moves these markets — a fresh model run, an hourly station observation — arrives on a timescale of seconds to minutes, not nanoseconds. So our speed is not the source of any edge. Its job is defensive and logistical: fast enough that a stale offer doesn't get yanked before we can take it, and first in line when genuinely new information lands. The edge itself is calibration (Chapter 6) — nothing here changes that. Speed keeps a good forecast from being wasted; it does not manufacture one.

05 — Servers and safety

Because the loop must run around the clock, it doesn't live on anyone's laptop. It lives on a server — a computer in a data center that stays on, plugged in, and connected, so the 5-minute cycle keeps ticking whether or not a human is awake.

An always-on machine that can spend money needs guardrails, and this is where every earlier chapter's caution gets wired in. The safety system (Chapter 8) is built into the decide step itself, not bolted on afterward:

• Fractional Kelly sizing. Bet a fixed fraction of the mathematically "optimal" amount, so one loud opinion can't blow up the account.
• Per-market, total, and daily caps. Hard ceilings on how much rides on any one bet, on everything at once, and on how much can be lost in a single day.
• Correlation cap. A limit on stacking bets that would all win or lose together — a heat wave over a whole region is really one bet wearing many hats.
• Kill switch. A single control that halts all trading instantly, for a human or the machine itself to hit when something looks wrong.

There's also a quieter gate doing a lot of work here: the minimum-price gate from Section 02. Most of what the model flags as an "edge" is against 0.1¢ dust on tail buckets — offers too tiny to be real. The gate throws those out before they ever reach sizing, which is why so many cycles end in zero trades. That refusal is a safety feature as much as a discipline: it's the difference between a machine that patiently waits for a real, two-sided market and one that churns fees chasing mirages.

None of these makes the machine smarter. They make it survivable — able to be wrong, repeatedly, without ending the game. That's the whole trick of running unattended: assume you'll be wrong sometimes, and make sure being wrong is never fatal.

06 — Putting it together

So here is the whole machine in one breath. On a server that never sleeps, parked a few milliseconds from the exchange, two clocks run at once. A slow loop wakes every 5 minutes to discover the open weather markets and refresh a 122-member ensemble forecast across ~80 stations, cached and protected by a circuit breaker. Underneath, a fast WebSocket reactor listens to the live order books and re-checks for edges in milliseconds whenever a price moves — reading a book in about 23 ms and deciding in a fraction of a microsecond whether the crowd's price is out of line. When a real, two-sided edge clears the minimum-price gate and the safety caps, it sizes a suitably small bet; the position is held across cycles and settled on the real weather outcome, and the profit or loss updates the balance a human watches on the dashboard. Most of the time — correctly — it places nothing at all.

And right now the money is fake, on purpose. The paper lifecycle works end to end, and the settlement logic checks out against 220 real market-days — but there is still no live track record, no real trade, no proven profit. The engineering is done and fast; the case for real money is still being made, one settled paper trade at a time. In the final chapter, we'll be equally honest about what could still go wrong.