Meridian

A few words show up again and again in how we talk about Meridian, so it helps to define them once.

The read is the assessment we form each session of the day's state. The model on call is whichever execution model that state calls for. When a model runs, we're engaging; when none is warranted, we're standing aside, which means holding cash.

That's most of the lexicon. What matters more is the promise underneath it: we publish the trades, not the recipe. Every entry, every exit, every result is open for inspection. The engine that produces them stays private.

We also try to avoid the usual guru vocabulary. Phrases like smart money, manipulation, or killzone dress up guesses as insight. We'd rather use plain language grounded in what we can actually observe and measure. If we can't state something precisely, we'd rather not claim it at all. The point of this series is to explain how the program thinks without pretending it's magic.

It's tempting to talk about a market as if it has a fixed personality. In practice it doesn't. The same instrument, traded the same hours, behaves like a different animal from one session to the next. Some days carry a steady character all the way through. Others turn quiet, or choppy, or disorderly in ways that make a method that worked yesterday look broken today.

This is the premise Meridian is built on. If days genuinely differ in kind, then no single fixed approach can fit all of them. A method tuned to one sort of day will, by construction, be wrong on the others. You can average that out and call the mediocre result an edge, but you've really just blended good conditions with bad ones.

The alternative is to treat the kind of day as the first question, before deciding how — or whether — to act. That's a harder problem, but an honest one. Most of what follows in this series is about how we try to answer it without fooling ourselves.

Before Meridian does anything, it forms a read of the day's state. The read comes first, and it decides what — if anything — runs that session. Nothing is deployed until the day has been characterized.

Two things make the read trustworthy rather than a story we tell ourselves. First, it's formed the same way every single session. There's no version of it that's more careful on important days and looser on quiet ones; the procedure is fixed. Second, it's built only from what was actually available at the time. The read never reaches into information the session hadn't produced yet.

That second point sounds obvious and is the easiest thing in this business to get wrong. It's trivial to build a read that looks brilliant when you let it peek at how the day turned out. That isn't a read; it's a memory. A real read has to commit using only the past and present.

So the sequence is always the same: characterize the day, then let the characterization decide. Not the other way around.

For each state we actually trust, there is a single execution model, built and validated specifically for that state. Not a general-purpose model with settings, and not an ensemble voting on what to do. One state, one model.

And in any given session, at most one of those models is ever live. The read points to a state; if that state is one we trust, its model runs and the others sit idle. We don't blend their signals, we don't stack them, and we don't average their opinions into a compromise.

The reason is that blending quietly destroys the very thing that made each model worth deploying. A model earns its place by working within the conditions it was built for. Run it outside those conditions, or dilute it with another model built for a different day, and you're no longer trading the thing you validated.

So the design stays deliberately plain: match the day to at most one model, run that model exactly as tested, or run nothing. Simplicity here is a feature, not a limitation.

The most common thing Meridian does on any given session is nothing.

That surprises people who expect an automated program to be busy. But the logic is straightforward. We only trust a handful of market states, and only for those states do we have a model we've validated. When the day's read comes back as a state we don't recognize, or one we recognize but don't trust, there's no model to run. So we hold cash.

Standing aside is not the program failing to find a trade. It's the program working exactly as designed. A method that must act every session has quietly committed to trading its worst conditions alongside its best ones, and those bad conditions are where accounts bleed out slowly.

Refusing the ambiguous day costs nothing but the illusion of activity. It protects capital for the sessions where we genuinely have an edge. If it feels unsatisfying to sit out, that's a feeling worth examining — the market does not pay you for participation, only for being right when you choose to act.

A quiet market and a wild one are not the same environment, and sizing a position the same way in both is a mistake dressed up as consistency.

Meridian anchors position risk to how much the market is currently moving. When conditions are calm, a given move is small, so the position can be larger for the same dollars at risk. When the market is thrashing, the same nominal move represents far more, so the position shrinks. The goal is that a losing trade on a quiet day and a losing trade on a violent day cost roughly the same in dollar terms.

Why does that matter? Because without it, your results are dominated by whichever handful of sessions happened to be the most volatile. A few chaotic days can swamp months of ordinary ones, and your track record becomes a story about variance rather than method.

Sizing to volatility makes each trade a comparable unit. It won't remove losses — nothing does — but it keeps any single session from carrying a wildly outsized share of the outcome.

We publish losing trades. We publish losing days, losing weeks, and drawdowns. On purpose.

This runs against the grain of how trading results are usually presented. The standard move is to show the good stretch, crop the chart at a flattering point, and let the winners imply the rest. A record like that isn't evidence. It's marketing, and it tells you nothing about what happens when the process is under stress.

The losses are the informative part. Anyone can look competent during a favorable run. What you actually want to know is how deep the drawdowns go, how long they last, how the program behaves on its worst days, and whether the losing trades cluster in ways that suggest a flaw rather than ordinary variance. None of that is visible in a highlight reel.

So the full record is there — winners and losers, timestamped and complete. It makes us look less impressive on any given screenshot. It also makes the track record something you can actually reason about, which is the only kind worth publishing.

There's a crucial difference between a model that fits the past and one that would have worked going forward, and confusing the two is how most strategies quietly fail.

Fitting to the past is easy. Give me any stretch of history and enough freedom, and I can build something that traded it beautifully. That result means almost nothing, because the model was allowed to shape itself around outcomes it already knew. It memorized the answer key.

Walk-forward validation refuses that shortcut. You build the model on one span of history, then test it on a later span it was never allowed to see, and you judge it only on that unseen data. Then you roll the window forward and do it again. What you're measuring is performance on genuine out-of-sample days — the closest honest proxy for how it would behave live.

