# MintID > MintID is a sovereign, permissionless proof-of-stake Layer-1 blockchain for privacy-preserving, KYC-backed identity credentials — for people and for AI agents (Know Your Agent, KYA). Approved issuers vouch for holders after a real KYC; holders keep their own keys and prove claims (age, assurance grade, agent scope) with zero-knowledge presentations. No raw KYC data, PII or presentation logs ever touch the chain. Every page on this site is prerendered, dependency-free HTML, and every page has a markdown mirror at `/index.md` (advertised in-page via `link rel="alternate" type="text/markdown"`). Machine-readable surfaces: [llms-full.txt](https://mintid.net/llms-full.txt) (the whole site as one markdown document), [sitemap](https://mintid.net/sitemap.xml), [Atom feed](https://mintid.net/en/blog/feed.xml), [verifier-service OpenAPI](https://mintid.net/openapi/verifier-service.v1.yaml). ## Protocol & network - [MintID — KYC-backed identity for AI agents](https://mintid.net/en): KYC-backed identity for AI agents. A sovereign proof-of-stake Layer-1 for reusable, privacy-preserving identity credentials — no PII on-chain. - [Technology — protocol-level identity](https://mintid.net/en/technology): How MintID works: protocol-level identity on Cosmos SDK — zero-knowledge presentations, root-based status, 10-second proofs and holder self-revocation. - [Know Your Agent (KYA) — verifiable AI agent identity](https://mintid.net/en/agent-kyc): Know Your Agent (KYA): verify that an AI agent is backed by an accountable, KYC-verified human — without revealing who. The trust layer for agentic AI. - [Tokenomics — hard cap, staking, burns](https://mintid.net/en/tokenomics): The MintID token in plain language: a hard cap, declining issuance, protocol burns, staking and issuer bonds. It secures the network — never buys identity. - [Roadmap — a staged, self-financed path to mainnet](https://mintid.net/en/roadmap): The MintID build sequence: corpus v2.0 frozen after a published economic-viability audit, a staged launch — verified identity first, funded recourse on a published criterion — and financing through the full EU MiCA Title II path. - [For issuers — become a KYC credential issuer](https://mintid.net/en/issuers): Approved KYC organisations issue reusable credentials, publish signed status roots and lock a slashable bond — never exposing the holders they vouch for. - [For verifiers — verify credentials without storing PII](https://mintid.net/en/verifiers): Request 10-second zero-knowledge presentations bound to your challenge and policy, keep only a minimal decision record — never the proof or the person. - [For validators — stake on the identity Layer-1](https://mintid.net/en/validators): Run permissionless proof-of-stake consensus on CometBFT. Validators check cryptographic evidence only — never passports, biometrics or KYC files. - [The protocol — three specifications, one trust rail](https://mintid.net/en/protocol): MintID is defined by three specifications: SPEC-1, the identity Layer-1; SPEC-2, agent KYC; SPEC-3, consensual disclosure. Available on request. - [Whitepaper](https://mintid.net/en/whitepaper): The MintID whitepaper: a privacy-preserving proof-of-stake Layer-1 for KYC-backed identity for people and AI agents — architecture to roadmap. - [About MintID — public trust infrastructure for identity](https://mintid.net/en/about): Public trust infrastructure for identity: approved issuers vouch for people; the chain stores no documents and logs no checks. Private by construction. - [FAQ — zero-knowledge identity, credentials & the token](https://mintid.net/en/faq): Answers about MintID: zero-knowledge presentations, reusable KYC credentials, what the chain stores, key recovery, agent KYC (Know Your Agent) and the token. - [Contact](https://mintid.net/en/contact): Reach the MintID team: general enquiries, KYC credential issuers, verifiers and proof-of-stake validators. Specifications available on request. - [Blog — identity, KYA and reusable KYC explained](https://mintid.net/en/blog): Educational articles on privacy-preserving identity: Know Your Agent (KYA), reusable KYC, zero-knowledge credentials and how MintID compares to other identity chains. - [Where the numbers come from](https://mintid.net/en/sources): Every market figure on this site, with its primary source and how we label it. Vendor projections flagged; protocol fees and token figures never published prematurely. - [Glossary — Know Your Agent (KYA) & zero-knowledge identity terms](https://mintid.net/en/glossary): Plain-language definitions: Know Your Agent (KYA), agent KYC, zero-knowledge presentations, reusable KYC, holder binding, x402, Web Bot Auth and the MintID network roles. - [Docs — role manuals for the MintID network](https://mintid.net/en/docs): Downloadable role manuals for the MintID network — holder, issuer, validator and verifier SDK — plus the whitepaper and the published findings of the economic-viability audit. Versioned, dated, and honest about what runs today and what is still design. ## SDK documentation - [Integration overview — MintID verifier SDK docs](https://mintid.net/en/sdk): One verifying core, three ways to consume it: embed the Python SDK, self-deploy it as a service, or talk to your own service through a transport-only client. - [Getting started — MintID verifier SDK docs](https://mintid.net/en/sdk/getting-started): Verifier obligations before any code, the current installation channels, and the honest status of the pipeline and the proof engine. - [Python SDK (embedded mode) — MintID verifier SDK docs](https://mintid.net/en/sdk/python): mintid-verifier-sdk: a frozen public surface, one decision entrypoint, five infrastructure ports — and a proof engine pinned inside the wheel. - [Service mode & the OpenAPI contract — MintID verifier SDK docs](https://mintid.net/en/sdk/service-mode): The same SDK wrapped in a thin first-party HTTP service you deploy yourself, behind a frozen, versioned OpenAPI contract. - [TypeScript client — MintID verifier SDK docs](https://mintid.net/en/sdk/typescript-client): @mintid/verifier-client: a transport-only client for Node backends — zero runtime dependencies, no cryptography, no policy. - [Conformance & versioning — MintID verifier SDK docs](https://mintid.net/en/sdk/conformance): "Every SDK behaves identically" as a CI gate: the cross-language conformance suite, semver promises, and the release pins every artifact carries. - [Reason codes — MintID verifier SDK docs](https://mintid.net/en/sdk/reason-codes): The closed decision vocabulary, byte-identical across the Python SDK, the HTTP contract and every client — producible codes, handling, and the reserved set. - [ADR-0001 — KYC trust model — MintID verifier SDK docs](https://mintid.net/en/sdk/adr-0001-kyc-trust-model): An open architecture decision record: should the evidence vocabulary behind assurance grades A1–A4 be a bespoke MintID verdict contract, or a mapping onto an external assurance standard? Both options, the comparison, and the evidence that will settle it. - [ADR-0002 — SDK packaging & distribution — MintID verifier SDK docs](https://mintid.net/en/sdk/adr-0002-packaging): Accepted: the verifier SDK ships as versioned platform wheels with the Rust proof engine compiled in and pinned at build time — so a substituted or drifted engine cannot happen through any normal installation path. - [ADR-0003 — Multi-language strategy — MintID verifier SDK docs](https://mintid.net/en/sdk/adr-0003-multilanguage): Accepted: one verified core in Python; TypeScript and PHP as transport-only clients of a self-hosted service behind a frozen OpenAPI contract. Why reimplementing the pipeline per language was rejected permanently. - [bIP-0001 — Verifier service contract v1 — MintID verifier SDK docs](https://mintid.net/en/sdk/bip-0001-verifier-service-contract): The freeze of the verifier-service OpenAPI contract at v1: three operations, a closed reason-code vocabulary, and the invariants the freeze locks in for every client in every language. - [MCP server — MintID verifier SDK docs](https://mintid.net/en/sdk/mcp-server): @mintid/verifier-mcp: the three frozen contract operations as Model Context Protocol tools over stdio — transport-only, zero external runtime dependencies, inside your own perimeter. ## Blog - [How we grade identity — and how we keep it fresh](https://mintid.net/en/blog/grades-follow-eidas): What each MintID assurance grade A1–A4 certifies, mapped onto eIDAS, ISO/IEC 29115, ETSI TS 119 461, NIST IAL and the EU anti-money-laundering regimes — and why freshness is a second axis (bands F1–F4) rather than a decaying grade, with re-verification periods taken from the standards. - [The first live network: running, not written](https://mintid.net/en/blog/first-live-network): MintID stood up its first live network — a single-validator chain and the verifier service, deployed behind TLS from a reproducible bring-up package — and drove the first end-to-end test through it: proof-backed reads, live ten-second challenges, a fixed-slot decision record and a complete MCP session. Protocol-code defects found: zero. Alongside it, what the v2.0 re-freeze leaves fixed in the tokenomics — the hard cap, the ratified bands, the price-independent launch gate, the protocol cuts and the post-emission plan — now reads as closed policy, not promise. - [We audited ourselves before anyone asked](https://mintid.net/en/blog/we-audited-ourselves): Crypto projects publish code audits after the token is sold. MintID put itself through a full economic-viability audit — solvency of every actor, survivability of the project — before genesis, against its own frozen corpus, with the authorship on the cover: Conectia PRO, a related-party service provider to the protocol. The answer came within days: a full re-freeze of the corpus as v2.0. The verdict, stated whole: a qualified opinion, a demand thesis corroborated against independent sources, and five critical findings with five written answers. The report is downloadable, unedited. - [Verification is now a tool call](https://mintid.net/en/blog/verification-is-a-tool-call): The MintID client family grew a third member — not another language, a protocol. An MCP server exposes the three frozen verifier-service operations as tools any agent framework can call, with the same closed reason-code vocabulary: a rejection stays a decision, now readable by an agent. - [The graduated-knowledge slot: an identity profile for x402 and Web Bot Auth](https://mintid.net/en/blog/x402-web-bot-auth-identity-profile): Between an anonymous payment and a doxxed buyer sits the slot only a zero-knowledge proof can fill: human-backed, in scope, unrevoked — and unrevealed. MintID has drafted the standards-track transport profile that fits it, with machine-readable schemas and a validation suite. - [AI writes the evidence. It doesn’t get to decide.](https://mintid.net/en/blog/ai-writes-the-evidence): AI screeners are collapsing the cost of KYC — which is good for a credential rail. But a screener produces evidence, not verdicts. The MintID issuer plane now enforces that division by construction: enumerated checks with provenance, or a named rejection — and no field anywhere that could carry a provider-asserted grade. - [The pay-per-use web is here. It needs Know Your Agent.](https://mintid.net/en/blog/x402-pay-per-use-web-needs-identity): Cloudflare’s Monetization Gateway makes agents pay per call over x402. Payment and fleet signatures are solved — the accountable human behind the long tail of agents is not. Why zero-knowledge KYA is the missing half of the agentic web. - [Implementing clients: where the rubber meets the road](https://mintid.net/en/blog/implementing-clients): The multi-language strategy behind the MintID SDKs is decided and locked into the spec: one audited verification core, embedded in Python — and TypeScript and PHP clients that carry no cryptography and no policy, built against a verification service you host yourself. Why thin clients are the strongest guarantee we could ship. - [The MintID SDKs are in development: TypeScript, PHP and Python](https://mintid.net/en/blog/embedded-not-hosted): Development of the MintID verifier SDKs has started — TypeScript, PHP and Python — and we expect the first builds tested and working in a couple of weeks. Inside every binding, the same non-negotiables: nine acceptance checks, a ten-second proof lifetime and zero policy knobs. - [MintID vs ERC-8004: trustless agents still need accountable humans](https://mintid.net/en/blog/mintid-vs-erc-8004): ERC-8004 makes agents discoverable and their work verifiable — but its identity is a transferable NFT, its reputation is Sybil-prone, and recourse is out of scope. Where the standard stops, and how human-backed credentials fill the gap. - [Scope an agent can prove, axis by axis](https://mintid.net/en/blog/agent-scope-axis-by-axis): Agent authorisation today is a plaintext scope inside a token: all or nothing. A scope structured along five provable axes applies selective disclosure to authorisation itself — the merchant learns the limit, not the mandate. - [One KYC, every agent: the economics of amortised accountability](https://mintid.net/en/blog/amortised-accountability): Per-check verification re-pays KYC at every counterparty. Amortisation — one human verification backing N agent credentials — changes the cost structure of trust. The five flows a sovereign identity rail earns from. - [Identification, not surveillance](https://mintid.net/en/blog/identification-not-surveillance): Identifying an agent once, paid and consented, is categorically different from holding a handle that tracks its human forever. How pay-per-disclosure, pseudonym churn and on-chain receipts make surveillance structurally impossible. - [Money before identity: how disputes settle without ever learning who](https://mintid.net/en/blog/money-before-identity): Most disputes want money back, not a name. How a dispute rail built on self-custodied escrow, anonymous arbitration and due process settles claims without unmasking anyone — and why that protects both sides. - [The agentic identity problem: no human at the keyboard](https://mintid.net/en/blog/agentic-identity-problem): Every identity system of the last twenty years assumed a human at the keyboard. AI agents break that assumption — and six concrete failures follow. Why the accountability-versus-privacy binary is the one to solve first. - [Reusable KYC explained](https://mintid.net/en/blog/reusable-kyc-explained): Reusable KYC explained: verify once with an approved issuer, then prove age, assurance grade or status anywhere in zero knowledge — with no PII on-chain. - [MintID vs Concordium](https://mintid.net/en/blog/mintid-vs-concordium): How MintID and Concordium differ: identity architecture, anonymity revocation vs zero-knowledge presentations, compliance models and token design. - [What is Know Your Agent (KYA)?](https://mintid.net/en/blog/what-is-know-your-agent): What Know Your Agent (KYA) means, why AI agents need verified human backing, how KYA differs from KYC, and how zero-knowledge agent credentials work. ## Legal - [Privacy policy](https://mintid.net/en/privacy-policy): How the mintid.net website handles data. The protocol itself writes no KYC, personal data or identity logs on-chain — this page covers the website only. - [Terms of use](https://mintid.net/en/terms): Terms of use for the mintid.net website: informational material about a research-stage protocol — not an offer, solicitation or financial advice.