# Privi Quantum Ledger (remote · privi-ledger.onrender.com)

Quantum-sealed audit logs for AI agents (ML-DSA-87, SHA3-512), plus Privi Guard and trust passports.

- Trust score: 68/100 (medium)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- remote · `privi-ledger.onrender.com`: 68/100 (this document), [markdown](https://verifymcp.io/servers/canoydario847-cloud-privi-ledger/privi-ledger.md), [page](https://verifymcp.io/servers/canoydario847-cloud-privi-ledger/privi-ledger)

## Channel facts

- Endpoint: `https://privi-ledger.onrender.com/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.12.1`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Endpoint Security**: 57/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (passport_revoke).
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 72/100
  - AI-judged instruction clarity (good).
  - Tool/resource definitions use about 11762 tokens (~97/item across 121 items; 121 tools + 0 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 33/100
  - Stability observed for 10 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 99/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 98% of tool parameters carry a description.
  - Structured output schemas are declared (7% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 10 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 122 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the Privi Quantum Ledger MCP server?

Privi Quantum Ledger is a hosted endpoint at https://privi-ledger.onrender.com/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http canoydario847-cloud-privi-ledger 'https://privi-ledger.onrender.com/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "canoydario847-cloud-privi-ledger": {
      "url": "https://privi-ledger.onrender.com/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "canoydario847-cloud-privi-ledger": {
      "type": "http",
      "url": "https://privi-ledger.onrender.com/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.canoydario847-cloud-privi-ledger]
url = "https://privi-ledger.onrender.com/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "canoydario847-cloud-privi-ledger": {
      "type": "remote",
      "url": "https://privi-ledger.onrender.com/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add canoydario847-cloud-privi-ledger --url 'https://privi-ledger.onrender.com/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  canoydario847-cloud-privi-ledger:
    url: "https://privi-ledger.onrender.com/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "canoydario847-cloud-privi-ledger": {
      "Transport": "http",
      "Url": "https://privi-ledger.onrender.com/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add canoydario847-cloud-privi-ledger -t streamable-http -u 'https://privi-ledger.onrender.com/mcp'
```

### Other

```json
{
  "mcpServers": {
    "canoydario847-cloud-privi-ledger": {
      "type": "http",
      "url": "https://privi-ledger.onrender.com/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-04 (score 68, +1)

No change was recorded against any check on this day. Stability & Change Management went from 27 to 30. That category is still filling its 30-day observation window: 8 days of observed history at the previous scan, 9 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-02 (score 67, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-30 (score 66, +1)

No change was recorded against any check on this day. Stability & Change Management went from 10 to 13. That category is still filling its 30-day observation window: 3 days of observed history at the previous scan, 4 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-28 (score 65, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-27 (score 64, 0)

- [security] The server rewrote its instructions, which are the text every model session reads
- [security] New tool “seal_revoke”, which the server declares destructive
- [security] New tool “supplier_cert_revoke”, which the server declares destructive
- [functional regression] Schema quality: 9472 → 11762
- [functional improvement] Stability: unverified → 0.03
- [functional] Server version: 0.12.0 → 0.12.1
- [functional] Server version: 0.10.1 → 0.12.0
- [functional] New tool “ai_act_check”
- [functional] New tool “ai_act_export”
- [functional] New tool “ai_act_register”
- [functional] New tool “ai_act_system_save”
- [functional] New tool “ai_act_verify_export”
- [functional] New tool “qledger_block”
- [functional] New tool “qledger_entry_proof”
- [functional] New tool “qledger_seal”
- [functional] New tool “qledger_status”
- [functional] New tool “qledger_verify_chain”
- [functional] New tool “seal_content”
- [functional] New tool “seal_list”
- [functional] New tool “seal_verify”
- [functional] New tool “supplier_cert_verify”
- [functional] New tool “supplier_certs”
- [functional] New tool “supplier_proof_decide”
- [functional] New tool “supplier_proof_inbox”
- [functional] New tool “supplier_proof_submit”
- [functional] New tool “supplier_requirement_create”
- [functional] New tool “supplier_requirement_get”

### 2026-10-26 (score 64)

First indexed and scored.

## MCP tools (121)

### `privi_token_market` (~126 tokens)

PRIVI token market

PRIVI on Base: price, how much PRIVI and USDC the Privi swap desk holds (so whether a swap can fill),
any Uniswap v3 / Aerodrome pools, and optionally a swap quote. Every paid Privi tool also accepts PRIVI. Free.

Input parameters:

- `amount` (string): Amount to swap in (USDC for buy, PRIVI for sell), e.g. '25'
- `side` (string): Optional swap quote: 'buy' (USDC -> PRIVI) or 'sell' (PRIVI -> USDC)

### `ledger_pricing` (~27 tokens)

Ledger pricing

List Privi Ledger tools, what each costs, and how to get an organization key.

### `ledger_check_receipt` (~53 tokens)

Check a receipt

Confirm that an action receipt exists in the ledger and when it was recorded. Reveals no action contents. Free.

Input parameters:

- `entry_hash` (string, required): 64-character hex entry_hash returned when the action was recorded

### `ledger_audit_stream` (~111 tokens)

Audit a stream

Check whether an agent's action log is intact: entry count, time span, action and failure
counts, head hash, and where tampering broke the chain if it did. Does not reveal the actions
themselves. Paid per call via x402.

Input parameters:

- `org_id` (string, required): Organization ID, e.g. org_1a2b3c4d5e6f7a8b
- `stream_id` (string, required): Stream ID, usually the agent's name

### `ledger_record_action` (~181 tokens)

Record an agent action

Append an action to the organization's tamper-evident log. Returns the entry with its
entry_hash receipt. Requires the organization API key.

Input parameters:

- `action_type` (string, required): One of: tool_call, data_access, data_change, payment, message, decision, approval, error, other
- `actor` (string, required): Who acted: agent name, model, or user on whose behalf
- `details`: Optional structured details (JSON object, under 16 KB)
- `outcome` (string): One of: success, failure, pending, blocked
- `resource` (string): What was acted on: URL, file, record ID, account
- `stream_id` (string, required): Stream to append to, usually the agent's name, e.g. 'billing-agent'
- `summary` (string, required): One-line description of what was done

### `ledger_read_stream` (~71 tokens)

Read a stream

Read your organization's entries in a stream, oldest first, with an integrity check of the
whole stream. Requires the organization API key.

Input parameters:

- `after_seq` (integer): Return entries after this sequence number
- `limit` (integer): Max entries to return
- `stream_id` (string, required): Stream ID

### `ledger_list_streams` (~24 tokens)

List streams

List your organization's streams with entry counts. Requires the organization API key.

### `ledger_compliance_report` (~155 tokens)

Compliance report

Audit-ready report of your AI agents' activity for a period (SOC 2 evidence, security
questionnaires, AI-regulation record keeping): actions by type, failures, human approvals,
log integrity, on-chain status, and findings. The report's hash is anchored on the Privi
blockchain so it cannot be edited later without detection. Requires the organization API key.

Input parameters:

- `since`: Start of period, ISO 8601 UTC (e.g. 2026-10-01T00:00:00Z). Omit for all history
- `streams`: Only these streams; omit for all
- `until`: End of period, ISO 8601 UTC. Omit for now

### `ledger_report_pdf` (~77 tokens)

Compliance report PDF

A finished PDF of a sealed compliance report, for auditors and customers. Returned as base64
(pdf_base64) and as an embedded PDF resource; also downloadable at /reports/<report_id>.pdf with the
organization key. Requires the organization API key.

Input parameters:

- `report_id` (string, required): report_id returned by ledger_compliance_report

### `ledger_verify_report` (~75 tokens)

Verify a report

Check that a compliance report is unaltered: recomputes its hash, confirms Privi Ledger issued it,
and checks the anchor on chain (Base, until the Privi chain mainnet). Free; no key needed.

Input parameters:

- `report` (object, required): The 'report' object exactly as received from ledger_compliance_report

### `ledger_signup` (~73 tokens)

Sign up

Create a Privi Ledger organization on the free plan and get its API key (shown once; store it).
Free plan: up to the monthly entry limit, all tools included. Upgrade any time with
ledger_upgrade_pro. No key needed to sign up.

Input parameters:

- `organization_name` (string, required): Your company or project name

### `ledger_plan` (~33 tokens)

Plan and usage

Your plan, entries used this month, the limit, and when a Pro plan renews. Requires your organization API key.

### `ledger_upgrade_pro` (~51 tokens)

Upgrade to Pro

Buy 30 days of Privi Ledger Pro (unlimited entries) for your organization, paid in USDC on Base
via x402. Each call adds 30 days. Requires your organization API key.

### `gov_ai_usecase_save` (~273 tokens)

Save an AI use case

Add or update an entry in your agency's AI use case inventory (OMB M-25-21). Every change creates a
new version and is written to your tamper-evident 'ai-inventory' log. Requires the organization API key.

Input parameters:

- `actor` (string, required): Who is making the change (person or agent)
- `merge` (boolean): Merge into the existing record (true) or replace it (false)
- `use_case` (object, required): AI use case record in OMB M-25-21 reporting fields. Required: use_case_id, name, stage (pre_deployment|pilot|deployed|retired), high_impact, purpose, outputs, sourcing (in_house|vendor|both), involve…

### `gov_ai_inventory` (~44 tokens)

AI use case inventory

Your agency's AI use case inventory: the current version of each record. Requires the organization API key.

Input parameters:

- `use_case_id`: One use case; omit for all

### `gov_ai_inventory_check` (~94 tokens)

Check inventory readiness

Flags what an OMB M-25-21 review would flag before you submit: missing required fields, PII without a
Privacy Impact Assessment, and high-impact AI in pilot or deployment missing any minimum risk practice
(testing, impact assessment, independent review, monitoring, operator training, fail-safe, appeals, public
feedback) or without a recently active activity log as monitoring evidence. Requires the organization API key.

### `gov_ai_inventory_export` (~89 tokens)

Export public inventory

Machine-readable CSV of your publicly releasable AI use cases (for publishing at agency.gov/ai), with its
SHA-256 sealed on chain (Base, until the Privi chain mainnet) so the published file can be proven unaltered. Requires the
organization API key.

Input parameters:

- `include_withheld` (boolean): Include use cases marked withhold_from_public (internal copy)

### `gov_ai_verify_export` (~57 tokens)

Verify a published inventory

Check that a published AI inventory file is exactly what the agency exported from Privi Ledger, and
return its on-chain seal. Free; no key needed.

Input parameters:

- `csv_text` (string, required): The exact CSV file contents as published

### `gov_pqc_classify` (~115 tokens)

Classify an algorithm

Classify cryptographic algorithms as quantum-vulnerable (RSA, ECDH, ECDSA, EdDSA, DH, DSA, MQV),
post-quantum (ML-KEM, ML-DSA, SLH-DSA), hybrid, symmetric/hash, or unknown. Free.

Input parameters:

- `algorithms` (array, required): Algorithm or cipher-suite names, e.g. 'RSA-2048', 'ECDHE-RSA-AES256-GCM', 'X25519MLKEM768'

### `gov_pqc_system_save` (~202 tokens)

Save a system's crypto inventory

Record the cryptographic inventory (CBOM) of one system for post-quantum migration. Every change creates
a new version and is written to the agency's tamper-evident 'pqc-inventory' log. Scanners and agents can
submit results directly. Requires the organization API key.

Input parameters:

- `actor` (string, required): Who made the change (person, scanner or agent)
- `system` (object, required): System record: system_id, name, bureau, owner, high_value_asset, high_impact, sensitive_until_year, fedramp_cloud, notes, assets [{asset_id, kind (key_establishment|signature|encryption|symmetric|has…

### `gov_pqc_inventory` (~36 tokens)

Crypto inventory

Current cryptographic inventory of your systems. Requires the organization API key.

Input parameters:

- `system_id`: One system; omit for all

### `gov_pqc_plan` (~105 tokens)

Post-quantum migration plan

Prioritized post-quantum migration plan: every quantum-vulnerable asset ranked (High Value Assets,
high-impact systems and long-lived sensitive data first; key establishment before signatures), with its
deadline (key establishment Dec 31 2030, signatures Dec 31 2031), recommended NIST replacement, progress
metrics, and findings (missed deadlines, TLS below 1.3, no target dates, unrecognized algorithms).
Requires the organization API key.

### `gov_pqc_export` (~63 tokens)

Export sealed CBOM and plan

Export the full cryptographic inventory (CBOM) and migration plan as one JSON document for OMB, the
CIO or auditors, with its SHA-256 sealed on chain (Base, until the Privi chain mainnet). Requires the organization API key.

### `gov_pqc_verify_export` (~58 tokens)

Verify a CBOM export

Check that a CBOM and migration-plan document is exactly what was exported from Privi Ledger and return
its on-chain seal. Free; no key needed.

Input parameters:

- `document` (object, required): The 'document' object exactly as exported

### `ledger_handshake_offer` (~236 tokens)

Offer a handshake

Start a Privi Handshake: a two-sided record of a dealing with another company's agent
(payment, data transfer, delivery, agreement). Recorded in your log now; when the other company
accepts, both logs hold matching entries and the pair is sealed on chain (Base). Requires your
organization API key; the other company must also use Privi Ledger.

Input parameters:

- `action_type` (string, required): One of: tool_call, data_access, data_change, payment, message, decision, approval, error, other
- `actor` (string, required): Who is acting on your side
- `counterparty_org_id` (string, required): org_id of the other company (must be on Privi Ledger)
- `details`: Terms as structured data (amounts, quantities, dates)
- `expires_hours` (number): Hours the other company has to respond
- `resource` (string): Invoice, order, dataset, contract or other reference
- `stream_id` (string, required): Your stream to record it in, usually your agent's name
- `summary` (string, required): What is being agreed or done between the two companies

### `ledger_handshake_inbox` (~36 tokens)

Handshake inbox

Handshakes sent to and from your organization, newest first, with their terms and status.
Requires your organization API key.

### `ledger_handshake_accept` (~105 tokens)

Accept a handshake

Accept a handshake addressed to your organization: records the same terms in your log, confirms
it in the other company's log, and seals the matched pair on chain (Base). Requires your
organization API key. Read the terms first with ledger_handshake_inbox.

Input parameters:

- `actor` (string, required): Who is accepting on your side
- `handshake_id` (string, required): hs_... ID from the offer
- `stream_id` (string, required): Your stream to record it in

### `ledger_handshake_reject` (~65 tokens)

Reject a handshake

Reject a handshake addressed to your organization; the other company's log records the rejection.
Requires your organization API key.

Input parameters:

- `handshake_id` (string, required): hs_... ID from the offer
- `reason` (string): Why it is rejected (shared with the other company)

### `ledger_handshake_verify` (~61 tokens)

Verify a handshake

Public check of a handshake: both companies, status, whether both matching log entries still exist,
and the on-chain seal. Never reveals the terms. Free; useful for disputes and audits.

Input parameters:

- `handshake_id` (string, required): hs_... handshake ID

### `passport_issue` (~130 tokens)

Issue a Privi Passport

Issue a Privi Passport: a signed, on-chain-anchored trust credential for your agent or organization,
scored 0-1000 (grade A-E) from verified history, integrity, anchoring, reliability, human oversight,
compliance reports and confirmed handshakes. Show it to counterparties; they verify it free with
passport_verify / passport_gate. Valid 30 days. Free on Pro/enterprise; free-plan organizations pay
per passport via x402. Requires the organization API key.

Input parameters:

- `stream_id`: Issue for one agent (stream). Omit for the whole organization

### `passport_verify` (~99 tokens)

Verify a Privi Passport

Check an AI agent's Privi Passport before trusting it: Privi signature, content unaltered, not expired or
revoked, anchor on chain (Base), and a live re-score of the agent right now (so tampering after issue
is caught). Free; no key needed.

Input parameters:

- `passport`: The 'passport' object exactly as issued
- `passport_id`: pp_... ID, or omit and pass the passport document

### `passport_gate` (~166 tokens)

Gate on a Privi Passport

One-call allow/deny decision before transacting with another AI agent: verifies its Privi Passport and
applies your minimums, returning the reasons. If you send your organization API key the decision is
recorded in your own tamper-evident log as due-diligence evidence. Free.

Input parameters:

- `min_grade`: Minimum grade A-E (alternative to min_score)
- `min_score` (integer): Minimum current score 0-1000
- `passport_id` (string, required): pp_... ID presented by the other agent
- `purpose` (string): What you are about to do with this counterparty (recorded in your log if you send your key)
- `require_anchored` (boolean): Require the passport to be anchored on chain (Base)

### `passport_list` (~28 tokens)

List your passports

Your organization's issued passports with score, grade, expiry and revocation. Requires the organization API key.

### `passport_revoke` (~63 tokens)

Revoke a passport

Revoke one of your passports (e.g. an agent was retired or compromised). Verifiers see it immediately.
Requires the organization API key.

Input parameters:

- `passport_id` (string, required): pp_... ID
- `reason` (string): Why (shown to verifiers)

### `kya_check` (~194 tokens)

KYA: check a wallet

Know-Your-Agent for blockchains: is this wallet operated by an audited AI agent, and how trustworthy is it
right now? Resolves the address to its organization and live Privi Passport and returns allow/deny with
reasons, plus a Privi-signed attestation (valid 60 min) you can cache. For chains, DeFi protocols, exchanges,
stablecoin issuers and x402 facilitators. Free; send your organization key to log the check as evidence.

Input parameters:

- `address` (string, required): 0x wallet address about to send or receive a transaction
- `min_grade`: Minimum grade A-E
- `min_score` (integer): Minimum current Passport score 0-1000
- `purpose` (string): What the transaction is for (recorded in your log if you send your key)
- `require_signed` (boolean): Require wallet ownership proven by signature (not just declared)

### `kya_challenge` (~65 tokens)

KYA: challenge for a wallet

Step 1 of binding a wallet to your Privi Passport: get a message to sign with that wallet (EIP-191
personal_sign). Valid 30 minutes. Requires the organization API key.

Input parameters:

- `address` (string, required): 0x wallet address your agent controls

### `kya_bind_wallet` (~144 tokens)

KYA: bind a wallet

Step 2: bind the wallet to your organization's Privi Passport so its transactions pass KYA checks. With a
wallet signature the binding is *proven*; without one it is only *declared* (most checkers require proven).
Requires the organization API key.

Input parameters:

- `address` (string, required): 0x wallet address
- `challenge_id`: From kya_challenge
- `label` (string): Friendly name, e.g. 'treasury-agent hot wallet'
- `signature`: 65-byte hex signature of the challenge message by the wallet
- `stream_id`: The agent (stream) that uses this wallet; omit for the whole organization

### `kya_wallets` (~27 tokens)

KYA: your wallets

Wallets bound to your organization and how each was proven. Requires the organization API key.

### `kya_unbind_wallet` (~48 tokens)

KYA: unbind a wallet

Remove a wallet from your Passport (rotated or compromised key). KYA checks deny it immediately. Requires the organization API key.

Input parameters:

- `address` (string, required): 0x wallet address

### `mandate_create` (~232 tokens)

Create a spending mandate

Draft a Privi Mandate: the human's signed permission for your agent to spend, with a budget, per-payment cap,
allowed payees and expiry. Returns sign_url: send it to the human, who reads the plain-English terms and signs
once with their wallet (free, no transaction). Nothing can be spent until they sign. Requires the organization API key.

Input parameters:

- `agent_wallet`: 0x wallet the agent pays from (optional)
- `days` (integer): Days until the mandate expires (1-365)
- `max_per_payment_usdc`: Cap per payment; defaults to the total
- `max_total_usdc` (string, required): Total budget in USDC, e.g. '250'
- `payees`: Allowed payees (0x addresses or domains); omit for any
- `principal_wallet` (string, required): 0x wallet of the human who authorizes the spending
- `purpose` (string, required): What the agent may spend on, in plain words
- `stream_id` (string, required): The agent (stream) that will spend, e.g. 'shopping-agent'

### `mandate_check` (~127 tokens)

Check a payment against a mandate

For merchants, payment facilitators and counterparties: did a human authorize this AI agent to pay you this
amount? Verifies the human's wallet signature, status, expiry, per-payment cap, remaining budget and payee list,
and returns allow/deny with reasons plus a Privi-signed attestation. Free; no key needed.

Input parameters:

- `amount_usdc` (string, required): Payment amount in USDC
- `mandate_id` (string, required): mdt_... ID the agent presented
- `payee` (string, required): Who is being paid: your 0x address or domain

### `mandate_spend` (~185 tokens)

Spend under a mandate

Call before each payment: checks the mandate and, if allowed, deducts the amount from the budget and records the
payment in the agent's tamper-evident log. Refused payments are logged as blocked. Refused at once if the kill switch is
on. Over the organization's live-approval threshold it returns approval_required with an approve_url for the human; call
again with approval_id once they approve. Requires the organization API key.

Input parameters:

- `amount_usdc` (string, required): Payment amount in USDC
- `approval_id`: apr_... : the human's live approval, if this payment is over the agent's approval threshold
- `mandate_id` (string, required): mdt_... ID
- `payee` (string, required): Who is being paid: 0x address or domain
- `reference` (string): Order, invoice or transaction reference

### `mandate_get` (~47 tokens)

Get a mandate

Public view of a mandate: terms, status, the human's signature, spent and remaining budget, and recent spends. Free.

Input parameters:

- `mandate_id` (string, required): mdt_... ID

### `mandate_list` (~23 tokens)

List your mandates

Your organization's mandates with status and remaining budget. Requires the organization API key.

### `mandate_revoke` (~57 tokens)

Revoke a mandate

Stop an agent from spending under a mandate (the human can also revoke from the sign_url page). Requires the
organization API key.

Input parameters:

- `mandate_id` (string, required): mdt_... ID
- `reason` (string): Why

### `fortress_keys` (~56 tokens)

Fortress keys

Privi's public signing keys: Ed25519 and ML-DSA-87 (NIST FIPS 204, CNSA 2.0 post-quantum). Pin these to
verify Privi signatures offline. Free.

### `ledger_tree_head` (~60 tokens)

Signed tree head

The latest signed tree head of Privi's transparency log: an RFC 9162 Merkle root over every entry ever
recorded, signed with Ed25519 and ML-DSA-87, and periodically anchored on chain (Base). Free.

### `ledger_inclusion_proof` (~87 tokens)

Inclusion proof

Merkle audit path proving an entry is in Privi's append-only transparency log (RFC 9162). Verifiable offline
against the signed tree head. Reveals no entry contents. Free.

Input parameters:

- `entry_hash` (string, required): 64-hex entry_hash (an action receipt)
- `tree_size`: Prove against this signed tree head size; omit for latest

### `ledger_consistency_proof` (~68 tokens)

Consistency proof

Proof that Privi's log only grew between two signed tree heads: nothing recorded earlier was edited, removed
or reordered (RFC 9162). Free.

Input parameters:

- `first` (integer, required): Older signed tree size
- `second`: Newer signed tree size; omit for latest

### `fortress_tpi_policy` (~97 tokens)

Set a two-person policy

Define a Two-Person Integrity policy: which officers can approve, and how many distinct approvals an action
needs. Requires the organization API key.

Input parameters:

- `name` (string, required): Policy name, e.g. 'treasury-transfers'
- `officer_wallets` (array, required): 0x wallets of the officers who may approve (at least 2)
- `required` (integer, required): Approvals needed (2..number of officers)

### `fortress_tpi_request` (~129 tokens)

Request two-person approval

Ask officers to authorize a sensitive action under a two-person policy. Returns approve_url for the officers;
each signs with their wallet. Do not act until fortress_tpi_status shows 'authorized', then call
fortress_tpi_execute. Requires the organization API key.

Input parameters:

- `details`: Exact parameters; their hash is what officers sign
- `hours` (integer): Hours until the request expires (1-168)
- `policy` (string, required): Policy name
- `stream_id` (string, required): The agent asking
- `summary` (string, required): Exactly what will be done, in plain words

### `fortress_tpi_status` (~47 tokens)

Two-person status

Status of a two-person request (pending, authorized, vetoed, expired, executed) and who approved. Free.

Input parameters:

- `request_id` (string, required): tpi_... ID

### `fortress_tpi_execute` (~47 tokens)

Execute an authorized action

Consume a two-person authorization right before performing the action. Single use; refused unless authorized.
Requires the organization API key.

Input parameters:

- `request_id` (string, required): tpi_... ID

### `qledger_status` (~60 tokens)

Quantum Ledger status

Privi Quantum Ledger: latest quantum-sealed block (SHA3-512, ML-DSA-87 + Ed25519), entries waiting for the
next block, the Privi Foundation chain it is fused with, and signing keys. Free.

### `qledger_block` (~41 tokens)

Quantum Ledger block

One quantum-sealed block with its signatures, settlement on chain and a validity check. Free.

Input parameters:

- `height` (integer, required): Block height (0 = genesis)

### `qledger_verify_chain` (~80 tokens)

Verify the Quantum Ledger

Verify the whole Quantum Ledger: SHA3-512 block hashes, hash links, both signatures on every block, and for
recent blocks the log roots, entry roots and RFC 9162 consistency proofs. Free; anyone can run it.

Input parameters:

- `deep_last` (integer): Re-derive log roots and consistency proofs for this many most recent blocks

### `qledger_entry_proof` (~71 tokens)

Quantum proof for an entry

Prove an entry (by its receipt hash) is sealed in a quantum block: the block, its post-quantum signatures,
its on-chain settlement and the Merkle inclusion proof. Reveals no entry contents. Free.

Input parameters:

- `entry_hash` (string, required): entry_hash from ledger_record_action

### `qledger_seal` (~47 tokens)

Seal a quantum block now

Seal your newest entries into a quantum block now instead of waiting for the next scheduled block (every
few minutes). Does nothing if no entries are waiting. Requires the organization API key.

### `fortress_tpi_list` (~22 tokens)

List two-person requests

Your organization's two-person requests. Requires the organization API key.

### `ledger_evidence_bundle` (~103 tokens)

Evidence bundle

Export a self-contained evidence package for auditors, courts or air-gapped systems: every entry, the hash
chain, an RFC 9162 inclusion proof, the signed tree head, on-chain checkpoint and Privi's keys, signed with
Ed25519 and ML-DSA-87. Verify offline with verify_bundle.py (GET /tools/verify_bundle.py). Requires the
organization API key.

Input parameters:

- `stream_id` (string, required): Stream to export

### `live_info` (~71 tokens)

Privi Live: how to connect

Real-time Privi: WebSocket and server-sent-event streams (trust changes, your own audit tail, approvals), a
kill switch, human approvals, a metered MCP gateway and paid agent-to-agent rooms. Returns the endpoints,
channels, frames and what each plan gets. Free; no key needed.

### `live_kill` (~101 tokens)

Kill switch: stop an agent

Stop an agent at once: mandate_spend, your gateways and your room messages are refused until live_resume.
Takes effect on the next call, and is pushed to your live channel immediately. Audit logging keeps working.
Requires the organization API key.

Input parameters:

- `reason` (string): Why (shown in your log and on your live channel)
- `stream_id` (string): The agent (stream) to stop, or '*' for every agent in your organization

### `live_resume` (~39 tokens)

Kill switch: resume an agent

Lift a kill switch set with live_kill. Requires the organization API key.

Input parameters:

- `stream_id` (string): The agent to resume, or '*'

### `live_status` (~35 tokens)

Live status

Your kill switches, live-approval thresholds, pending approvals, gateways, rooms and usage this month. Requires the
organization API key.

### `approval_policy_set` (~94 tokens)

Approvals: set a live-approval threshold

Make mandate_spend pause for a human on large payments: any payment over the threshold creates an approval request
that the mandate's principal must sign with their wallet before the agent can spend. Requires the organization API key.

Input parameters:

- `approve_over_usdc`: Payments above this need a live human approval; omit to remove the rule
- `stream_id` (string, required): The agent (stream), or '*' for all of them

### `approval_request` (~235 tokens)

Approvals: ask a human

Ask a human to approve (or deny) an action. Returns approve_url for them: they read the request and sign with their
wallet (free, no transaction). Your agent then calls approval_wait, or watches your live channel for approval.approved.
Only the named wallet can decide; your API key can only cancel. Requires the organization API key.

Input parameters:

- `action` (string, required): Plain-English action the human is approving, e.g. 'Wire 4,800 USDC to Acme for invoice 1042'
- `amount_usdc`: Amount, if money is involved
- `approver_wallet`: 0x wallet of the human who decides (if no mandate_id)
- `mandate_id`: mdt_... : the mandate's principal decides
- `payee` (string): Payee address or domain, if money is involved
- `reason` (string): Why the agent wants to do this
- `reference` (string): Invoice or order reference
- `stream_id` (string, required): The agent asking
- `ttl_s` (integer): Seconds the request stays open (60-86400)

### `approval_status` (~49 tokens)

Approvals: check one

Status of an approval request: pending, approved, denied, expired or cancelled, with the human's wallet signature
once they decide. Free.

Input parameters:

- `approval_id` (string, required): apr_... ID

### `approval_wait` (~68 tokens)

Approvals: wait for the human

Block until the human decides (or timeout_s passes). Returns the current status; if still pending, call again.
Free.

Input parameters:

- `approval_id` (string, required): apr_... ID
- `timeout_s` (integer): How long to wait (1-55 seconds); call again to keep waiting

### `approval_cancel` (~48 tokens)

Approvals: cancel

Withdraw an approval request (or revoke an approval not yet used). Your key cannot approve, only cancel. Requires the
organization API key.

Input parameters:

- `approval_id` (string, required): apr_... ID

### `approval_list` (~36 tokens)

Approvals: list yours

Your organization's approval requests, newest first. Requires the organization API key.

Input parameters:

- `status`: pending, approved, denied, expired or cancelled

### `trust_events` (~103 tokens)

Trust feed: recent events

The latest trust-change events: passports issued, revoked or re-scored, wallets bound or unbound, mandates activated
or revoked, transparency-log heads anchored. Without a Pro key the feed is delayed (see live_info); use the WebSocket or
SSE stream for real time. Free.

Input parameters:

- `address`: Only events about this 0x wallet
- `limit` (integer): 1-200
- `passport_id`: Only events about this passport

### `gateway_create` (~244 tokens)

Gateway: protect and meter an MCP server

Put your MCP server behind Privi. You get an HTTP URL and a WebSocket URL that forward to it unchanged (x402
payments keep working) while Privi rate-limits callers, optionally requires a Privi Passport, meters every tool call
and writes each call to your tamper-evident log. The kill switch stops the gateway instantly. Upstream must be public
HTTPS. Requires the organization API key.

Input parameters:

- `guard` (string): Privi Guard on every tool result: off, tag (add the verdict in _meta) or block (withhold injected results). Each check uses your Guard allowance or credits
- `min_score` (integer): 0 = open to everyone. >0 = callers must prove a KYA wallet whose Passport scores at least this (0-1000)
- `name` (string, required): A name for this gateway, e.g. 'acme-search-mcp'
- `rate_per_min` (integer): Requests per minute per caller (1-1200)
- `upstream_url` (string, required): The MCP server's public https URL (streamable HTTP), e.g. https://api.acme.com/mcp

### `gateway_set_guard` (~101 tokens)

Gateway: Guard mode

Turn Privi Guard on for every tool result that passes through your gateway: tag adds the verdict and a receipt
id in result._meta['privi/guard']; block also replaces injected results with an error before your agents see
them. Each result is one Guard check (free allowance, then credits). Requires the organization API key.

Input parameters:

- `gw_id` (string, required): gw_... ID
- `mode` (string, required): off | tag | block

### `gateway_info` (~47 tokens)

Gateway: info

Public description of a gateway: where it forwards, whether callers need a Passport, its rate limit and its call
counts. Free.

Input parameters:

- `gw_id` (string, required): gw_... ID

### `gateway_list` (~18 tokens)

Gateway: your gateways

Your organization's gateways. Requires the organization API key.

### `gateway_stats` (~53 tokens)

Gateway: usage

Calls, errors, denials and x402 payment prompts per tool and per day for one of your gateways, plus your monthly quota.
Requires the organization API key.

Input parameters:

- `gw_id` (string, required): gw_... ID

### `gateway_delete` (~44 tokens)

Gateway: delete

Turn a gateway off. Its URLs stop working at once; history stays in your log. Requires the organization API key.

Input parameters:

- `gw_id` (string, required): gw_... ID

### `room_open` (~197 tokens)

Rooms: open a live room

Open a live, hash-chained conversation room for two organizations' agents. Both connect over WebSocket
(ws_url), authenticate with their API keys and talk in real time; closing the room seals the transcript on the Privi
chain. Optionally charge per message, paid under the guest's human-signed Mandate. Requires the organization API key.

Input parameters:

- `counterparty_org_id`: org_... that may join; omit to get a one-time join_code instead
- `hours` (integer): Hours the room stays open (1-168)
- `max_messages` (integer): Message cap (2-10000)
- `payee`: Who is paid for messages: 0x address or domain
- `price_per_message_usdc`: Charge the guest this much per message (needs payee)
- `title` (string, required): What the room is for, e.g. 'Negotiate delivery of lot 4471'

### `room_info` (~47 tokens)

Rooms: info

Public facts about a room: parties, price, message count, head hash and its seal once closed. No message text. Free.

Input parameters:

- `room_id` (string, required): rm_... ID

### `room_list` (~21 tokens)

Rooms: list yours

Rooms your organization owns or joined. Requires the organization API key.

### `room_transcript` (~42 tokens)

Rooms: transcript

Every message in a room you are part of, with the chain check. Requires the organization API key.

Input parameters:

- `room_id` (string, required): rm_... ID

### `room_close` (~70 tokens)

Rooms: close and seal

Close a room and seal its transcript: the hash is signed (Ed25519 + ML-DSA-87), anchored on chain (Base) and written
to both organizations' logs. Either party can close. Requires the organization API key.

Input parameters:

- `room_id` (string, required): rm_... ID

### `room_verify` (~75 tokens)

Rooms: verify a sealed transcript

Check a closed room's seal (signature, on-chain anchor) and, if you pass the transcript, that it is complete and
unaltered. Free; no key needed.

Input parameters:

- `messages`: The transcript's 'messages' array exactly as room_transcript returned it
- `room_id` (string, required): rm_... ID

### `mcp_server_check` (~206 tokens)

Check an MCP server before connecting

Free safety check for any remote MCP server, before an agent connects to it or after it was approved. Privi
reads the server's tool list (it never calls a tool) and returns a verdict: ok, caution, danger (tool poisoning:
hidden instructions, concealment from the user, requests for keys or private files, tool shadowing, invisible
characters), changed (tools differ from expected_tools_hash), unverified (tools behind auth) or unreachable. Also
returns the tools_hash to pin, a grade A-F and a link to the server's public history. Every first observation and
change is recorded in Privi's on-chain-anchored transparency log. No key needed.

Input parameters:

- `expected_tools_hash`: The tools_hash you approved earlier; Privi tells you if the tools changed since then (rug-pull check)
- `url` (string, required): The server's streamable-HTTP MCP endpoint, e.g. https://example.com/mcp

### `scan_search` (~125 tokens)

Search the MCP trust registry

Search Privi Scan, the public directory of remote MCP servers from the official MCP Registry, each with a
safety grade, verdict, tool count and change history. Use it to find a trustworthy server for a job. Free.

Input parameters:

- `grade` (string): Only this grade: A, B, C, D or F
- `limit` (integer)
- `offset` (integer)
- `query` (string): Words to match in name, description or URL; empty lists everything
- `sort` (string): name, score, risk, changed or new

### `scan_server` (~85 tokens)

Privi Scan: one server in full

Full report for one MCP server: every tool definition with its hash, all findings with evidence, the change
history (what was added, removed or modified, and when) and the transparency-log proof. Free.

Input parameters:

- `include_history` (boolean)
- `server_id` (string, required): mcp_... id from scan_search or mcp_server_check, or the endpoint URL

### `scan_changes` (~53 tokens)

Privi Scan: recent tool changes

The latest MCP servers whose tool definitions changed after they were first observed (possible rug pulls),
newest first. Subscribe to the Live channel 'scan' for these as they happen. Free.

Input parameters:

- `limit` (integer)

Output parameters:

- `result` (array)

### `scan_stats` (~37 tokens)

Privi Scan: totals

How many MCP servers Privi Scan tracks, by status and grade, tools indexed, changes recorded and how to verify
the evidence. Free.

### `scan_watch` (~95 tokens)

Watch an MCP server (pin its tools)

Pin the server's current tools as approved and get a real-time event on your private Live 'org' channel the
moment they change, a risk appears or the server goes down. Free plan: 3 servers; Pro: 500. Needs the org key.

Input parameters:

- `repin` (boolean): Pin the current tools_hash as approved (default true)
- `server` (string, required): mcp_... id or endpoint URL

### `scan_unwatch` (~37 tokens)

Stop watching an MCP server

Remove a server from your watchlist. Needs the org key.

Input parameters:

- `server` (string, required): mcp_... id or endpoint URL

### `scan_watchlist` (~34 tokens)

Your watched MCP servers

Your watched servers with their pinned tools_hash and whether each has drifted since you pinned it. Needs the
org key.

### `scan_claim_start` (~90 tokens)

Claim your MCP server's listing

Start proving you operate an MCP server listed in Privi Scan. Returns a token to publish at
https://<your host>/.well-known/privi-scan.txt. Verified owners get an owner-verified badge, unlimited rescans,
change alerts and control over the listing. Needs the org key (create_org is free).

Input parameters:

- `server` (string, required): mcp_... id or endpoint URL

### `scan_claim_verify` (~45 tokens)

Finish claiming your MCP server

Check the token at /.well-known/privi-scan.txt and mark your organization as the verified owner.

Input parameters:

- `server` (string, required): mcp_... id or endpoint URL

### `scan_owner_listing` (~62 tokens)

Show or hide your server's listing

Verified owners only: hide the server from the directory (opt-out) or show it again. History already in the
transparency log cannot be removed.

Input parameters:

- `listed` (boolean, required)
- `server` (string, required): mcp_... id or endpoint URL

### `scan_rescan` (~50 tokens)

Rescan an MCP server now

Probe the server immediately instead of waiting for the next crawl (every ~6 hours). For the verified owner
or Pro organizations.

Input parameters:

- `server` (string, required): mcp_... id or endpoint URL

### `guard_check` (~216 tokens)

Guard: check text before acting on it or sending it

Check content for prompt injection (inbound) or leaked secrets and personal data (outbound) before an
agent acts on it or sends it. Returns allow / warn / block, the findings, a redacted copy for outbound
secrets, and an Ed25519-signed receipt anchored on-chain, which proves the check happened. Privi does
not store the text. Free for 1,000 checks a month with an organization key; otherwise 1 cent per check
in USDC via x402.

Input parameters:

- `direction` (string): inbound = untrusted content coming in (prompt injection, hidden instructions); outbound = content going out (API keys, card numbers, data smuggled in URLs)
- `source`: Optional label for the receipt, e.g. the page URL or tool name
- `text` (string, required): The content to check: a web page, email, document or tool result the agent is about to act on (inbound), or what the agent is about to send (outbound)

### `guard_check_many` (~88 tokens)

Guard: check many texts at once

Check up to 50 texts in one call (for example every tool result in a step). Each item is billed as its
own check against your free allowance or credits and gets its own receipt. Needs an organization key.

Input parameters:

- `items` (array, required): Up to 50 items {"text": "...", "direction": "inbound"|"outbound", "source": "optional label"}

### `guard_receipt` (~62 tokens)

Guard: verify a receipt

Verify a Privi Guard receipt: the signed body, signature validity and its Merkle proof into the anchored
transparency log. Free; anyone holding the id can verify it.

Input parameters:

- `check_id` (string, required): gc_... id from a guard_check receipt

### `guard_balance` (~24 tokens)

Guard: balance

Your free checks left this month and your prepaid credits. Needs the organization key.

### `guard_buy_credits` (~92 tokens)

Guard: buy check credits

Buy prepaid Privi Guard checks in USDC on Base via x402. Credits never expire and are used after the free
monthly allowance. Needs the organization key.

Input parameters:

- `pack` (string, required): 1k = 1,000 checks for 7 USDC; 10k = 10,000 for 50 USDC; 100k = 100,000 for 300 USDC

### `guard_pricing` (~26 tokens)

Guard: pricing and how it works

What Privi Guard checks, what it costs, and how receipts work. Free.

### `privi_payment_options` (~29 tokens)

Privi: payment methods

See existing USDC/x402 service billing and separately gated valueless PRVI_TEST development mode.

### `privi_test_payment_quote` (~48 tokens)

Privi: create a valueless test-payment quote

Off-chain PRVI_TEST quote. Requires organization key and explicit test mode. Never takes money.

Input parameters:

- `sku` (string, required): Existing priced tool to model; NO service will be unlocked

### `privi_test_payment_simulate` (~57 tokens)

Privi: simulate a valueless test payment

Consume a test quote once. Receipt is NOT payment, on-chain proof or entitlement.

Input parameters:

- `acknowledgement` (string, required): Must equal VALUELESS TEST ONLY
- `quote_id` (string, required): Short-lived PRVI_TEST quote ID

### `ai_act_system_save` (~512 tokens)

AI Act: register an AI system

Add or update an AI system in your company's EU AI Act register. Privi screens it against the Article 5
bans, classifies it (prohibited / high-risk / transparency / general-purpose / minimal), and lists the
obligations that apply to your role with their dates. Every change is versioned and written to your
tamper-evident 'ai-act' log. Requires the organization API key.

Input parameters:

- `actor` (string, required): Who is making the change (person or agent)
- `merge` (boolean): Merge into the existing record (true) or replace it (false)
- `system` (object, required): AI system record. Required: system_id. Recommended: name, owner, role (provider|deployer|provider_and_deployer|importer|distributor), intended_purpose, used_in_eu, vendor_name. Risk flags: annex_iii_…

### `ai_act_register` (~45 tokens)

AI Act: your register

Your EU AI Act register: each AI system's current record, tier and applicable obligations.
Requires the organization API key.

Input parameters:

- `system_id`: One system; omit for all

### `ai_act_check` (~73 tokens)

AI Act: compliance check

What a customer's due-diligence or a regulator would flag today: prohibited practices, incomplete
Article 5 screens, obligations already in force without evidence (critical), obligations due within 180
days (medium), upcoming high-risk duties, and high-risk systems with no recent log. Requires the
organization API key.

### `ai_act_export` (~57 tokens)

AI Act: export sealed register

Export your AI Act register as JSON to hand to customers, auditors or regulators, with its SHA-256
sealed on chain so anyone can prove it was not edited afterwards (check with ai_act_verify_export).
Requires the organization API key.

### `ai_act_verify_export` (~61 tokens)

AI Act: verify a register

Check that an AI Act register a supplier or partner sent you is exactly what they exported from Privi,
and return its on-chain seal. Free; no key needed.

Input parameters:

- `register_json` (string, required): The exact register_json a company shared with you

### `supplier_requirement_create` (~155 tokens)

Supplier Proof: require proof from suppliers

Publish a requirement your suppliers must meet. Share the returned invite_url with them: they answer it
from their own Privi organization (free sign-up) and you approve or reject in supplier_proof_inbox.
Requires the organization API key.

Input parameters:

- `items` (array, required): What each supplier must prove: [{key: 'iso_9001', label: 'ISO 9001 certificate', document_required: true}, {key: 'ai_act_register', label: 'Sealed Privi AI Act register'}]. 1-30 items.
- `title` (string, required): e.g. 'Approved supplier 2027'
- `valid_days` (integer): How long an approved certificate lasts (1-1095 days)

### `supplier_requirement_get` (~37 tokens)

Supplier Proof: view a requirement

See what a buyer requires of its suppliers. Free; no key needed.

Input parameters:

- `req_id` (string, required): Requirement ID (req_...)

### `supplier_proof_submit` (~121 tokens)

Supplier Proof: submit proof to a buyer

Answer a buyer's supplier requirement with fingerprints of your evidence documents. The buyer reviews
and, if approved, Privi issues a certificate sealed on chain. Requires your organization API key
(sign up free with ledger_signup).

Input parameters:

- `evidence` (object, required): One entry per requirement item: {item_key: {sha256: '<64-hex of the document>', note: '...', valid_until: 'YYYY-MM-DD'}}. Only fingerprints are sent; keep the documents yourself.
- `req_id` (string, required): The buyer's requirement ID (req_...)

### `supplier_proof_inbox` (~43 tokens)

Supplier Proof: inbox

Supplier submissions waiting for your decision (as the buyer). Requires the organization API key.

Input parameters:

- `status` (string): pending | approved | rejected | superseded

### `supplier_proof_decide` (~99 tokens)

Supplier Proof: approve or reject

Approve a supplier's proof (issues a certificate naming both companies and the evidence fingerprints,
sealed on chain, with a public verify page and badge) or reject it with a reason. Requires the
organization API key.

Input parameters:

- `approve` (boolean, required): true issues the certificate; false rejects
- `reason` (string): Required when rejecting, so the supplier can fix it
- `sub_id` (string, required): Submission ID (sub_...)

### `supplier_cert_verify` (~90 tokens)

Supplier Proof: verify a certificate

Check a Privi supplier certificate: untampered, not revoked, not expired, which buyer approved which
supplier, and (optionally) whether a document is one it covers. Free; no key needed.

Input parameters:

- `cert_id` (string, required): Certificate ID (spc_...)
- `document_sha256`: Optional: SHA-256 of a document to check it is the one the certificate covers

### `supplier_certs` (~28 tokens)

Supplier Proof: your certificates

Certificates you issued (as buyer) or hold (as supplier). Requires the organization API key.

### `supplier_cert_revoke` (~60 tokens)

Supplier Proof: revoke a certificate

Revoke a certificate you issued (as the buyer). Verification shows it as revoked at once.
Requires the organization API key.

Input parameters:

- `cert_id` (string, required): Certificate ID (spc_...)
- `reason` (string, required): Why it is revoked

### `seal_content` (~150 tokens)

Content Seal: seal files or text

Seal content your company publishes (documents, images, video, press releases, invoices, AI output)
with who made it and whether AI was involved. Each seal is anchored on chain; anyone can check a file
for free at the returned verify_url or with seal_verify. Counts toward your plan's monthly entries.
Requires the organization API key.

Input parameters:

- `items` (array, required): 1-50 items: {sha256: '<64-hex of the file>' (or text: 'exact text'), origin: human|ai_assisted|ai_edited|ai_generated, ai_tool (required unless human), title, author, media_type, note}. Only the fing…

### `seal_verify` (~77 tokens)

Content Seal: check a file

Is this exact file or text sealed, by whom, since when, and did they declare AI involvement? Any
change to the content (one pixel, one character) means no match. Free; no key needed.

Input parameters:

- `sha256`: SHA-256 (64 hex) of the file
- `text`: Or the exact text

### `seal_list` (~31 tokens)

Content Seal: your seals

Your most recent content seals. Requires the organization API key.

Input parameters:

- `limit` (integer): 1-200

### `seal_revoke` (~59 tokens)

Content Seal: revoke a seal

Withdraw one of your seals (e.g. sealed by mistake). Checks then show it as revoked.
Requires the organization API key.

Input parameters:

- `reason` (string, required): Why it is revoked
- `seal_id` (string, required): Seal ID (seal_...)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/canoydario847-cloud-privi-ledger/privi-ledger#diagnostics

## Score history

- 2026-11-05: 68
- 2026-11-04: 68
- 2026-11-03: 67
- 2026-11-02: 67
- 2026-11-01: 66
- 2026-10-31: 66
- 2026-10-30: 66
- 2026-10-29: 65
- 2026-10-28: 65
- 2026-10-27: 64
- 2026-10-26: 64

## Common questions

### What is the Privi Quantum Ledger MCP server?

Privi Quantum Ledger is an MCP server listed in the public MCP registry as io.github.canoydario847-cloud/privi-ledger. Quantum-sealed audit logs for AI agents (ML-DSA-87, SHA3-512), plus Privi Guard and trust passports. This page covers its hosted endpoint (https://privi-ledger.onrender.com/mcp).

### Is the Privi Quantum Ledger MCP server safe to use?

Privi Quantum Ledger scores 68 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Privi Quantum Ledger MCP server expose?

Privi Quantum Ledger exposes 121 tools: privi_token_market, ledger_pricing, ledger_check_receipt, ledger_audit_stream, ledger_record_action, and 116 more. Their descriptions and schemas cost roughly 10,443 tokens of context every time the server is loaded.

### Does the Privi Quantum Ledger MCP server require authentication?

No. We connected to Privi Quantum Ledger without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the Privi Quantum Ledger MCP server still maintained?

Privi Quantum Ledger is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://privi-ledger.onrender.com/mcp
- Repository: https://github.com/canoydario847-cloud/Privi-Network
- Website: https://privi-discovery.onrender.com/
- Changelog RSS feed: https://verifymcp.io/servers/canoydario847-cloud-privi-ledger/privi-ledger.xml
- Changelog JSON feed: https://verifymcp.io/servers/canoydario847-cloud-privi-ledger/privi-ledger.json
- HTML version of this page: https://verifymcp.io/servers/canoydario847-cloud-privi-ledger/privi-ledger