A personal engineering project

Mithraeum · Agora

A desktop research environment for mining, building, testing and running systematic trading strategies — one that spends most of its machinery trying to prove its own results are luck, and that can replay, bar by bar, what a running strategy's orders actually did.

This site is a showcase, written for people I know who asked what I have been building. It describes how the system is put together and what the pieces do. It is not a product page, nothing here is for sale, and no claim on this site is an offer of anything.

The mining page after a finished search on the synthetic series SYN-ATLAS: the generator's settings and honesty line on the left, the field of every candidate's in-sample curve on the mined tape and on two basket tapes in the middle, and the chosen candidate's own book on the right, re-run at bar resolution with its signals and benchmark. — **The mining engine, mid-search.** Two hundred and fifty candidates evolved over four waves on *SYN-ATLAS* — an invented series the application generated itself. Left, the search's settings and its honesty line, which reports that the noise floor is stale and that this tape is too short to tell a Sharpe under about 1.46 from luck; middle, every candidate's curve on the mined tape and on two basket tapes it was scored on but never bred on; right, the chosen candidate's own book, re-run at bar resolution and checked against the row it came from. The figures are the demonstration's own arithmetic behind the application's standing hypothetical-results warning; nothing here is a result.

The Mithraeum the application: The program itself — a desktop application that runs on your own machine, where strategies are built, searched for, tested and run. Everything it knows stays on that machine.
The Agora the website: The web service beside it — accounts and signing in, the manual, a forum, a shared library and support. It knows who you are and nothing about what you trade.

Two names, two different things, and they are easy to run together because this showcase is named after both. Mithraeum is the software you would install. Agora is the site you would sign in to. Two more programs stand behind them, and all four are below.

543build rounds

332test suites

185klines of source

526API routes

113indicators

69design documents

138klines of tests

3.6MBengineering log

Counted from the working tree at Round 543. "Lines of source" is Python, JavaScript and CSS across the four programs, excluding test code, archived revisions, bundled third-party environments and vendored libraries; the 138,000 lines of tests are counted separately beside it. "API routes" is the combined HTTP surface of all four programs. Every one of the 113 indicators can now be drawn by the search as well as used by hand. The engineering log is the round-by-round write-up, one entry per change, kept since the first.

The mining engine

A search that argues against itself

Ask the machine for strategies and it will find thousands that look wonderful on the history they were found in. Almost all of them are luck. The search is built around that fact.

A grammar, not a dice roll. Candidates are drawn from weighted tables over every indicator in the registry — votes, negations, indicators read off other instruments, exits on the position's own state — then evolved over waves. A stored seed reproduces the exact population it produced the day it ran.
Selection never sees the answer. Parents are ranked on the training span alone; the validation span is judged, never bred on, and the holdout itself rotates.
A noise floor for every search. The same search runs again on tapes with the signal destroyed, so the best of a thousand is read against what the best of a thousand looks like on pure noise.
The market question, every time. Each candidate is measured against simply holding the tape — in six-month blocks, not as one flattering total.
A tail nobody looked at. The final months of an unattended search are sealed until it is over: the one number selection cannot have touched.

More on searching and trying to break it, the tool catalogue, and the research bots that run all of it unattended.

The selection-honesty panel over the same demonstration search: tiles for 280 examined, 250 kept, the deflated-Sharpe median and best and the minimum backtest length; a deflated-Sharpe histogram; a PBO run reading 71 percent with the verdict overfit factory; two reality-check tiles with p-values of 0.94 and 0.97; and the noise floor's tiles and verdicts — the best live Sharpe at or below the null median, the kept set's body at or below the null body median. — **The search, arguing with itself.** The same demonstration search's honesty panel: every kept candidate deflated by the 280 examined, a 71 per cent probability that the selection itself was overfitting — which it calls an *overfit factory* — two reality checks on the best row's excess over holding the tape, and a noise floor measured on signal-free twins of it. Its verdict on its own best candidate: *indistinguishable from noise wearing a strategy's name*. Synthetic series throughout; that is the product working as intended.

