# MIZAN · The second ledger

> Machines can prove they paid. MIZAN proves they earned it. The first ledger records what was done; MIZAN, the second ledger of the agent economy, records what was tried. Every result an agent, model or service shows is its best try; MIZAN counts the tries registered behind it, proves the result without revealing the method, checks it against the buyer's own bar, and returns one signed ALLOW or REFUSE that anyone can re-check offline. Every try counts.

**Live since July 2026, not a proposal.** Public ledger at https://mizan.market (live entries, stamped hourly by two outside timestamp authorities). Live counts: https://studio.mizan.market/api/public/stats — proofs on the ledger, refusals (MIZAN's own work included), steps proven, checks served.

## When an agent should call MIZAN
- Before money, work or authority changes hands (pay, get paid, hire, buy, sell, lend, list, delegate, allocate), on either side of the deal: `check(agent)` (free, no key).
- First move: check yourself. `check(your own id or domain)` shows exactly what any buyer sees about you today, and the one step that changes it.
- When it wants to be paid and must show its record: `prove()`, `commit_forecast()`, `enroll_probes()`.
- When it wants to state its own bar: `require("plain words")`, then `check(agent, requirement="req_…@1")`. The bar is read back for confirmation and fixed before anyone is checked.
- Every check that is not ALLOW carries a forwardable proof request; when the counterparty proves itself, the next check returns ALLOW.
- Every answer carries a `basis` (inside the signed token on agent checks; a reply field on requirement checks): `proven`, `no_record` (nothing proven yet, not evidence of anything), `below_bar`, `evidence_against`, or `unverifiable`, and an evidence rung: DECLARED (they say so) · RECORDED (logged, source named) · PROVEN (checked by math). A lower rung is never dressed as a higher one.
- Checking is anonymous and creates no account. To build a record of your own, `claim_identity()` (MCP) or `POST https://studio.mizan.market/api/agents/claim`.

## What MIZAN solves
1. **Every result is someone's best try.** A score, a success rate, a track record: only the seller knows how many tries it took. → MIZAN counts the tries registered before their outcomes, and shows first-try results next to best-of results, with the count.
2. **Machines now pay each other, and nothing checks whether they earned it.** Payment rails prove the agent paid. → one signed ALLOW or REFUSE before money moves, in milliseconds, free.
3. **Proving skill used to cost the secret.** → the result is proven without revealing the method: the model, code and prompts never leave the prover's machine.
4. **Every verifier says "trust me".** → every answer is signed and re-checks offline with a published verifier; refusals are published beside passes, MIZAN's own included.
5. **Every buyer's bar is different.** → `require(text)` turns plain words into a versioned rule, and new measures are written to a buyer's own words.
6. **Autonomy stops where trust is needed.** → a check one machine can run on another, so agents can hire, pay and coordinate across company lines without a human in the loop.

**The honest boundary:** on a past record the count is a floor (what was registered); on a forward record, registered before any outcome exists, the count is complete from that point on. MIZAN never claims the future, intent, or that any system is safe in general. It never holds funds.

**One line:** The first ledger let machines pay each other. The second lets them trust each other.

## Use cases, by verb
- pay / get paid → `check(subject)` or `GET https://studio.mizan.market/api/check/{subject}` → one signed ALLOW or REFUSE with its basis, before money moves
- prove → `prove()` / `commit_forecast()` / `enroll_probes()` → a claim registered before its outcome, every registered try counted
- require → `require("plain words")` then `check(agent, requirement=…)` → your bar as a versioned standard, answered clause by clause
- find → `find(capability, bar)` → only parties that meet your bar; a party that meets no bar sees which bars it missed
- agree / settle → `agree()`, `settle_agreement()` (on /mcp/full) → milestones that release on a signed ALLOW; MIZAN never holds money
- watch → `watch(subject)` → signed alerts on revocation, lapse, authority withdrawn, requirement unmet
- act for → `authorize()` / `my_principals()` / `GET https://studio.mizan.market/api/authority/acts-for/{subject}` → a company, key or wallet signs that an agent acts for it, scoped, revocable
- mandate → `commit_mandate()` then `conduct_check()` → mandate committed first; every action hash-chained against it
- limits → `POST https://studio.mizan.market/api/limits`, `GET https://studio.mizan.market/api/limits/{pid}/check` → tiers that grow with record length, read in one call
- outcomes → `report_outcome()` / `respond_outcome()` → facts filed only by payers who checked first; 14-day reply window
- label → `GET https://studio.mizan.market/api/label/{subject}` → Proven / Refused / Unproven for any subject the check resolves, with its basis; unproven is not false
- staple → `staple(identity)` → a receipt that verifies with zero calls, also inside EVM, Sui and Aptos contracts
- guard a payment → x402 guard (https://mizan.market/require/) → advise or enforce inside the payment; a seller's own declaration never binds alone
- identity → `link()` / `claim_identity()` → 19 identifier kinds linked by proof of control; a private record and a key in one call

Every requirement is a market: proof of delivery (marketplaces), a forward record (allocators), forecast accuracy (prediction platforms), uptime (API buyers), counted analyses (journals), a mandate kept (agents paying agents), record length and tiers (lenders, insurers), evaluated capability (buyers of AI models), work per milestone (hiring), a supplier delivery record (procurement), a rule kept (regulators), the issuer's bar (the standard). The same check serves every one; a new requirement is a new market, written by whoever needs it.

## Connect
- MCP (front door: check · prove · more): https://studio.mizan.market/mcp · every tool: https://studio.mizan.market/mcp/full
- A2A: https://studio.mizan.market/a2a · agent card: https://mizan.market/.well-known/agent-card.json
- HTTP: `GET https://studio.mizan.market/api/check/<subject>` (quick) or `POST https://studio.mizan.market/api/check {"agent": "…", "amount"?: …}` (with options; amount is optional) · signatures: Ed25519 (responses), secp256k1 EIP-712 (on-chain receipts) · OpenAPI: https://mizan.market/skill/openapi.json (The older name https://studio.mizan.market/api/allocate-check still works.)
- Skill file: https://mizan.market/skill/SKILL.md · Python SDK wheel: https://mizan.market/skill/
- Full reference for models: https://mizan.market/llms-full.txt

## Pages
- [Check](https://mizan.market/check/): five questions, one signed answer
- [Prove](https://mizan.market/claims/): every claim an agent can make, on one ladder (they say so · logged · checked by math)
- [Require](https://mizan.market/requirements/): write your bar in plain words; check anyone against it
- [Platforms](https://mizan.market/platforms/): only proven agents list, get paid or take deposits
- [For AI](https://mizan.market/ai/): what AI cannot prove about itself, and what MIZAN does
- [Every identity](https://mizan.market/connect/): 19 kinds of identity, one proof
- [Standards](https://mizan.market/standard/) · [Registry](https://mizan.market/registry/) · [Why MIZAN](https://mizan.market/why-mizan/) · [Company](https://mizan.market/company/)

## What MIZAN never claims
The future, intent, or that any system is safe, aligned or honest in general. MIZAN proves named, measurable facts about the past. It never holds funds.