It's a more demanding standard, and plenty of ideas that look wonderful in hindsight simply don't survive it. That's the point. We'd rather discover a model is hollow in testing than discover it with real capital.

Most of what a systematic program does is decline. Discipline, in practice, is mostly a list of things you refuse to do.

Meridian passes on any day whose state it can't confidently characterize. It passes on states it can name but hasn't validated a model for. It passes when conditions sit in the ambiguous space between the states it trusts, rather than forcing a fit. And it ignores the ordinary temptations — a market that looks like it's doing something interesting, a run of losses that makes acting feel urgent, a quiet stretch that makes sitting still feel like waste.

None of those are reasons to engage. They're just pressures, and a rules-based process exists partly to be immune to them.

The hard part isn't building something that can trade. It's building something that will stay in cash through all the situations that merely resemble opportunity. Every one of those refusals is a small forgone thrill and, more often than not, a loss avoided. The list of what we don't trade is longer than the list of what we do, and that's by design.

The site shows the full record, but a number can mislead you if you read it in isolation. A short guide to what each one does and doesn't say.

The equity curve shows the path, not just the destination. Two strategies can end at the same place, one smoothly and one through gut-wrenching swings; the shape matters as much as the endpoint.

Hit rate — the share of winning trades — is the most over-weighted number in trading. A high hit rate can still lose money if the losses are large, and a low one can compound nicely if the wins are bigger. It means nothing on its own.

Profit factor relates what was won to what was lost. It's more informative than hit rate, but a small sample can inflate it easily.

Drawdown is the number to sit with longest. It tells you how bad the worst stretch was, which is what actually tests whether you can stay invested.

Read them together, across enough trades to matter. Any single figure, taken alone, is a way to fool yourself.

An edge that only appears in one kind of market sounds fragile, and often it is. But fragility isn't really about how narrow the edge is. It's about whether you know, in advance and from the outside, exactly when it applies.

A model that works only under specific conditions is dangerous when you run it blindly, because it will keep firing in the conditions where it doesn't work and quietly give back everything. The same model becomes robust the moment you can reliably identify its conditions and confine it to them.

That's what gating does. Each Meridian model is restricted to the states where it was actually validated, and it simply doesn't run elsewhere. This can look restrictive — the model sits idle most of the time. But the restriction is the source of the robustness, not a limitation on it.

The fragile version is the general-purpose model that promises to work everywhere and therefore commits to working in its worst environments too. A narrow edge, correctly fenced, is sturdier than a broad claim that can't survive contact with the days it wasn't built for.

In the live account there is no human discretion. The read is a set of rules. Each model is a set of rules. They run identically every session, and no one overrides them in the moment because the day feels a certain way.

That matters because in-the-moment judgment is exactly where consistency goes to die. The same person will size up after a win and freeze after a loss, will see conviction in noise and hesitate on a valid signal. Removing discretion from execution removes that whole category of error. The program does on a good-feeling day precisely what it does on a bad-feeling one.

This doesn't mean judgment plays no role. It plays an enormous one — just earlier, and offline. Deciding which states to trust, building and validating models, choosing what evidence is convincing enough to deploy: all of that is human, careful, and deliberate.

The discipline is in the boundary. Judgment belongs in research, where it can be checked and tested at leisure. It is deliberately kept out of the live account, where it would only add variance we can't measure.

A single losing session tells you almost nothing about whether a process is sound. That's not a comforting slogan; it's just how variance works.

Even a genuinely good process loses regularly. If it's right more often than not with favorable sizing, individual outcomes still scatter widely around the average. Strings of losses happen by chance alone, and they happen more often than intuition expects. Reading a bad day as evidence of a broken system is one of the most common and expensive mistakes in trading, because it leads to abandoning something sound at its worst moment.

So how do you tell ordinary drawdown from a real problem? Not by the depth of any one loss, but by whether the behavior stays inside what testing led you to expect. A drawdown no worse than ones the validation already showed is noise. A problem looks different: losses arriving in conditions where the model was supposed to stand aside, results drifting persistently outside the tested range, the process doing things it was never built to do.

The number to watch isn't today's result. It's whether the pattern still resembles the one you validated.

Every published number carries a verifiable fingerprint — a hash computed over the underlying source data. The point is simple: the record can be checked, not merely believed.

A hash is a short string derived from a body of data such that any change to the data, however small, produces a completely different string. Attach one to each result and you've made a commitment that can't quietly be edited later. If a trade's details were altered after the fact, the fingerprint wouldn't match, and anyone could tell.

This matters because the usual currency of trading claims is reputation. You're asked to trust the person, the screenshots, the story. Reputation is exactly the thing that's easiest to manufacture and hardest to audit.

Verifiability replaces trust with something you can inspect. You don't have to take our word that a trade happened as stated; the record is structured so that it can be independently confirmed. It's a higher bar to hold ourselves to, and a deliberately uncomfortable one. That discomfort is the point — a claim you can check is worth more than one you're asked to accept.

Holding cash isn't the absence of a decision. It's a decision, made deliberately, with real value.

The arithmetic is easy to overlook. A loss avoided compounds exactly like a gain realized. Skipping a bad day leaves you with more capital to deploy on a good one, and that preserved capital grows for the rest of the record. Over a long enough run, the sessions you correctly refused can matter as much as the ones you traded well.

This is why the days Meridian does nothing are part of the strategy rather than gaps in it. When the read comes back as a state we don't trust, cash is the position we're holding on purpose — the one the process selected. It isn't idleness or waiting for something better to come along. It's an active allocation to not losing money in conditions where our edge doesn't apply.

A program that only knew how to be in the market would be missing half its toolkit. Knowing when to hold nothing, and being disciplined enough to actually do it, is as much a part of the method as any trade.