The replay

What the orders actually did

A backtest says what a strategy would have done. The replay shows what a deployment's orders did — bar by bar, scrubbable like a video, with everything that happened drawn where it happened.

Landmarks under the bar. Fills, signals, regime changes and session boundaries sit on a strip beneath the scrub bar. One key jumps to the next; two more set a loop.
One window for everything. The executed book, its benchmark, the price, the regimes and the indicators on one figure, with drawdown, position, volume and oscillator strips sharing its exact pixel window — so a trough sits under the bar that caused it.
The delay in two legs. The time from signal to fill split into the application's leg and the broker's, never summed into one figure that blames the market for the machine.
Every order's trail. Joined from the order's own history, the audit trail and the broker's log, each line wearing its source — and a round trip opened by an exit flagged as a trade nobody meant.
The same book, everywhere. The Backtest page scrubs a test exactly the way this page scrubs a deployment, and the live and mining pages wear the same look.

More on running it and on how execution is measured.

The Backtest page's book replayed to bar 763 of 1,060 for a demonstration regime strategy on the synthetic series SYN-BOREAS: the transport with play, speed and a strip of signal landmarks beneath the scrub bar; candles under risk-on and risk-off regime boxes with four moving averages; the strategy's book against buy and hold on the same axis, drawn only as far as the cursor with the rest of the run still empty; the values drawer reading the book, buy and hold and the position at that bar; and drawdown, exposure and oscillator strips beneath. — **The book, replayed.** A demonstration strategy on *SYN-BOREAS* — an invented series the application generated itself — played to the three-quarter mark: regime boxes over the candles, the strategy's book against buy-and-hold on one axis, the drawdown, exposure and oscillator strips sharing its exact window, and nothing drawn past the cursor yet. The same component, with the same transport, plays back a deployment's executed orders on the Replay page. The figures are the demonstration's own arithmetic behind the application's standing hypothetical-results warning; nothing here is a result.

The testing battery

Trying to break what survived

Whatever the search keeps is treated as luck until it has been pushed from every angle the project knows how to push — and the verdict comes back with its reasons attached.

One ordeal, the same every time. Twelve trials run in sequence against a strategy with nothing to configure beyond depth, drawn as one page — a grade ring stacked by pillar, and hard flags that cap the letter instead of hiding inside an average.
Markets that never happened. Costs, delay, volatility shocks and price jumps swept across ranges, and synthetic continuations grown off real history — data the strategy provably never saw, because it did not exist.
History, spent carefully. A held-out span behind an embargo wider than any indicator's window, and walk-forward folds that re-derive the strategy as they march through time.
The mildest world that kills it. A fixed ladder of eleven worlds from calm to crash, calibrated to the strategy's own behaviour — the answer is a sentence, not a score.
The procedure is on trial too. How likely the selection itself was to overfit, and whether the best of the search beats what that many attempts at nothing would produce.

More on trying to break it, and every testing tool, one by one, in the catalogue.

The Ordeal's score card for the demonstration strategy: a grade ring reading D, 69 of 100, stacked by pillar; three hard flags — no protective stop, probability of overfitting over 0.5 at 0.546, deflated Sharpe under 0.5 at 0.329; a note that the flags are kept out of the average and cap the grade, which would otherwise have been C; the headline figures, including a return 109.9 points behind buy and hold; a list of where the missing points went; and nine weighted pillars from crisis survival to transfer, each with its own sub-statistics. — **A verdict with its reasons attached.** The Ordeal's score card for a demonstration strategy on *DEMO-ATLAS*, a series the application generated itself: grade D, 69 of 100, capped by three hard flags it names outright — no protective stop, an overfitting probability of 0.55, a deflated Sharpe of 0.33 — with a note that it would otherwise have graded C, and a headline line admitting it finished 109.9 points behind buy-and-hold. A tool that graded everything well would be decoration; this one demotes its own demonstration and says exactly why. Every figure is that run's own arithmetic, behind the application's hypothetical-results warning.

