Skip to main content
Glama

AINumbers Fintech Intelligence Suite

Validate ChainGraph private-input commitments

validate_private_inputs
Read-onlyIdempotent

Verify an artifact's private_inputs[] (ChainGraph Standard §25 ocg-private-input@1) WITHOUT ever seeing the plaintext witness: per RFC 6901 pointer, checks the pointed value inside policy_parameters IS the declared sha256-salted@1 commitment (never the plaintext, §25.2), that the commitment scheme is known, and -- when a §18 compute_proof is present -- that its journal commits the same commitment and binds output_payload. Optionally accepts an out-of-band {pointer, salt, input_value} disclosure package (authorized-verifier path) and recomputes sha256(salt || cgCanon(input_value)) to confirm it equals the commitment. Returns one {pointer, verifiable} record per entry: "proof-only" | "disclosed-verified" | "commitment-only" (no proof yet -- structural + plaintext-exclusion only) | "failed". Pure client-safe compute, zero network, never requires the plaintext.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
artifactNoA full ChainGraph artifact envelope carrying private_inputs[], policy_parameters, and optionally output_payload + audit_signature.compute_proof.
disclosuresNoOPTIONAL authorized-verifier disclosure packages, keyed by pointer, for the disclosed-verified path.
compute_proofNoaudit_signature.compute_proof (if not passing a full artifact).
output_payloadNoArtifact output_payload (if not passing a full artifact).
private_inputsNoThe private_inputs[] array (if not passing a full artifact).
policy_parametersNoArtifact policy_parameters (if not passing a full artifact).

TDQS

A3.8/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable behavioral context: 'Pure client-safe compute, zero network, never requires the plaintext.' It explains the verification logic and that no state mutation occurs, going beyond the annotations. No contradiction is present.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with the core purpose but is long and dense, containing many technical specifics (RFC 6901, sha256-salted, §25.2, etc.). While every sentence contributes to completeness, the length may overwhelm. It could benefit from structuring into bullet points for easier parsing, but it is not excessively verbose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (6 parameters, nested objects, no output schema), the description covers the essential aspects: input specification, verification logic, optional disclosure path, and return format. It describes the possible return values (proof-only, disclosed-verified, etc.). There are minor gaps (e.g., error handling), but overall it provides sufficient context for an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, but the description enriches parameter understanding. It explains that 'artifact' is the full ChainGraph envelope and that other parameters (e.g., compute_proof, output_payload) are optional alternatives. It clarifies the 'disclosures' parameter as authorized-verifier packages. This adds meaning beyond the schema's property descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: verifying ChainGraph private-input commitments without seeing the plaintext. It specifies the verification logic, optional disclosure path, and return values. This distinguishes it from other 'validate_' sibling tools, which deal with different aspects (e.g., agent cards, mandates). The verb 'validate' is specific to the resource 'private_inputs[]' and the standard (§25 ocg-private-input@1).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not provide any explicit guidance on when to use this tool versus alternative validation tools. While the technical depth implies its domain, there is no 'use this for' or 'avoid when' advice. The sibling list includes many validate tools, but no distinction criteria are offered.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.

TDQS

C2.4/5.0
Disambiguation1/5

Nearly every tool is an 'OpenChainGraph compute node' with identical boilerplate, and dozens of assess/check/validate/verify/lint/recompute verbs overlap heavily in purpose. An agent cannot reliably tell which of many similarly scoped tools should handle a given compliance or analytics question.

Naming Consistency2/5

Most names are snake_case, so there is superficial consistency, but the verb vocabulary is enormous and unpredictable, mixing build/compute/check/validate/verify/lint/assess/classify/score/reconcile and more. Several noun-first names such as pain001_validate, recon_match, and ha_record_validate further break the pattern.

Tool Count1/5

695 tools is far beyond any practical agent-facing surface, exceeding even the extreme end of the calibration range. This is a full product catalog dumped into one MCP server rather than a curated, usable tool set.

Completeness3/5

The suite covers an extremely wide range of fintech and regulatory calculators, validators, chain tools, and discovery utilities, so coverage is broad rather than thin. However, the lack of a clear domain boundary makes completeness nearly impossible to assess, and the heavy overlap suggests the surface was generated rather than intentionally designed.