Privi Anchor
Server Details
Timestamped proof that AI outputs and data existed, anchored on the Privi blockchain.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- canoydario847-cloud/Privi-Network
- GitHub Stars
- 0
TDQS
Scored across 4 tools
Each tool has a clearly distinct role: hashing text, anchoring hashes in batch, querying service status, and verifying on-chain proofs. There is no meaningful overlap, and the descriptions explicitly reference how they chain together (e.g., anchor_hash_text feeds anchor_hashes, receipts feed anchor_verify).
All four tools use a consistent snake_case anchor_ prefix followed by a clear action or noun (anchor_hashes, anchor_hash_text, anchor_status, anchor_verify). The pattern is predictable and immediately readable.
Four tools is a tight, well-scoped surface for a focused anchoring service; each tool corresponds to a necessary step in the hash-to-verification lifecycle. Nothing feels padded or missing at the count level.
The core lifecycle is covered: prepare hashes, anchor them, check service status, and verify proofs on-chain. Minor gaps exist around discovering or listing past anchors and receipts, but agents can work around this via returned receipts and external chain queries.
Available Tools
4 toolsanchor_hashesAnchor hashesAInspect
Anchor up to 100 hashes on the Privi chain in one transaction. Returns, for each hash, a receipt (tx_hash, Merkle proof, block, time) that anyone can check with anchor_verify. Requires an API key (Authorization: Bearer).
| Name | Required | Description | Default |
|---|---|---|---|
| label | No | Optional note kept in this server's index (not on chain) | |
| hashes | Yes | 1-100 hex SHA-256 hashes of the content to anchor |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations cover the safety profile (not read-only, open-world, not idempotent, non-destructive), and the description adds context beyond them: the 100-hash batch cap, the per-hash receipt contents (tx_hash, Merkle proof, block, time), and the auth requirement. Nothing contradicts the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with what the tool does, followed by return shape and auth requirement. No filler; each clause carries distinct information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description compensates by enumerating the receipt fields an agent will receive, plus batch limits and authentication. Combined with annotations covering safety, an agent has everything needed to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so both parameters (hashes with '1-100 hex SHA-256', label noted as server-index-only) are already documented in the schema. The description only echoes the batch ceiling and adds no format or labeling detail beyond it, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (anchor), resource (SHA-256 hashes), target (Privi chain) and scope (up to 100 per transaction). It also implicitly distinguishes itself from sibling anchor_hash_text by operating on pre-computed hashes rather than text, and names anchor_verify as the downstream counterpart.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives a clear prerequisite (API key via Authorization: Bearer) and points to anchor_verify for the verification step, which tells the agent when this fits in a workflow. It does not explicitly say when to prefer anchor_hash_text or anchor_status instead, so the sibling routing is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
anchor_hash_textHash textARead-onlyInspect
SHA-256 of a piece of text, ready to pass to anchor_hashes. Hashing happens here; nothing is stored.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | Exact text to fingerprint (UTF-8) |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds meaningfully beyond that with 'Hashing happens here; nothing is stored,' clarifying that computation is local and no state is persisted — exactly the reassurance an agent needs before calling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences with zero filler; the algorithm and output destination are front-loaded and the no-storage guarantee follows immediately. Every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Output schema exists, so return value details need not be explained, and the description correctly points at the downstream consumer. For a one-parameter pure function this is nearly complete; only a note on expected input edge cases (empty string, encoding) would close the gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With a single parameter at 100% schema coverage, the schema already explains 'Exact text to fingerprint (UTF-8).' The description's 'piece of text' adds no format, encoding, or edge-case detail beyond the schema, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Names the exact operation (SHA-256) and the resource (a piece of text), which an agent cannot infer from the name alone. The clause 'ready to pass to anchor_hashes' ties the output to a specific sibling, making it distinguishable from anchor_hashes and anchor_verify.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Ready to pass to anchor_hashes' establishes the intended workflow context: this is the local pre-step before anchoring. It gives clear positive guidance but no explicit exclusions or when-not-to-use conditions (e.g., hashing a file versus a string).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
anchor_statusAnchor statusBRead-onlyInspect
Which chain anchors go to, the service wallet that signs them, its gas balance, and totals.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds domain context about what the status includes, but does not add behavioral details such as auth needs, rate limits, or freshness. It does not contradict the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single compact phrase with no wasted words and is front-loaded with the main data points. It is slightly fragmentary rather than a complete sentence, but that does not harm brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, read-only status tool with an output schema and safety annotations, the description provides enough domain context to identify the payload. It does not need to explain return values because the output schema already does so, though it could be more complete with usage guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, and the schema coverage is 100%. Per the rubric, zero parameters establishes a baseline of 4; there is no parameter information the description needs to compensate for.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the status payload: chain destinations, signing wallet, gas balance, and totals. It distinguishes itself from hash/verify siblings by content, but lacks an explicit verb and does not name or contrast the alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No when-to-use or when-not-to-use guidance is provided, and no sibling tools are referenced. The agent must infer that this is the status-retrieval tool from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
anchor_verifyVerify an anchorARead-onlyInspect
Check on the blockchain that a hash was anchored, by whom and when. Free. With tx_hash and proof from a receipt, the check uses only chain data.
| Name | Required | Description | Default |
|---|---|---|---|
| hash | Yes | The 64-character hex SHA-256 that was anchored | |
| proof | No | Optional: Merkle proof from the receipt | |
| tx_hash | No | Optional: transaction from the receipt, to verify without this server's index |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark it read-only and open-world, so the safety profile is covered. The description adds useful behavioral context beyond that: verification is 'Free,' it checks on-chain, and with tx_hash and proof it uses only chain data rather than this server's index.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core action and scope. Every sentence earns its place by adding either purpose, cost, or verification-path detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a three-parameter verification tool with full schema coverage and annotations but no output schema, the description conveys the conceptual return (whether anchored, by whom, when), cost, and the effect of optional parameters. It leaves only minor gaps around failure behavior and result formatting.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds meaning for tx_hash and proof by explaining that together they let the check rely only on chain data, which clarifies why an agent would supply them.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Check on the blockchain that a hash was anchored, by whom and when.' It is clearly distinguishable from the anchoring siblings (anchor_hashes, anchor_hash_text) and the status sibling, though it does not explicitly name or contrast them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage context is implied by 'With tx_hash and proof from a receipt, the check uses only chain data,' which tells the agent how the optional parameters change the verification path. However, it never states when to prefer this tool over anchor_status or the other siblings, nor any exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
- First observed
anchor_hash_text - First observed
anchor_hashes - First observed
anchor_status - First observed
anchor_verify
Related MCP Connectors
Prove you made it first. Blockchain Timestamp creative work via Claude or any MCP-enabled AI Agent.
Qualified eIDAS RFC 3161 timestamping for AI workflow provenance. SIGNIUS/IDnow backbone.
Tamper-evident proof creation and verification for AI agents via MCP, A2A, and REST.
Deterministic AI liability attribution with Bitcoin-anchored proof certificates.
Related MCP Servers
AlicenseAqualityBmaintenanceBitcoin-anchored provenance for AI outputs; enables stamping, verifying, and tracing outputs with offline-verifiable canonical roots.3Apache 2.0- AlicenseNot gradedqualityFmaintenanceSigned AI content provenance with PII scrubbing — timestamps and signs AI-generated outputs for EU AI Act and FTC compliance.MIT
- FlicenseNot gradedqualityDmaintenanceCryptographically anchored, tamper-evident evidence receipts for AI agents — verified run receipts, existence-at-time proofs, and cited answers from an anchored public record. Remote MCP with proof-gated settlement; attests existence and integrity, never truth.-
- FlicenseNot gradedqualityCmaintenanceSuperseded. Earlier version of the DCL product (MCP endpoint at /sse with API key, plus an offline desktop audit trail). Not the current path for agents. Use the hosted DCL Trust Oracle: https://github.com/Fronesis-Labs/dcl-webhook (MCP endpoint https://mcp.fronesislabs.com/mcp, Streamable HTTP, x402 payment, no API key).-
Glama MCP Gateway
Add one secure layer between your agents and this server.