# MIZAN · The second ledger > MIZAN is the second ledger of the economy. Payment networks record what was paid; MIZAN records whether it was earned. First call: check(subject="try-me") gives a signed ALLOW in under a second. Then check whoever you are about to pay; proceed only on ALLOW. Every answer carries a token that verifies offline against the published key. REFUSE is an answer, not an error: no record met your rule; forward its proof request and the check flips to ALLOW when they prove. To pass checks yourself: prove(...) puts a record where there was none; claim proven, method private. Free; no key needed. A bar in words: require(words). Everything else: more(). Payment rails prove an agent paid. MIZAN proves it earned it. Built on Counted (the Counted Claim Standard); MIZAN is its reference implementation. x402, AP2 and ACP move money; MIZAN decides whether it should move, and the verdict travels with the payment. - **The one call:** `curl https://studio.mizan.market/api/check/try-me` (`try-me` is the sandbox subject, always ALLOW) · MCP `check(subject, rule)` at https://studio.mizan.market/mcp · A2A https://studio.mizan.market/.well-known/agent-card.json - **Verify offline:** the reply's `token` is Ed25519-signed; keys at https://studio.mizan.market/.well-known/mizan-keys.json. Python `mizan.verify_token(token)` (`pip install mizan-sdk`) · TypeScript `verifyToken(token, { keys })` from `mizan-agent-tools` (`npm install mizan-agent-tools`). - **One map:** https://mizan.market/.well-known/mizan.json · verdict format: https://mizan.market/verdict/ · error codes: https://mizan.market/verdict/codes/ · changelog: https://mizan.market/verdict/changelog/ · status: https://mizan.market/status/ - **Live:** Watch the ledger move: GET https://studio.mizan.market/api/public/live (SSE) · /api/public/live/recent - **Measures:** Set your own measure: POST /api/measures (compile, read back) then /api/measures/publish - **Build:** Build on the record: https://mizan.market/developers/ (read, write, require; SDK, middleware, examples) - **One line, plain text:** https://mizan.market/developers/index.txt (one line per party; the rail kit as text: https://mizan.market/integrate/rail/index.txt) - **Release:** After ALLOW, request a release receipt: POST /api/release (signed, verifies offline) - **Adopt:** Adopt in one call: POST https://studio.mizan.market/api/adopt {template: escrow-release-gate|marketplace-listing-filter|x402-seller-with-verdict|vault-allocation-gate, name, what, url, stack, point} · bars: https://mizan.market/bars/ · templates: https://mizan.market/templates/ (GET the same URL for the full schema) - **Bars:** The bar library: https://mizan.market/bars/ — require what another bar requires in one line - **App:** Your record as an app: https://mizan.market/app/ (what you earned · what is owed · the proven world) · agents: GET https://studio.mizan.market/api/me with your key - **Gate:** Set the rule money must pass, judged live: POST https://studio.mizan.market/api/gate/judge {text: plain words, measure: not_payee|me|named:|two|multi_origin, direction: pay|hire|back|release} → rule read back + endings + signed rows (yes/no per record, verifiable offline) + the open ask; page: https://mizan.market/app/ - **Your record:** GET https://studio.mizan.market/api/me (key) → what you proved, what you meet, who relied on you; GET /api/owed → value waiting on a yes - **The standard:** Counted, open: specification, verdict format, bindings, JSON Schemas and conformance vectors at https://github.com/muaviamohammed/counted (`make conformance` runs every vector). - **Errors** have one shape: `{"error": "", "code", "message", "request_id", "next"}` (the verdict routes nest the same fields: `{"error": {"code", "message", "request_id", "next"}}`); `next` is the one action that fixes it. The first ledger records what was done; MIZAN, the second ledger of the 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, steps proven. ## 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 - **Integrate end to end (for coding agents):** https://mizan.market/integrate/ · the one file: https://mizan.market/MIZAN_INTEGRATE.md - 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/` (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: `pip install mizan-sdk` · TypeScript SDK: `npm install mizan-agent-tools` - 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 - [The stack](https://mizan.market/stack/): all 43 live layers (Record, Authorization, Settlement, Economy, Network, Autonomy, on one Ledger), each with what it does, how it works and a live link - [Who it's for](https://mizan.market/#who): 30 parties in eight groups (people, move money, invest, run markets, hire, build agents, web3, rules and assurance), each with its problem and a free first step - [Solutions](https://mizan.market/solutions/): agent marketplaces, payment rails, funds and labs: the bar you would write and where it is enforced - [Playground](https://mizan.market/playground/): run a live check and verify its signature in your browser - [Trust center](https://mizan.market/trust/): keys, ledger, timestamps, offline verifier, security - [Architecture](https://mizan.market/architecture/) · [Changelog](https://mizan.market/changelog/) - [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.