zkevidenceoracle

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

No annotations are provided, so the description must carry the full burden. It discloses the technical reference (Polygon ZK attestation + XRPL report anchoring) but does not state whether it is read-only, what the output format is, or any side effects. Lack of detail about return behavior is a gap for a status tool.

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 concise sentence that front-loads the core purpose. It is efficient but could include a bit more context (e.g., output type) without becoming verbose.

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 and no annotations, the description is insufficiently complete. It doesn't explain what the status means, what values are reported, or how the anchoring mechanism relates to usage. Given the tool's simplicity, a short output description would significantly improve completeness.

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 has zero parameters, and the schema is trivially covered. Per the rubric, 0 params gets a baseline of 4. The description does not need to explain parameters that don't exist.

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 tool's subject: on-chain anchor status specific to Polygon ZK attestation and XRPL report anchoring. While the verb is implicit (get/check), the phrasing conveys a status-checking action. It distinguishes from sibling proof/verification tools by focusing on anchor status rather than proofs.

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 explicit guidance on when to use this tool versus alternatives. The description implies it's for checking anchoring status, but does not mention conditions, prerequisites, or contrast with sibling tools such as verify_commitment or audit_proof.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It merely states the package composition and does not disclose whether the tool is read-only, whether it verifies existing proofs or creates new ones, what side effects occur, or what the output format is. This is a significant transparency gap.

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 structurally clear with a colon separating the package concept from its components, and there is no redundant wording. However, it is under-specified to the point of being nearly a label, sacrificing essential information for brevity. It is not as sparse as 'Process' but still leaves too much unsaid.

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 tool that packages three different proof types, the description is incomplete. It does not explain the workflow, the role of entity_id, what 'auditor-ready' means operationally, or what the caller should expect. The absence of annotations and output schema makes this incompleteness more damaging.

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 schema defines a single parameter entity_id with no description, and the tool description does not mention it at all. Schema description coverage is 0%, so the description was expected to compensate, but it provides zero insight into what entity_id means or how it impacts the proof package.

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 identifies the tool as an 'auditor-ready proof package' and lists its components (commitment + merkle + credential), which indicates what it produces. However, it lacks an explicit action verb (e.g., generate, create, assemble) and does not clearly distinguish this from sibling proof-related tools like obligation_proof or threshold_proof.

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?

There is no explicit guidance on when to use this tool versus alternatives. The phrase 'auditor-ready' hints at an auditing use case, but no alternatives are named and no exclusions or context are provided. The description gives no actionable direction for an agent deciding between this and create_commitment, build_merkle_tree, or other proof tools.

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

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

No annotations are provided, so the description carries the full burden. It only states the action and intended outcome, but fails to disclose whether it's a read-only computation, if it persists state, or what the return format is.

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 two sentences long, front-loaded with the action, and contains no wasted words. Every sentence contributes meaningful context.

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?

Given there are no annotations and no output schema, the description is too vague about domain concepts like 'active evidence' and the optional entity_id. This leaves critical gaps for an agent to call the tool 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 coverage is 0%, and the description doesn't mention the only parameter 'entity_id' at all. The agent has no idea what entity_id means or how it relates to 'all active evidence'.

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 states 'Build merkle tree from all active evidence', specifying the action and resource. It distinguishes from siblings like verify_merkle_proof by using 'build' rather than 'verify', though it doesn't explicitly call out 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?

The phrase 'Root hash proves evidence exists' implies usage when proof of evidence existence is required, but it gives no explicit guidance on when to use this tool versus alternatives such as verify_merkle_proof or create_commitment.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that the operation is a one-way hash ('Hash') and that details are hidden, but it does not disclose whether the commitment is stored, whether anchoring via anchor_status is required, or any security or side effects. This is minimal for a ZK-related tool.

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, front-loaded sentences with no fluff. Every word serves a purpose.

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?

