Accept accountable agents
This page is for a business whose HTTP service, paid or not, should accept software agents only when an accountable principal stands behind them. Your service becomes the verifier of record: it runs the MintID verifier under its own origin and its own request key, checks a presentation from each agent, and keeps its own ledger. The protocol charges nothing to verify; operators price their own services.
Most of the pieces below are not released yet. This page names them so you can plan, and says what runs today.
| Piece | Status |
|---|---|
| The identity leg on x402 paid routes (the x402 middleware) | In production |
| The OAuth bridge for ordinary APIs | A draft (0.1.0) |
| Domain-control evidence | Published by MintID as bIP-0005 v1. The kit writes it. |
| The verifier identity commitment | Issued by the issuer for your exact origin from your responsible person's identity verification, at grade A2 or above. |
| The refusal with the onboarding route | Shipped by MintID; the kit carries it. Built and not yet released. |
| The verifier service | MintID publishes a signed verifier-service image with each public release. |
The verifier kit, zadq verifier-kit | Built and not yet released; the name is provisional |
The reference application, relying-party-enrolment | Built and not yet released; the name is provisional |
| The managed deployment | Being prepared. |
| Admission to production | Under MintID's published admission policy for the single-node production chain, through ZadQ. It opens with the published verifier obligations; you then follow the request on the dashboard. |
The words on this page
- Bounded agent: software that acts for a person within a scope, a cap
and an expiry that person set when the agent was minted.
- Human-backed agent credential: what a bounded agent presents; it
proves an identity-verified person answers for the agent, without revealing who.
- Accountable principal: the person who answers for the agent.
- Relying party: a service that decides whether to accept an agent.
- Verifier of record: the relying party in its role on the network. The
decision is yours: challenges are bound to your registered exact origin, so nobody can decide for you.
The verifier kit
The kit runs on your machine; its home is the Apache-2.0 tools repository. Status: Built and not yet released; the name is provisional.
- **
zadq verifier-kit init** produces, locally: the request-signing key (it
never leaves your machine), the domain-control evidence file you publish at your origin, your verifier's registration signed by your own operator account (ZadQ never holds it), the configuration of the verifier service, a policy preset per scope bundle, and the OAuth bridge configuration (a draft, 0.1.0) for ordinary APIs beside the x402 middleware. The kit writes your evidence in bIP-0005 v1. Its set-up takes your operator account, because the evidence names it.
- **
zadq verifier-kit check <origin>** replays the conformance set against
your 402 response and your challenge route.
The verifier itself is the MintID verifier SDK in service mode, beside your service. The kit configures it; it does not replace it.
Your domain-control evidence
Your domain-control evidence is a small public JSON document, in MintID's format bIP-0005 v1. It names your exact origin, your request key and the operator account that registers your verifier. It carries no private key and no personal data.
It has six members, and only these:
v 1
origin your exact origin, e.g. https://api.example.com
verifier_id_hex "derived" on the permissionless tier, else 64 lowercase hex
request_key_pub_hex your request key's public half, 64 lowercase hex
operator_account the bech32 account (mintid1…) that signs your registration
issued_at_unix an integer
Any other member gets the document refused.
The digest is SHA-256 over the document's RFC 8785 canonical form, not over the bytes you serve. Serve the canonical bytes the kit writes, and the two are the same.
Serve it at your origin, byte for byte, as application/json with no content encoding, at the path the specification fixes:
/.well-known/mintid-verifier
Or publish its digest as a DNS record:
_mintid-verifier.<host> TXT "v=1; digest=<64 hex>"
That is the only grammar. ZadQ's admission request checks the file at your origin, so publish the file even if you also publish the record.
The document names your operator account, so: create the operator account, write the evidence, serve it, check it, then register or request admission.
A registered origin is never freed. A wrong digest can be corrected later by a renewal with a fresh document, but get it right the first time.
The kit and the SDK are free. ZadQ pays a referral share per person your door sends who keeps a paid plan; the plans page says how it works.
The policy your service asks for
Your verifier sends a challenge with a policy. The agent proves:
- human-backed at the grade you set or above;
- scope includes your counterparty form and category;
- a per-transaction limit at least the cap you want proven;
- the pairwise pseudonym (always asked) and unexpired.
A presentation lives ten seconds and is bound to your exact origin, your verifier id, your request key, the nonce, the policy and the chain height. It proves the predicates at the moment it is made; it is not a proof of how recently the principal was verified.
The enrolment pattern
- Your customer signs in to your service and chooses Connect an agent.
Your verifier issues a ten-second challenge with your policy.
- The agent presents. On accept, you store
{customer_id, pseudonym, name, cap, approval_rule}. The pseudonym is stable for this agent at your service and meaningless anywhere else.
- Every later request carries a fresh presentation: the x402 middleware on
paid routes, or the OAuth bridge (a draft) on ordinary APIs, which turns an accepted presentation into a short-lived session credential.
- Your service checks the decision, looks up the pseudonym, applies your
ledger and the cap, and applies the approval rule: auto, or ask the customer.
- When the principal revokes the agent, from the holder or at the issuer,
the next presentation fails with a closed reason and you mark the profile inactive. On the single-node production chain the published bound between a revocation and the first refusal is 245 seconds.
The ledger, the cap and the approval rule are yours. The pseudonym can be personal data at your service: keep it under your own data-protection rules.
The refusal that sends a person to verify
When your verifier refuses an agent nobody answers for, the refusal carries the route to verification: {operator, url, accepts, reason}. It is the same on x402 (402), on the OAuth bridge (401; the bridge is a draft, 0.1.0) and through the MCP server.
{"operator": "<the operator's name>", "url": "<your door's onboarding URL>",
"accepts": ["<profile>"], "reason": "<closed reason>"}
url is your door's onboarding URL, exactly as your dashboard shows it under Your door. reason is one of a closed list. Your service decides on every request under its own policy; nothing in your flow waits on ZadQ.
The kit carries this refusal. Built and not yet released.
What your service learns, and never learns
| Your service learns | Your service never learns |
|---|---|
| The predicates its policy asked for | Who the accountable principal is |
| A pseudonym for the agent, for your service only | Which other agents the principal runs |
| The decision, under your origin and key | Anything about the agent's dealings with other businesses |
The dispute retention record
Specified, and not yet running: every agent presentation carries an encrypted reference to the agent that only its issuer and the network's Foundation together can open, and only for a recorded claim; your verifier keeps it, unreadable, for the claim window, so a claim reaches an agent that no longer answers. The network's dispute process that uses it is specified, not built.
Beside its decision record, your verifier keeps for each agent it accepts the challenge it issued, the agent's pseudonym, the presentation with its encrypted reference, and what the proof was checked against. It deletes that record when the claim window closes, unless a claim filed on it is open; then it keeps it until that claim closes. The record is never published and never written to the network's public record. The claim window is your verifier's configuration, with a provisional default of 90 days, until the network governs it.
No record, no acceptance. If your verifier cannot write the record, it refuses the agent with the reason code dispute_retention_unavailable: the verifier could not keep the record a claim would need, so it refused the agent. That is an operator problem on your side, never the holder's fault: treat it as an alert and fix the store, and the holder may retry later with a fresh challenge. Keep the store durable and back it up like your verifier's nonce store.
The record holds the agent's pseudonym and the presentation: say in your privacy notice what you keep and for how long, and delete it at the end of the window. In the managed deployment being prepared, the record is yours, like the decision log.
The reference application
**relying-party-enrolment, in the tools repository; status: Built and not yet released; the name is provisional. A small relying party your developers run in an hour: a customer sign-in stub, the Connect an agent** screen (name, cap, approval rule), the profile table keyed by the pseudonym, the per-agent ledger and cap, the ask-the-customer approval, an x402 paid route and an ordinary route behind the OAuth bridge (a draft), and a revoked agent failing with a closed reason. Its README walks the pattern above.
Admission to production
Admission to production opens with the published verifier obligations. On the single-node production chain, ZadQ will then file your admission request with the chain's operator under MintID's published admission policy, and show you the turnaround on your dashboard. The policy asks for your responsible person's identity verification at grade A2 or above, sets a target of five working days, and keeps a public admissions log. The tier is permissionless by default, and a business is admitted on request.
ZadQ collects what the policy asks (your origin, the evidence file, the responsible person's identity verification and your acceptance of the verifier obligations) and files the request. The decision is the chain operator's. ZadQ records it and never makes it.
The fee is the network's, set by its admission policy. ZadQ never charges it. Your registration is signed by your own operator account, which ZadQ never holds.
On the public testnet
On MintID's public testnet you can register your verifier yourself, from your own operator account, with idchaind tx verifier self-register. The account that signs owns the record for good, and only that account can renew it, every 180 days on the testnet. The testnet faucet funds the account. The testnet's fee has no value and is burned; read it on the chain before you sign. The verifier id is derived from your origin alone:
SHA-256("mintid/verifier/self-registered-id/v1" ‖ 0x00 ‖ origin)
MintID's public guide Becoming a verifier → Self-registration on the public testnet, step by step gives the whole path. A testnet reset erases the record; register again on the new chain. Nothing minted on the testnet carries weight.
Running it
Run it yourself with the verifier kit: your request-signing key is generated on your machine and never leaves it. Or, in a managed deployment being prepared, ZadQ runs it under your origin and you can rotate its key and export its logs at any time.
To accept presentations, your verifier runs MintID's verifier service beside your service. MintID publishes it as a signed container image with each public release. Refusing an agent works without it.
Pin the image by digest, not by tag: the digest is in the release's signed manifest. Check its signature with cosign against MintID's release key, published with the release, and check its SBOM attestation, signed with the same key. MintID's public guide Verify a release describes the whole check.
The release's compose file runs a full node beside the service. The trusted header source must be a node you run, never the network operator's endpoint.
Your request key stays in your key store. The service signs through it, and ZadQ never receives it.
Every route you do not gate keeps working as it does today: the gate is your own policy, applied by your verifier.
Further reading
- MintID's integrator page, Accept accountable agents (not published yet: the link is added here when it is).
- The offer for businesses: Accept accountable agents
on the main site.
The platform
ZadQ is built on the MintID identity network and operated by the CONECTIA group, the network's first implementer, on the same published terms as any issuer: the same admission, the same bond on the network, the same status rules, verifiable by anyone on the network's public record. We disclose this relationship wherever it is relevant.