Prove the edge.
Never reveal the model.
Sign in to submit a strategy and mint a real MIZAN credential — a STARK anyone can re-verify, forever, while the strategy stays sealed. Open testing: the product is production-grade and complete; anyone can sign in and test the full flow, and real GPU proof mints are issued on request during the test phase.
▸ Launch window — minting is free · a real STARK, yours forever
New here? Create free account — just email and a password, no card, straight to submission.
Submit it. Prove it. Own the receipt.
Bring a strategy you've already built. It runs through MIZAN's locked risk gate inside a zero-knowledge proof: the verdict is public and re-verifiable forever, the strategy itself is never revealed. A pass makes it MIZAN-verified · Level I (Honest Execution); the luck-correction ladder below takes it toward Level II (Validation-Complete).
Want your strategy to never touch our servers? See the offline engine ↗ — same credential, proved on your hardware or a confidential enclave. The engine itself is distributed to verified quants on request.
Nobody was asked to test this — people in 13 countries ran live sessions anyway; a quant at an algorithmic-trading firm proved two full strategies end to end.
A rule-based strategy you can express as a weighted ensemble (Sma/Ema/Momentum/Donchian/Bollinger/Rsi). Transparent and fully in-circuit. Mints a Level I (Honest Execution) credential; the luck ladder below climbs toward Level II.
What happens next: your spec is checked instantly, then a real STARK proof runs server-side (typically 20–50 min — safe to close this tab). A failing strategy is refused honestly and costs nothing. Your logic is processed only for the mint, never committed to the proof.
A good backtest isn't enough. If you tried many variations and kept the best, its Sharpe is inflated — you found the luckiest, not the truest. The Deflated Sharpe (Bailey–López de Prado) corrects for how many you tried. MIZAN commits the N trials you declare inside the proof and binds your winner to be provably the best of them — so the deflation can't be gamed. It certifies the search you commit; pre-register your full sweep for a credential-grade N. Just tell us the search you ran:
⊘ Hosted mint: your strategy leaves your browser to a secure GPU for this proof. Fully trustless (strategy never leaves your machine) is the local SDK path.
The entire product, in one scroll.
This web app exists so you can understand and try MIZAN in your browser. The real product is entirely offline — the prover runs on your own machine, and your strategy never leaves it. Same engine, same credential, verifiable by anyone. This page is the showroom; the offline engine is the car.
See the offline engine ↗“A committed stream of positions, compounded on committed prices, after committed costs, cleared a pinned gate.”
Everything the product can and cannot do follows from what that sentence can express. Here it is, piece by piece.
Zero setup. The spec transits our GPU for the mint but is never committed into the credential. Perfect for learning what MIZAN does and minting a first credential in minutes — but your logic does briefly leave your machine.
The entire prover runs on your own machine at 127.0.0.1 — the strategy never leaves it, and we are completely blind to it. For a truly sensitive edge, this is the deploy. Slower on big data; identical credential.
Fail and you're refused honestly, with your numbers — it costs nothing and records nothing. Each class is hash-pinned and identical for everyone within it — the credential commits the exact parameters, and the verifier names the class (or flags a non-canonical gate, never guessing). Costs are committed inside the proof: 7bp fee + 3bp slippage per side is the protocol reference floor. Market-neutral mints run on the local prover for now (H100 path pends its next deploy) — same proof, more patience.
Passing once could be luck, so MIZAN proves the luck-corrections too — each answers a harder question than the last, all computed inside the proof so none of the numbers can be massaged. The top of the ladder is MIZAN Level II — validation-complete: the López de Prado/Bailey in-sample program and the Harvey–Liu/Hansen universe program, sealed in one credential.
Rung 5 has already judged its own maker: the first Level II seal ruled MIZAN's flagship NOT SIGNIFICANT (PSR 0.7226 < 0.95) — published on the wall, next to the passes. That is what makes the passes worth something.
A one-shot backtest seal proves your model is immutable and passed — not that its positions were free of hindsight. The no-lookahead guarantee is earned forward: the anchored track, where positions are committed before the bars exist, then the proof extends period after period. A growing anchored track is the closest thing to a cryptographic live record — the bridge to MIZAN Level III (pre-registered), which is roadmap, not shipped, and we say so. It is the credential an allocator should actually pay for.
A credential is only worth what its issuer refuses to certify.
Everything in this product follows from that sentence.
Submissions & credentials.
Live status of every proof. Once proved, issue the credential (free during launch) to unlock its public, re-verifiable page — then extend it into a growing track as new data accrues. The whole public history lives in the Registry.
Allocate to edges that survived honest testing.
Verified strategies across equities, commodities, rates, macro, gold, FX and digital assets — each cleared independent testing after real costs. Choose your rail: see every fill in your own account, or see continuous proofs instead of positions. The strategy stays sealed either way.
Every credential. Verify any of them.
A public index of every credential minted through MIZAN, each linking to a re-verifiable artifact. No allocation, no login, no custody. The strategy is never revealed; the proof always is.
All credentials — newest first
Every artifact re-verifies in your browser (Verify tab) or with the open desktop verifier — trusting no one, including us
We publish the method. Then we attack it.
MIZAN is a verification standard, not a marketing claim — so the standard itself is written down, versioned, and open to challenge. Below: the two-school framework, the coverage methodology, the adversarial audits we run against our own engine (including a real soundness hole we caught and closed), the boundaries we refuse to round up, and the working paper in preparation. Every claim here is the strongest true statement available, traceable to a proof artifact or a versioned document — where we cannot trace, we understate.
To our knowledge, the first verification standard where every claim is a proof. Backtest honesty is not one discipline but two — an in-sample program and a multiple-testing program — and a credential earns Level II only by satisfying both inside a single zero-knowledge proof, to our knowledge the first engine to do so. The strategy is never revealed; the verdict is recomputed in-circuit, so no fabricated curve can pass.
Coverage is the share of systematic strategies — weighted by prevalence among practicing quants — whose performance claims can be expressed and cryptographically proven by MIZAN. A verification company does not get to quote unverifiable numbers about itself, so every percentage we state publicly is pinned to a versioned note with a closure rule: covered means all of — logic expressible via the DSL or the sealed/black-box rail, a Merkle-rootable dataset for its assets/timeframe, an honest cost model for the class, and metrics + gate in-circuit.
Two honest numbers, because there are two surfaces. The engine rail is what the proving system covers; the hosted no-code app is what a user can mint without the SDK today. The app converges toward the engine number as UI ships. The remaining path to ~90% engine is dynamic cross-asset allocation and per-strike options — each named as in-build or roadmap, not claimed as shipped; the v3 step flipped point-in-time US equities to covered (test phase) on the licensed substrate.
v3 supersedes v2 (PIT US equities flipped to covered on the licensed substrate); v2 superseded v1 — which understated engine coverage by scoring the app UI's limits. We published the corrections with attribution rather than hide them. Weights are declared estimates, re-fit at ≥100 real submissions and at every era stamp. Challenges to taxonomy or weights are invited and incorporated with attribution.
Before an engine era is stamped, we run an adversarial audit against every arm of it — forged witnesses, journal-field omission, parameter tampering, rounding-direction abuse, overflow, seed and knob grinding. The most recent full-surface pass (2026-07-24, pre-v11-stamp) attempted 18+ distinct attack classes; five were real findings and were fixed, the rest refuted with recorded rationale. After fixes the core test suite runs 211/211 green. The v10 public surface was never touched — every fix landed in the unstamped v11 lane. This is a research artifact, and we present it with pride.
Two adversarial audit documents back this section — the full-surface v11 pre-stamp audit and the composed-PBO audit — each recording the fix, the test that pins it, and the refuted-attack rationale. We do not claim an audit proves the absence of all bugs; it proves we tried, hard and on the record, to break our own engine.
The restraint is the credibility. A MIZAN credential scores what happened on committed data — it does not claim the future, and it names its own residuals precisely.
A paper formalizing the cryptographic implementation of both validation frameworks — Deflated Sharpe / PBO / CPCV together with Harvey–Liu multiple-testing and Hansen's SPA, all computed in zero knowledge on committed inputs — is in preparation. We intend to submit it to a peer-reviewed venue. There is no title-as-published, no journal acceptance, no preprint id, and no co-authors to announce yet; when there are, they will appear here, traceable.
Reviewers and collaborators are invited. If you work on backtest overfitting, multiple-testing correction, or zero-knowledge proof systems, we want your critique before submission, not after. Reach us through the contact on the marketplace and homepage.
Every credential on the Registry re-verifies on your hardware, trusting no one — including us. Every methodology document is versioned and open to technical challenge; substantiated challenges are incorporated with attribution, as the coverage v1→v2 correction was. If you can find a way to pass the gate without an honest edge, or a way to make the engine claim something it should refuse, that is a contribution, and we will credit it. A verification company that cannot be checked is just another marketing claim.
ميزان · Prove the claim. Never reveal the method. — every credential re-verifiable, every method challengeable with attribution
Re-verify it yourself.
A MIZAN credential is checkable by anyone, with zero trust in us. Pick a path by how paranoid you want to be — every path computes the verdict on your hardware, never an API.
Step 3 resolves the credential's engine fingerprint against the append-only era registry: a credential from any published era (v6 → v11) verifies forever — superseded is never revoked. A fingerprint matching no published era reads UNRECOGNIZED ENGINE: the proof may be internally consistent, but it was not minted by any engine MIZAN has published, so treat it as untrusted. Recognition — not trust in MIZAN — is what the registry provides.
Download a single self-contained page — the entire verifier is embedded inside it. Open it (even with the internet off), drag a credential in, and it verifies on your machine in milliseconds. Nothing is ever uploaded. MIZAN-themed, drag-and-drop, done.
⤓ Download the offline verifier app1.5 MB · one HTML file · runs in your browser fully offline · the WASM engine, MIZAN's published engine-id list, and the canonical data roots are all baked in.
Nothing but your terminal and three public files: the verifier (a small source-available program), a credential, and the canonical data it's bound to. Your machine re-derives everything and prints the verdict. The strategy stays hidden.
chmod +x mizan-verifier-v10-macos-arm64
xattr -d com.apple.quarantine mizan-verifier-v10-macos-arm64 # unsigned — or right-click → Open once
./mizan-verifier-v10-macos-arm64 mizan_blackbox_fractional.bundle btc_4h.csv --aux mizan_blackbox_fractional_parts.json --track mizan_blackbox_fractional_track_head.json
[✓] zk receipt verifies (proof is real)
[✓] data root recomputed from YOUR csv matches
… every condition checked, in colour, on your machine …
What this proves: cleared the gate after costs, out-of-sample.
What it does NOT prove: future returns or live fills.
✅ INDEPENDENTLY VERIFIED — a hidden strategy cleared the MIZAN gate.
On Windows or Linux? Use the offline app above (any OS) or ③ in your browser below — it's just as trustless (the check runs locally in WebAssembly). Native builds for other platforms are on the way; you can also build the verifier from source.
③ In your browser (built-in) — nothing to install, works on any device. Honest boundary: you trust the verifier code we serve, so pin it — the module's SHA-256 is published; a swapped module fails the integrity check.
Load a credential's .bundle (download it from your dashboard). Your browser verifies the actual cryptographic seal and that the sealed journal matches the credential. A STARK — no trusted setup, nothing trusted.
Recompute a credential's committed data root from your own copy of the bars. A match means the credential is bound to exactly that data. A sample is pre-filled so you can try it right now.
Same engine, your machine.
The hosted studio is the showroom; this is the product. The full prover runs at 127.0.0.1 on your own hardware — your strategy never leaves it, and we are blind to it — and mints the same Level I (Honest Execution) credential, against the same era registry, re-verifiable by anyone. Mint locally, then publish just the credential here to join the public wall.
Minted on your own hardware? Your strategy never left your machine — upload just the credential bundle (plus its parts/track sidecars if it has them). The studio re-runs the independent era verifier on it; only honestly-minted, gate-passing credentials join the registry. Verification is free forever — listing is the paid service (free during launch).
How to submit a strategy.
MIZAN proves your strategy cleared an institutional risk gate — after costs, no lookahead, out-of-sample — without revealing the strategy. You get a portable, independently re-verifiable STARK credential. Two ways in — pick by what your strategy is.
rules or sealed model
gate · LdP suite · Harvey–Liu/SPA
crypto 4h & daily · 14 US ETFs · SPY · NVDA · 639 US names
already run-proven
New here? Every claim below is exactly what the engine does — no more. See a worked example ↗
Everything in this guide hangs off three Levels. Each is the strongest true claim available at its rung — and each states what it refuses to claim.
The first Level II seal ruled MIZAN's own flagship NOT SIGNIFICANT (PSR 0.7226 < 0.95) — published on the wall, next to the passes. That honest fail is the Standard working as designed.
Any strategy
Use this if your edge is real code — Python, C++, an ML model, order-book or alt-data signals. We never see or run your logic; you submit only the decisions it made.
- Run your agent offline on catalogue markets (1–8 that share a calendar) and export its positions: one row per bar-move, one column per market, leverages (1 = 100% long, −0.5 = 50% short, 0 = flat).
- Export its position stream: one integer per bar-move —
+1long,−1short,0flat. Length = (dataset bars − 1). - In 🕶 Any agent above: a public agent name, a private label (seals your commitment, never revealed), pick the markets in column order, upload the CSV, set the gross cap. Check the gate (free, seconds), then Mint. Or from code:
mizan.prove(df, markets=[…])— see the SDK.
These exact positions, sealed behind your model's commitment and compounded on the real committed prices at real costs, cleared (or failed) the pinned gate. Tamper with any period → the sealed track head changes → the credential fails. A fabricated returns curve cannot pass.
The gate marks risk against intrabar wicks. A constant-leverage directional signal long into a >12% bar trips the −12% worst-bar floor. Flatten during extremes or size down.
A one-shot backtest seal is self-reported on real prices. It proves your sealed, immutable model cleared the gate — not that the positions had no lookahead. That guarantee is earned by ⟳ Extending the track forward with an anchored head. The growing anchored track is what means something to an allocator.
Rule-based
A weighted ensemble of standard rules — runs fully in-circuit, transparently, no offline export. Up to 8 weighted rules from six primitives (Sma · Ema · Momentum · Donchian · Bollinger · Rsi) plus a vote threshold, regime gate, direction, leverage, vol-target.
On the DSL path you can also mint the Deflated Sharpe — and climb the full Level II ladder (PBO, CPCV, and the both-schools ValidationExt seal): declare the full set of configs you searched, and the circuit corrects your Sharpe for how many you tried — binding your winner to be provably the best of them, so it can't be gamed. Boundary, stated: the correction covers the N you commit (forward-only), not your entire search.
Your strategy runs on a provenance-pinned dataset — you can't upload your own prices (that's what stops fabricated data).
| key | market | source | bars |
|---|---|---|---|
| btc_4h | BTC · 4h | Binance | 12,917 |
| btc_daily | BTC · daily | Binance | 1,096 |
| spy | SPY · S&P 500 · daily · 1997→ (test phase) | our data provider (licensed) | 7,184 |
| us_<ticker> · us_pit30_daily | 639 US single names + the 30-stock PIT universe panel (delisted names retained in panels) · test phase | our data provider (licensed) | rules path |
Provenance: sourced by MIZAN and root-pinned — the credential binds the exact bytes, so the data can't be swapped or curated mid-proof. Independent data-signing (exchange/vendor-attested) is the next provenance milestone. More assets on request — any single asset or index we can source clean OHLC for is ~15–30 min to pin. Dynamic multi-stock selection isn't supported (needs point-in-time data with delisted names); single-name and index credentials are honest, a dynamic-universe one is not yet.
An honest map of the strategy universe against the proof engine. The ordering isn't marketing — it's the ladder of proof primitives: each tier needs exactly one more thing to be provable than the tier above it. The core claim never changes: a committed stream of positions, compounded on committed prices, after committed costs, cleared a pinned gate. Everything follows from what that sentence can and cannot express.
| tier | strategy families | status | what it takes |
|---|---|---|---|
| 1 | Directional & timing on a priced series — trend, momentum, breakout, mean-reversion, seasonality, vol-regime timing; any ML or discretionary logic reduced to a sealed position stream | ✓ live | Nothing — this is the engine today. The logic stays sealed; only the decisions are proven. |
| 2 | Multi-asset books — CTA portfolios, cross-sectional long/short, stat-arb & pairs | ◐ per-sleeve | One credential per leg works now. The portfolio-level claim — the diversification an allocator actually buys — needs multi-instrument credentials (a positions vector against a price matrix). Engineering, not new cryptography. |
| 3 | Carry & financing legs — perp funding harvest, cash-and-carry basis, FX carry, borrow-aware shorting | roadmap | Commit a funding/borrow-rate series beside the price series; P&L becomes position × Δprice + position × funding accrued. Pure circuit arithmetic — the cheapest real expansion. |
| 4 | Nonlinear payoffs — options: vol selling, spreads, tail hedges, dispersion | roadmap | The unlock: an option book is linear in the contracts' own prices. Commit the chain as instruments and it's tier 2 again — plus a margin model and heavy pinned data. The big build; zero new proof theory. |
| 5 | Execution alpha — market-making, HFT, queue-position edges | bounded | Provable only conditional on a declared fill model, or from an anchored live track of real fills. A backtest's counterfactual fills cannot be proven by anyone — physics, not a circuit limitation. |
| 6 | Non-priced assets — private credit, distressed, activist | out of scope | No bar-by-bar price series exists, so there is nothing to compound. The only path is attested live cash flows — a different trust model than "math, not trust." |
Per the published methodology (docs/COVERAGE_METHODOLOGY.md, v3): the engine rail covers roughly 80% of systematic strategies today (this no-code app: ~45%, converging as UI ships) — the v3 step: point-in-time US equities flipped to covered when the licensed US-equity data substrate went live and the first real proof verified on it — and the published roadmap lifts the engine to roughly 90%. We publish the remaining 10–15% gap instead of hiding it: tier 5's counterfactual fills and tier 6's unpriced assets are beyond any zero-knowledge system, ours included — the ceiling is the credibility.
A credential is only worth what its issuer refuses to certify. We would rather prove half the universe honestly than claim all of it and be wrong where it counts — the same discipline as the cost floor and the pinned gate.
Proving is free during the launch window — a real STARK, yours forever. A failing strategy is refused honestly and costs nothing. Costs: committed inside the proof and printed on the credential — protocol reference floor 7 bps fee + 3 bps slippage per side, checked at verification.
You never trust MIZAN. Download the source-available verifier and your bundle, run one command, watch every condition check while the strategy stays hidden. Fully trustless path = the local SDK.
Structural-break (CUSUM/SADF) and HRP/denoising arms ship in the same v11 surface — see docs/V11_VALIDATION_COMPLETE_SPEC.md for every arm, its bar, and its boundary. Honest boundary that never moves: every multiple-testing arm is forward-only-N — it corrects for the trials you committed, not your entire search history. Level III pre-registration is the roadmap answer.
- ✓ Rule-based strategies — up to 8 weighted rules from 6 indicators (Sma, Ema, Momentum, Donchian, Bollinger, Rsi) + regime gate, vol-target, leverage
- ✓ Any agent, sealed (era v12) — Python, C++, ML, LLM: you submit only the positions it took, fractional sizing, long/flat/short, 1–8 markets per book from the catalogue; the logic never leaves your machine
- ✓ Long, flat, and short positions
- ✓ 668 catalogue markets — BTC ETH SOL BNB XRP DOGE (4h & daily, Binance), 14 US ETFs on one calendar, SPY, NVDA, 639 US single names (licensed survivorship-free feed), plus a 30-stock PIT panel for the DSL rail. Every series carries its sha256 and canonical root in the catalogue. NIFTY & gold withdrawn 2026-07-28 pending an authoritative NSE source — provenance is the product
- ✓ Both schools of backtest honesty (Level II · era v11) — the López de Prado/Bailey program (DSR, PBO, CPCV, PSR, MinBTL, triple-barrier labels, uniqueness, structural breaks, HRP) + the Harvey–Liu/Hansen program (Bonferroni/Holm/BHY, SPA, Romano–Wolf), in-circuit
- ✓ Extend forward — grow an anchored, timestamped track over time
- ✅ Your own dataset — two paths. (1) Request the market: any asset or index with a clean authoritative source is ~15–30 min to pin canonically — request a dataset →. (2) Own-data tier (SDK, on request): mint on any market's data you commit — the kit ships watermarked under NDA during the test phase; verifiers check with their own copy (--any-data) — loudly labeled submitter-committed, never canonical. The hosted menu stays provenance-pinned: that is what stops fabricated prices.
- ✅ Sealed position sizing and multi-market books — shipped 2026-10-14 in the Any-agent form and the Python SDK (era v12). Cross-market allocation is one book, one proof, cost floor in-circuit
- ◔ Per-strike options — data-gated
- ✗ Live trading & fills — we prove backtests on committed history, never live execution. Always.
- ✗ High-frequency — refused on principle
This is the honest map. If a row isn't marked ✓ Supported today, we don't claim it — that discipline is the product. What we can't prove, we say out loud.