Given the lack of annotations and output schema, the description is incomplete. It does not explain what the tool returns (e.g., a commitment or proof), how it interacts with sibling tools like verify_commitment or anchor_status, or any prerequisites. For a simple one-parameter tool, an agent still needs more context 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?

The schema has one parameter, entity_id, with 0% schema description coverage. The description does not mention entity_id at all, so it adds no meaning about how the parameter is used. The phrase 'compliance status' only indirectly relates to the entity, leaving the agent to guess the parameter's role.

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 uses a specific verb ('Hash compliance status into ZK commitment') and clearly identifies the resource (compliance status → ZK commitment). It also distinguishes itself from sibling tools like create_vc, build_merkle_tree, and verify_commitment by focusing on creating a privacy-preserving commitment.

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?

The phrase 'Proves state without revealing details' implies when to use the tool, but there is no explicit when-to-use guidance, no exclusions, and no mention of alternatives such as create_vc, threshold_proof, or selective_disclosure. The usage context is inferred rather than stated.

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

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

With no annotations, the description must disclose behavior, but it only says 'Grade + score only' without explaining what that means, whether the credential is stored, what permissions are needed, or what the response contains. It fails to clarify the operation's side effects.

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 short and front-loaded, but the second sentence 'Grade + score only' is cryptic and under-specified; it is not clear enough to count as a useful structural element.

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 credential creation tool with no output schema and no annotations, the description is insufficiently complete. It omits return format, parameter meaning, and the meaning of the 'Grade + score only' limitation.

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 covers type's allowed values but leaves entity_id undocumented. The description does not explain either parameter or how 'Grade + score only' maps to them, so it adds no value beyond the schema.

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 identifies the action (create W3C Verifiable Credential) and target (DORA compliance), distinguishing it from siblings like verify_vc. However, 'Grade + score only' is ambiguous, and the schema's type parameter supports mica_compliance and aml_screening, which the description does not mention, making the stated scope incomplete.

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 guidance on when to use this tool versus alternatives such as create_commitment or verify_vc. The phrase 'for DORA compliance' implies a use case but provides no exclusions or prerequisites.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only hints at informational content ('crypto info') but does not state whether the operation is read-only, what side effects exist, or what the response shape resembles. Minimal transparency is provided.

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 vague phrase. While brief, it is under-specified and does not earn its place due to lack of useful content. This is more under-specification than effective conciseness.

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?

The complexity is low (no params, no output schema), but the description's ambiguity about 'crypto info' creates a significant gap. It is unclear whether this refers to cryptocurrency, cryptographic primitives, or something else, making the tool incompletely described for an agent.

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 has zero parameters, and the input schema is empty. Per baseline, no parameter description is needed; the score is set to 4 as there is no additional semantic burden.

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 'Server status + crypto info' is vague and lacks a clear verb. It fails to specify what the tool actually does (e.g., retrieves, checks, returns) and does not distinguish it from sibling tools like 'ping' or 'anchor_status' which also relate to status.

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 guidance is provided on when to use this tool versus alternatives. The description gives no context for appropriate usage or exclusions, leaving the agent without any decision support.

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

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

With no annotations, the description carries the full behavioral burden. It discloses a key trait—evidence is not shown—implying privacy preservation. However, it doesn't state whether the operation is read-only, what it returns, or any side effects, leaving significant gaps.

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?

Single sentence, seven words, zero fluff. The key information is front-loaded: the verb and object appear immediately, with the privacy qualifier appended. Every word 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?

Given no output schema, no annotations, and a terse description, the tool's behavior remains under-specified. It doesn't explain the proof type, the response format, or the meaning of the parameters. For a tool in a sibling set involving proofs and verifications, more context is needed.

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 schema has 50% description coverage: obligation_id has an example (DORA-TPR-03) but entity_id is bare. The description adds no parameter meaning, failing to clarify what entity_id represents or how the two parameters relate to proving an obligation.

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 states a specific verb ('Prove') and resource ('obligation fulfilled'), with a useful qualifier ('without showing evidence') that hints at a zero-knowledge proof. It distinguishes from sibling tools like verify_* by focusing on generating a proof, though it doesn't explicitly name 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 guidance is provided on when to use this tool versus siblings or when not to use it. The description is a single claim with no context about prerequisites, scenarios, or exclusions.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavior. It only states the purpose ('Connectivity test') without explaining what the tool actually does, what output it returns, or any side effects. This is a significant transparency gap.

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?