And everything around it

Mining, the replay and the testing battery are the spine of it — finding something, finding out what it did, and trying hard to prove it was luck. Around them sits the rest of the application.

A strategy vocabulary

Votes of at least K conditions, weighted scores, negation, lagged operands, a calendar and a clock, swings and market structure, rolling regression, indicators on another symbol, pyramiding and risk sizing — in a logic tree, never a script.

Designing

Know your strategy

The whole plan as a tree with how often each condition fired, leading with the exits no condition controls — and saying so when a strategy has no stop at all.

Designing

Indicators you write yourself

Formulas parsed in a sandbox rather than executed as code, registered beside the 113 built-ins — so your own indicator appears in every dropdown, every search and every gate.

Designing

One data source, no fallbacks

Every request goes to the source you selected and to no other; an unrecognised one requests nothing at all, and the whole application can run fully offline.

Data

Books and rotation

Blend survivors into a portfolio or rank a universe through time and hold the leaders, with turnover charged honestly and the cash line drawn.

Combining

The live loop

A deployment ladder where nothing promotes itself, standing rules born in shadow, forward paper evidence, and a live book drawn like the backtest's.

Running it

Unattended research

Bots that mine, prove and label what they promote, under an honesty floor no configuration can lower and a guard on every door to your broker, your data and your work.

Bots

Safeguards and monitoring

A hash-chained audit trail, daily self-diagnosis, alerts derived from the trail, and limits a setting cannot switch off — everything that watches for the quiet failures.

Safeguards

A workspace that keeps up

Two peer panes on one screen, a context menu on whatever is under the cursor, pages that fit the window, and controls that say what is working rather than going grey.

The workflow

The four pieces

Two of them are the ones you would actually use — the Mithraeum is the application on your machine, the Agora is the website. The other two stand behind those. Click any card to open it; the row it sits in opens with it.

The Mithraeum the application

The application itself — a local-first desktop program for designing, testing and running strategies.

You describe a strategy as logic rather than code, test it against real history, search for variations you did not think of, try hard to prove the survivors were luck, and — if you choose to connect a broker — run them, then replay what they did.

Everything it knows lives on the machine it runs on. There is no server holding your positions, because there is no server.

Built on: Python · Flask · pandas · numpy, packaged as a desktop app
Brokers: **** · **** · **** (three, unnamed)
Data: **** · **** (two, unnamed) · or fully offline
Platforms: macOS today; a second build host for Windows
Isolation: Multi-tenant per login; no cross-account view

Its pages sit under Mithraeum in the bar — start with the workflow.

The Agora the website

The web service that handles accounts, the manual, a forum, a shared library and support.

It knows who you are and nothing about what you trade — and that is structural rather than a promise. It was never given a way to ask.

It also owns the paperwork of having an account at all, including closing one: self-service, password-confirmed, blocked by nothing, and your own contributions destroyed rather than hidden.

Owns: Identity only — billing lives elsewhere
Sign-on: Server-to-server ticket redemption, not via the browser
Support: Diagnostic bundles built through an allowlist
Never sees: Market data, positions, orders, strategy logic

It has its own page — the community in screenshots — and the strategy library beside it.

The Control Plane backend service

The backend owning commercial authority: subscriptions, signed entitlements and the release channel.

The smallest of the four and the only one holding a signing key. It answers two questions: what is this account entitled to, and what is the current version of the software — both answered with a signature the application verifies against a key it already pinned.

Signing: Ed25519; a new key can only arrive via a separate channel
Trail: Append-only and hash-chained; edits are detectable
Scopes: Public · service · operator, from one explicit map
Releases: One version, one signed binary per platform

Described with the trust boundaries on Architecture, under The platform.

The Hub never ships

The workbench. It launches, watches, tests, backs up and packages the other three — and never ships.

