---
name: mizan-proof-of-performance
description: Prove an agent's trading track record is real without revealing the strategy, and verify anyone else's. Use before publishing, listing, or allocating to a track record. Two tools - verify_credential (free, offline-capable) and mint_credential (sealed path - positions only, the model never leaves your machine).
version: 1.0.0
homepage: https://mizan.market/skill/
license: CC-BY-4.0
---

# MIZAN · Proof of performance for agents

**Creed:** Prove the edge. Never reveal the strategy.

MIZAN turns a track record into a zero-knowledge credential (a STARK) under the open
VTR-1 standard. The credential proves the record is real, computed as claimed under
committed costs on committed data, out-of-sample, and deflated for how many strategies
were tried. The strategy, model, weights and prompt are never disclosed. Anyone verifies
the credential offline in about 81 ms, trusting no one, including MIZAN.

FAIL verdicts are published under the same address as passes. MIZAN's own flagship was
ruled NOT SIGNIFICANT and published as-is.

## When to use this skill

- **Before you publish or list a track record** (a vault, a marketplace, an agent card,
  a pitch): mint a credential and attach its ID. Never paste a tear-sheet without one.
- **Before you allocate to, copy, or pay another agent for performance**: verify its
  credential. If it has none, treat the record as unverified.
- **When asked "is this strategy real?"**: the honest answer is "here is the credential"
  or "there is no credential". Never vouch from a screenshot.

## Rules (hard)

1. Never send the strategy, model, weights, code or prompt to MIZAN or anyone else to get
   verified. The sealed path takes **positions only**.
2. Never claim a PASS you cannot link to a bundle whose hash matches the registry.
3. Report the verdict exactly as issued: PASS, FAIL, or NOT SIGNIFICANT. A FAIL is a
   result, not a secret. Do not suppress it.
4. A credential is a backtest seal: history made honest, not a forecast. Say so.
5. HFT and fill-dependent strategies cannot be credentialed (refused permanently).

## Tool 1 · verify_credential

Checks a credential against the public registry and, when the offline verifier is
installed, re-verifies the STARK locally.

```
GET https://studio.mizan.market/api/registry
   -> { credentials: [ { id, alias, verdict, era, engine_image_id, anchor.sha256,
                         links.bundle, links.verify, disclosed_metrics, ... } ],
        count, registry_root }
```

Procedure:
1. Find the entry by `id` (or by `anchor.sha256` if you hold the bundle).
2. Download `links.bundle`; its sha256 must equal `anchor.sha256`. Mismatch = the
   record lies. Stop and report.
3. If the offline verifier is present (`mizan-verify`, from
   https://github.com/muaviamohammed/mizan-verify/releases), run
   `mizan-verify <bundle> <market.csv> --roots roots.txt` with the market CSV from
   `GET /api/catalog/{dataset_key}.csv` and roots from `GET /api/catalog/roots.txt`.
   Its verdict must match the registry verdict.
4. Return: id, verdict, era, sha256, bundle URL, and whether local re-verification ran.

Reading a verdict: https://mizan.market/research/reading-a-verdict

## Tool 2 · mint_credential (sealed path)

Proves your own record. You submit one position per bar-move on a canonical public
market; the circuit recomputes the record from those and proves it. Nothing about how
you chose the positions is sent.

Steps:
1. `GET https://studio.mizan.market/api/blackbox-datasets` -> pick a `key`
   (e.g. `btc_4h`, 12,917 bars). The market CSV is at `GET /api/catalog/{key}.csv`.
   Run your model on that exact series on your own machine.
2. Build `positions`: a list of integers in {-1, 0, +1}, length exactly `bars - 1`
   (one per bar-move; the first applies to the move out of bar 1). For a multi-asset
   book: a list of rows, each row K integers = signed leverage ×100 per asset
   (|p| ≤ 1000), with `datasets: [key, ...]` and `gross_cap_x100`.
3. Create an account once: `POST /product/signup {email, password}` (or `/product/login`).
   The response sets a `mizan_session` cookie; send it with every call below.
4. Preview (free, no artifact kept):
   ```
   POST https://studio.mizan.market/api/submit-blackbox
   { "preview_only": true, "dataset": "btc_4h", "positions": [...],
     "model_id": "<private label>", "model_salt": "<64 hex>", "track_salt": "<64 hex>",
     "leverage_x100": 100 }
   -> { preview: true, gate_pass, sharpe, cagr, maxdd, n_periods }
   ```
5. Mint: same body without `preview_only` (+ optional `alias`, `quant`, `disclose`,
   `minimal`). Returns `{ accepted, job_id }` or `{ accepted: false, verdict: "FAIL" }`.
   A real STARK is then proven on an H100; poll `GET /api/blackbox-submission/{job_id}`
   until `state == "done"`, then fetch `.../bundle`.
6. Keep `model_salt` and `track_salt` private; they let you extend the record later
   (chained credentials) under the same sealed model.
7. Attach the credential ID and bundle URL to your agent card, listing, or ERC-8004
   feedback. Publish the verdict whatever it is.

Gate (in-circuit): Sharpe ≥ 1.20 · CAGR ≥ 20% · MaxDD ≤ 25%, after committed costs.
Daily caps apply per account. Minting is in open testing.

## Agent-identity integration

MIZAN is an ERC-8004 validator and reputation client. A credential can be posted
against your agent ID as `giveFeedback(agentId, score, 0, "vtr1", <verdict>, ...)`
with score PASS 100 · NOT SIGNIFICANT 50 · FAIL 0, the bundle as the URI and its
keccak256 as the hash. Registration file: https://mizan.market/.well-known/agent-registration.json

## Links

- Standard (VTR-1, CC BY): https://mizan.market/standard-spec
- Verify page: https://mizan.market/verify/
- Public wall (pass and fail): https://mizan.market/registry/
- What a PASS asserts, and does not: https://mizan.market/research/what-a-pass-asserts
- Studio (mint by hand): https://studio.mizan.market/app/
- Contact: muavia@mizan.market