While the description is short with no fluff, it is under-specified rather than concise. 'Connectivity test' conveys almost no actionable information, and the brevity does not serve the agent's need for understanding.

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?

Given the tool's simplicity (no params, no output schema), a brief description could suffice, but this one lacks essential details such as what the test verifies, how results are reported, or how it differs from similar sibling tools like health_check. The description is incomplete for reliable tool selection and invocation.

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 has zero parameters, so the schema is fully covered. The baseline for 0 params is 4, and the description adds nothing about parameters because none exist. This is appropriate.

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 "Connectivity test" merely restates the conventional meaning of 'ping' without a specific verb or resource. It does not distinguish the tool from siblings like health_check, which could serve a similar purpose.

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 guidance is given on when to use this tool versus alternatives. The description provides no context for appropriate use, prerequisites, or exclusions.

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

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

The phrase 'hashes instead of raw data' is a useful behavioral disclosure, indicating a privacy-preserving output. However, with no annotations, the description must carry more context about side effects, read-only nature, or permissions, which are absent.

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 extremely short, but it is a fragment and under-specified rather than appropriately concise. It omits critical details about the report's content, return value, and usage, so it does not earn its place as a complete description.

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 tool with one optional parameter, no annotations, and no output schema, the description provides minimal context. It fails to clarify what the report contains, when it should be used, or how entity_id affects the output, making the tool contextually incomplete.

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 input schema defines one parameter, entity_id, but the description does not explain its purpose or expected format. With 0% schema description coverage, the tool description fails to compensate, leaving the parameter semantically opaque.

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 'Privacy-preserving report: hashes instead of raw data' is a noun phrase rather than a clear action statement. It implies the tool produces a report with hashed data, but lacks a specific verb like 'generates' or 'returns' and does not distinguish this from sibling tools such as audit_proof or obligation_proof.

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?

There is no guidance on when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusions, leaving an agent without criteria to select it.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only states the transformation (disclose fields, hash the rest) but omits critical details such as what entity_id is used for, whether the tool reads an existing credential, what the output format is, or if there are side effects. This is insufficient for a privacy-sensitive tool.

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 seven words long and immediately front-loads the action. Every word is meaningful with zero redundancy, achieving maximum conciseness while still conveying the core function.

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?

The description omits essential context: what entity_id references, how the underlying data is obtained, what the return value looks like, and how this relates to siblings like create_commitment. With no output schema and no annotations, the tool is not adequately described for an AI to invoke it correctly without guessing.

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 50%: 'disclose' has a description, but 'entity_id' does not. The tool description adds minimal meaning for 'disclose' (implied as the list of fields to reveal) but completely ignores 'entity_id', failing to compensate for the schema gap. The agent would not know what entity_id refers to.

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 uses a clear verb 'Disclose' and specifies the operation of hashing remaining fields, unambiguously conveying the tool's role in selective disclosure. It doesn't explicitly name the resource type (e.g., credential) but the action is sufficient to distinguish it from creation or verification siblings.

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 guidance is provided on when to use this tool versus alternatives like create_commitment or verify_merkle_proof. The description lacks any mention of appropriate contexts, exclusions, or sibling tools that might be more suitable for specific use cases.

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

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

No annotations are present, so the description must disclose behavioral traits. It does state the key behavior of proving without revealing the score, but it omits other important aspects such as the return value, side effects, or any prerequisites. The behavioral disclosure is minimal and incomplete.

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, front-loaded sentence with no filler. It efficiently conveys the core purpose without wasting words, and the structure is clear and direct.

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?