Operational tooling lives in a fourth program that is not part of any release, so the thing customers install stays a clean application rather than an application with a maintenance hatch in it.

Runs: 332 test suites; the verdict is the exit code
Watches: Background sampling with history and threshold alerts
Reports: Dependencies, stray processes, backup health
Never: Acts on what it reports

Toured on the workbench page, under The platform.

How the pieces fit

They are separate programs, not modules, and they run as separate processes. That separation is the main architectural decision in the whole project: the thing holding a signing key is not the thing exposed to the internet, and neither of them is the thing holding anyone's trading data.

The three arrows are the only things that cross. A sign-in, a signed statement of what the account may use, and a question about whether a newer version exists. Nothing about what you hold or trade is on any of them — the services on the right were never given a way to ask. The boxes are doors: each one opens the page that describes it.

The path a strategy takes

Seven stages, in order, and the order is the point — most of what follows exists to stop an idea moving to the next one. Two of them are gates rather than steps: nothing crosses them because it did well, and nothing crosses them by itself. The workflow takes each in turn.

1 Design
A strategy is a logic tree, not a script — conditions, votes, groups, and an optional regime gate.
2 Test
Run it over real history with costs, slippage and delay modelled, then scrub the result bar by bar.
3 Search
Ask a machine for thousands of variations — then spend most of the machinery defending against what it finds.
4 Validate
Held-out data, walk-forward, stress sweeps, synthetic paths, an empirical null. Most candidates die here, by design.
5 Combine
Blend survivors into a book, or rank a universe and hold the leaders — with turnover charged honestly.
6 Deploy
Paper, then connected, then armed, then unattended. Each rung is its own decision; nothing promotes itself.
7 Run and replay
Re-read the broker before acting, record everything locally, be able to stop — and replay what the orders did.

The two lit steps are the gates. Everything before stage four is a way of generating candidates; everything at and after it is a way of refusing them. What comes back the other way matters too — the replay, the attribution ledger and the position dossier turn a live result into the next revision rather than an abandonment. Stages three and four can be handed to an unattended researcher; stages six and seven never can, and that is a property of the code rather than a setting.

Five hundred rounds, in one column

The project is built in numbered rounds, each written up before it closes. These are the ones the rest of this site keeps referring back to — not a changelog, but the load-bearing moments. The full story lives in the working notes.