Given the absence of annotations, output schema, and incomplete parameter documentation, the description is not complete. It does not state what the tool returns, how the entity_id should be supplied, or when to use this proof over others. For a simple tool, more context is expected.

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 50%: threshold is described in the schema, but entity_id has no description. The tool description does not clarify what entity_id represents or how it is used, nor does it add any detail beyond the schema. The description fails to compensate for the missing parameter documentation.

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 uses a specific verb ('Prove') and clearly identifies the resource (a threshold condition on a score). It explicitly states the zero-knowledge property ('without revealing exact score'), which distinguishes it from sibling tools like selective_disclosure or obligation_proof.

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?

There is no guidance on when to use this tool versus alternatives. The description does not mention preferred contexts, exclusions, or scenarios where another proof tool would be more appropriate. No when-to-use information is provided.

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

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

No annotations are provided, leaving the description to fully disclose behavior. It only states the action but does not explain outcomes, return formats, permissions, or any side effects.

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 short sentence with no unnecessary words, but its brevity comes at the cost of detail. It front-loads the action but leaves ambiguity about the context.

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?

Given one parameter and no output schema, the description provides minimal context. It does not explain what 'current state' means or what a successful verification returns, leaving the agent under-informed.

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 single parameter commitment_id lacks a schema description and the tool description does not mention it. With 0% schema coverage, the description fails to compensate and adds no meaning beyond the parameter name.

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 the verb 'verify' and resource 'commitment', clearly indicating the tool validates a commitment. It distinguishes from siblings like verify_merkle_proof and verify_vc by focusing on commitments, though 'current state' adds some ambiguity.

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?

There is no explicit guidance on when to use this tool versus alternatives like verify_merkle_proof or verify_vc. No context, prerequisites, or exclusions are provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states 'verify' without mentioning read-only status, error behavior, side effects, or assumptions about the tree/evidence, which is insufficient for safe invocation.

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 short sentence, but it is under-specified rather than appropriately concise. It lacks necessary details, so it fails to earn its place as an adequate description.

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?

Given the tool's moderate complexity, absence of annotations, and lack of output schema, the description is incomplete. It doesn't explain what constitutes a Merkle proof, how the tree/evidence IDs are used, or what happens on invalid proofs, leaving major gaps.

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 0%, and the description does not explain tree_id or evidence_id. The names give some hint, but the relationship between them and the verification process is unclear, so the description adds no meaning beyond the schema field names.

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 states a specific verb (verify) and resource (evidence in merkle tree). However, it does not distinguish this from sibling proof tools like audit_proof or threshold_proof, so it stops short of a 5.

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 guidance is provided on when to use this tool versus alternatives. The description gives no context, exclusions, or examples, leaving the agent to infer usage 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.

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

With no annotations provided, the description carries the full burden of disclosure, but it only states 'verify,' which implies a read-only action. It doesn't disclose whether this is a safe operation, what the return value is, whether it calls external services, or how errors are handled.

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 one concise sentence with no redundant words, making it efficient. However, the extreme brevity borders on under-specification, so while it earns points for no fluff, the lack of detail is a drawback.

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?

Given the tool's simplicity (one parameter, no output schema, no annotations), the description is the only source of information, but it fails to cover return values, expected behavior, error conditions, or the meaning of 'integrity.' It is fundamentally incomplete.

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 input schema contains a single 'credential_id' string, but the description doesn't mention this parameter at all. With 0% schema description coverage, the description should explain the parameter's format or purpose, but it adds no semantic value.

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 provides a clear verb ('Verify') and a specific resource ('credential'), with 'integrity' adding a qualifier that distinguishes it from other verification tools like verify_commitment. However, it doesn't explain what 'integrity' entails, so the purpose is partially ambiguous.

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?

The description offers no guidance on when to use this tool, prerequisites, or how it compares to alternatives such as verify_commitment or audit_proof. There is no mention of exclusions or preferred scenarios, leaving the agent without direction.

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