Round 1The log opens
The first numbered round, and the habit that outlasted every feature: nothing ships without its own written entry — what changed, what broke, what the mistake taught. Every round since has one.
Round 101Sign-in turns inside out
The application stops holding web credentials and starts redeeming a one-time ticket with the identity service, server to server. The browser becomes a courier that carries a token it cannot use.
Round 108Indicators you write yourself
Custom formulas, parsed in a sandbox rather than executed as code, register into the same registry as the built-ins — so your own indicator appears in every dropdown, every search and every gate, first class.
Rounds 144–151The mining lab ships end to end
Generation, evolution, diversity control, held-out fitness and the empirical null land as one connected machine. Most of what it does is refuse to let a search flatter itself.
Round 188The Ordeal
The whole testing battery, run in sequence against one strategy with nothing to configure — and coverage reported beside the score, because a partial run can flatter itself.
Rounds 251–252The commercial split
Subscriptions, entitlement signing and the release channel move into their own small service. From here on, the program facing the internet cannot mint an entitlement, and the program holding the key faces almost nothing.
Round 263Standing rules, born in shadow
"When this condition holds, do that" — except every rule starts in shadow mode, recording what it would have done against the real book until you have the evidence to arm it.
Round 288Closing an account closes it
Self-service deletion with no blockers, the username released the same minute, one anonymous row retained — and an order of operations that aborts whole rather than ever destroying half.
Rounds 289–317The palette is computed
The profit green and loss red are re-solved under colour-blindness simulation rather than picked by eye, and the theme family closes into a deliberate two-by-two of warm and cold, night and day.
Round 387Forty saved strategies vanish
Two concurrent writes shared one fixed temporary filename and spliced the store, and a read that treated corrupt and missing as the same fact reported it empty. Every store write is atomic per writer now, and a file that will not parse is preserved rather than replaced.
Rounds 389–403The stop lab, and the answer nobody wanted
Asked to mine the best stops, the measurement said a stop's return is not optimisable while its drawdown reduction transfers reliably — so the tool ships as a price list, not an optimiser.
Rounds 413–429Research bots
The unattended search becomes a program: bots that draw a set-up, mine it, prove the survivors and label what they promote — under an honesty floor no configuration can lower, and a guard on sixteen doors so a bot can reach no broker, no data provider and none of your own work.
Rounds 432–453The bar stops wearing its identity six times
The gradient came off the top bar: an identity asserted six times in one strip is a texture, not a signature. State is carried by position and one solid rule now. This site followed it.
Rounds 433–440A limit you can switch off is not a limit
Every limit a data vendor publishes now has a number, a ceiling nobody can raise past, and a sweep that checks the configuration against it — and every request, brokerage and data together, lands in one trail.
Rounds 455–463Four numbers that were not what they said
A review of the mining evidence found the noise floor's twin leaking the next bar's open, validation slices cut from a sampled curve, parents bred on the validation span, and one fixed holdout. Each was corrected, and the page's defaults stopped favouring the in-sample maximum.
Rounds 468–472The one number selection cannot have touched
A sealed tail at the end of every bot's tape, opened once, after the search is over — and a cost-stressed twin derived rather than re-run, which made each candidate cheaper to test honestly.
Rounds 473–484Pages become one, and screens become two
The Ordeal becomes a single picture; sectioned pages gain a unified arrangement; everything fits the window; two panes share one screen; and a right-click reaches the object under the cursor.
Rounds 485–502The funnel made honest
A deployability sweep found the unattended funnel's verdict on its own search space was no — so the benchmark is charged on both sides, the Ordeal's letter means something again, and a condition that never fires is something the cut can see.
Rounds 506–514Five things the grammar could not say
Votes, weighted scores, negation, a calendar axis, swings and market structure, rolling regression, an indicator on another symbol, pyramiding and risk sizing — each off by default, and a gate that asks the whole registry whether any indicator reads the future.
Rounds 516–534What your orders actually did
The replay: landmarks under the scrub bar, strips that share the book's window, the delay split into the machine's leg and the broker's, drift on a named basis, and an order's trail joined from three records.
Round 519Know your strategy
No logic tree had ever mentioned a stop. The explainer leads with the exits no condition controls — and found more than half the saved strategies had none.
Rounds 533–538One book, several hosts
The replay's book becomes one component: the Backtest page scrubs a test the way the Replay page scrubs a deployment, and the live and mining pages take its look.
Rounds 540–543The miner learns the vocabulary
All 113 indicators become drawable and the search learns votes, negation, position-state exits and peer instruments — while the classic grammar stays byte-identical, so every stored search still reproduces.
Round 543Where it stands
The tree this site is counted from: four programs, 332 test suites, and a round log 3.6 MB long. Still a personal project, still nothing for sale.

The workspace

Every screenshot on this site was captured from a demonstration instance running on synthetic data — series the application generated itself (the SYN-* and DEMO-* tickers visible in the frames), with no real market behind them. Where a number, a curve or a verdict is visible, it is the demonstration's arithmetic over those invented series: not a result, not a track record, and not a claim about anything.

What is on this site

The navigation groups the pages the same way: what belongs to the Mithraeum (the application), what belongs to the Agora (the community site), and what describes the platform standing behind both.

Section	What it covers
The Mithraeum — the application
Workflow	The path from an idea to a live position, and what must be true at each gate.
Research	Designing strategies, searching for them by the thousand, and trying to break the survivors.
Bots	Handing the search to an unattended researcher — and everything it is not allowed to touch.
Toolkit	Every mining and testing tool, one by one, and what each guards against.
Combining	Blending strategies into a book, rotation, and charging turnover honestly.
Live trading	The deployment ladder, the replay, and every order-level control in one place.
Data	One data-source selector with no fallbacks, the request gate, and working fully offline.
The Agora — the community site
The Agora	The landing, accounts and sign-on, the boards and support in screenshots, and closing an account for real.
Library	Strategy posts — published as logic, forked with attribution, adopted into the application. Results do not travel.
The platform behind both
Architecture	Four programs, three trust boundaries, what is not allowed to travel — and the Control Plane, which signs what the others verify.
Safeguards	Error handling, audit trails, diagnostics, monitoring and warnings — everything that watches for the quiet failures.
Privacy	What stays yours: local-first data, the bundle allowlist, and where the network is involved at all.
Workbench	Behind the scenes — the workbench that never ships, and the lessons that shaped everything else.

Please read this bit. This site describes a personal software project. It is not investment advice, not a recommendation to trade anything, and not an offer of any product or service. Nothing here should be taken as a claim about financial performance — the only figures anywhere on this site are a demonstration instance's own arithmetic over app-generated synthetic series, shown inside screenshots as illustrations of the tools, and no performance is claimed or implied by any of them. Software for testing trading ideas is a tool for reasoning about history; history is not a prediction. I am not a financial adviser or a broker, and nothing on this site should be relied upon as though I were.

A personal project. Not advice. Nothing for sale.

This site describes a personal engineering project, written and run by one person in their own time and published under the name Mithraeum Agora. There is no company behind it, no team and no other contributor. It is not a product and not a business. Nothing here is for sale — there is no account to open, nothing to buy, no subscription, no waiting list, and no service is being offered or solicited. Sending a message through the note form creates no customer, client or contractual relationship of any kind. The note form on the contact page is the way to reach me, and it is the only one.

Nothing on this site is investment advice, financial advice, tax advice, or a recommendation, solicitation or offer to buy or sell any security or financial instrument. I am not a financial adviser, a broker, an investment manager or a regulated firm, and nothing here should be relied on as though I were. If you are making decisions about money, take advice from someone qualified and regulated to give it.

Figures do appear on this site, inside screenshots, and none of them is a performance claim. Every one is a demonstration instance's own arithmetic over price series the application generated itself — synthetic data, with no real market behind it — shown to illustrate what the tools display. They are hypothetical and simulated: no capital was at risk, no orders were placed, and a result computed over history with the benefit of hindsight carries limitations that live trading does not forgive. Hypothetical results are not indicative of future returns, and past performance — real or simulated — predicts nothing.

No brokerage, market-data vendor or other company is named anywhere on this site, and where a name appeared inside a screenshot it has been redacted out of the image. Nothing here states or implies that any company is associated with this project, endorses it, sponsors it, supplies it or has reviewed it. None is, and none has.

What this site collects. Nothing, unless you write to me. There is no analytics, no tracking, no advertising, and nothing at all is loaded from another domain. If you use the note form it takes the name, address and message you type, stores them privately where only I can read them, and keeps them for up to a year before they are deleted — sooner if you ask, and you do not have to give a reason. Your IP address is not kept. One thing is stored on your own device: the colour theme you pick, remembered by your browser so the site does not change appearance every time you arrive. It is written only when you choose a theme, and it identifies nothing and nobody. The preference itself never leaves your browser, but the screenshots follow it, so the pictures your browser fetches from this site are the ones drawn in that palette. The contact page answers all of this in more detail.

Terms of use. This site is provided as is and as available, with no warranty of any kind, express or implied. It describes software under active development: anything here may be incomplete, out of date or simply wrong, and it may change or disappear without notice. Nothing on it is a contract, a term of service for any product, or a promise that anything described will be built, released or kept running. To the fullest extent the law allows, I accept no liability for any loss or damage arising from use of this site or from reliance on anything it says. Nothing here excludes or limits any liability that cannot lawfully be excluded or limited.

Trading involves risk of loss.