Innovalyxx Sovereign Edge

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

With readOnlyHint=false, the tool may not be read-only, and the description does add context: it charges $0.50 per call and returns JSON alignment scores. It does not, however, disclose whether the report is persisted as a side effect, what happens if stored IATP/ABV data are missing, or any auth/rate-limit requirements, so the description only partially carries the behavioral burden.

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?

Three sentences, each earning its place: function, output, and cost/compliance. The core action is front-loaded, and there is no filler.

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 single-parameter tool with an output schema, the description is largely complete: it identifies inputs, sources, output, cost, and compliance context. It is only missing explicit routing guidance against the highly similar sibling get_tevv_alignment and side-effect clarity, which prevents a perfect score.

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%, and the agent_id schema description already explains what the identifier is used for ('score against the NIST AI 200-2 TEVV-Athlon mapping'). The free-text description adds no parameter-specific meaning, so the baseline of 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?

Description states a specific action ('Issue a TEVV-Athlon assessment report'), the data sources ('stored IATP reputation and ABV maturity'), and the return type ('JSON alignment scores'). It is clear about what it does, but it does not explicitly differentiate itself from the closely named sibling get_tevv_alignment, so it stops short of 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?

The phrase 'from stored IATP reputation and ABV maturity' implies this tool should be used after those inputs are already available, and the compliance/cost lines add context. However, it never states when to choose this over alternatives like get_tevv_alignment or run_abv_assessment, nor gives 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?

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds useful non-obvious context: the response is a JSON score, there is a per-call cost of $0.01, and there is a compliance note. No contradiction with 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 short, front-loaded with the main action, and generally efficient. The line about compliance is cryptic, and 'Returns JSON score' is partially redundant with the output schema, but overall it is a compact definition.

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 simple single-parameter read tool with strong annotations and an output schema, the description is nearly complete, including cost and return shape. The main missing piece is guidance on when to use run_abv_assessment instead of this tool.

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% and the single agent_id parameter is already fully described. The description repeats the score range but adds no new parameter semantics beyond what the schema provides.

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 ('Retrieve'), names the exact resource ('stored ABV maturity score'), and gives the value range (0-100). Saying 'stored' distinguishes it from the sibling run_abv_assessment without needing to name it.

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 implies use for reading an already-stored score, but it does not explicitly say when to prefer this over run_abv_assessment or other sibling tools. There is clear context but no exclusionary guidance or named alternatives.

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?

Annotations already mark this as read-only and idempotent, so the description's main burden is to add useful context. It does so by disclosing that results are estimates, that output is JSON, that the call has a £0.01 cost, and that it references EU AI Act Art. 50 and schema.org. This goes beyond the structured annotations without contradicting them.

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 four short sentences with no filler. 'Returns JSON visibility metrics' is slightly redundant with the opening clause and the output schema, but the compliance and cost statements are distinct and valuable, so the overall structure is efficient and front-loaded.

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?

This is a low-complexity, single-parameter read tool. The description states what metrics are returned, labels the estimates, gives the JSON return shape, and adds operational context (cost, compliance). Combined with the read-only annotations and the output schema, nothing an agent needs in order to invoke it correctly is missing.

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%, and the single 'url' parameter is already clearly documented as the merchant URL whose metrics should be returned. The description merely repeats 'merchant URL' and adds no format, normalization, or edge-case detail, so it adds no semantic 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 opens with a specific action ('Retrieve') and a specific resource ('estimated LLM mention rate and GEO score for a merchant URL'), and names the return type. The named metrics make it distinguishable from sibling tools like get_agent_maturity or run_geo_audit, which focus on different concepts.

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 tool's intended use is implied by 'for a merchant URL' and 'Retrieve estimated LLM mention rate and GEO score', but the description gives no explicit condition, no exclusions, and no pointers to an alternative tool. It does not help an agent decide between this and the many similar-looking sibling 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?

Annotations already indicate a safe, read-only, idempotent operation. The description adds useful behavioral context beyond the annotations: it returns a JSON alignment document and costs $0.01 per call, which informs the agent about output format and billing.

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?

Four short, information-dense sentences with no waste. The action and resource are front-loaded, followed by output, compliance, and cost details that all earn their 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 the tool's low complexity (one parameter), an existing output schema, and annotations covering read-only/idempotent behavior, the description is complete. It covers what is returned, compliance relevance, and cost, so an agent has what it needs to call 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 single 'format' parameter is fully documented in the schema with enum 'json' and a clear description, so schema coverage is 100%. The tool description does not add additional parameter meaning, which matches the baseline expectation.

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: 'Retrieve NIST AI 200-2 TEVV-Athlon mapping for IATP, ABV, FACT, and Lean 4.' This clearly identifies the tool's purpose, though it does not explicitly differentiate it from the sibling generate_tevv_report.

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 about when to use this tool versus alternatives like generate_tevv_report. The compliance references imply a context, but no exclusionary or selection guidance is provided for an agent to choose confidently.

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?

Annotations already cover idempotentHint=true and destructiveHint=false. The description goes beyond by disclosing a $0.50 per-call cost, the compliance frameworks (EU AI Act Art. 14, KYA-OS, IETF AID), and the return format (Ed25519 envelope). These are genuinely useful behavioral disclosures not present in structured fields. No contradiction with 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?

Three terse sentences with the core purpose front-loaded. The compliance sentence adds context but is somewhat niche for agent selection; still, it earns its place by signaling regulatory relevance. No redundant phrasing or filler.

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 output schema covers the return value (Ed25519 envelope), so the description need not explain it. Cost, compliance, and signature algorithm are all present. The main gap is missing when-to-use guidance relative to the verification siblings, but for a self-contained issuance tool with full param coverage, it is otherwise complete.

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% and both parameters are already well-described in the schema (agent_did recipient, capabilities optional strings recorded on the attestation). The description only echoes 'optional capabilities' and adds no syntax, format, or constraint details beyond the schema. Baseline 3 applies since the schema does the heavy lifting.

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?

Clear verb (Issue) + resource (signed trust attestation) + target (agent DID and optional capabilities), with a specific signature algorithm (Ed25519). It implicitly differentiates from the verification siblings (verify_agent_attestation, verify_agent_trust, verify_agent_reputation) since this is the creation counterpart. An agent can tell what this tool is for immediately.

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 constext is implied by the verb 'issue' — the agent must create a signed attestation. However, no explicit when-to-use vs. alternatives guidance is given, no exclusions are stated, and the distinction from verification tools is left to inference. The compliance and cost details hint at context but do not route the agent explicitly.

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?

Annotations provide no read-only, openness, idempotency, or destructiveness signals, so the description carries the full burden. It discloses the server does not store the attestation and the cost ($0.01 per call), which is useful. However, it does not describe potential side effects on the memory entry, error behaviors, or authorization prerequisites beyond what's in the schema. It adds some transparency but leaves 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?

The description is three sentences, front-loaded with the primary action, and includes only essential extras (cost, compliance). No redundancy; efficient and well-structured.

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 output schema exists and schema descriptions cover all parameters, the description covers purpose, cost, and storage behavior. However, it does not explain scenarios where this tool is preferred over alternatives, and it omits potential side effects or failure modes. It is adequate but not exhaustive.

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 the schema already explains each parameter. The description does not add parameter-specific information beyond what's in the schema. It only mentions the entry generically, which doesn't add semantics. A baseline 3 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 states a specific action ('Issue an Ed25519-signed portable attestation') on a specific resource ('a memory entry'), and differentiates it from siblings like memory.write and issue_agent_attestation by emphasizing portability and offline verification. It is clear and specific.

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 implies usage for offline verification ('Returns envelope for offline verify') and mentions server non-storage, but does not explicitly compare to sibling tools like memory.verify_attestation or issue_agent_attestation, nor state when not to use it. There's only implicit context, no explicit when/when-not guidance.

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?

Annotations only indicate it is not read-only, not idempotent, and not destructive. The description adds real behavioral context: it writes an immutable consent row, returns a grant receipt, and carries compliance and cost implications. This fills in a fair amount beyond the annotations, though it could further disclose the effect of repeated grants or revocation.

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?

Three sentences convey the core action, the result (receipt and immutable row), compliance context, and cost. Every sentence contributes meaningful, non-obvious information. The most essential purpose is front-loaded, and there is no filler.

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 fairly complex mutation tool with 8 parameters and an output schema, the description covers the key behavioral facts and financial/legal constraints. It is slightly light on prerequisites for the wallet_signature and any explicit pointer to revocation, but the output schema and thorough input schema compensate.

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 already provides descriptions for all 8 parameters (100% coverage), so the baseline is 3. The description does not add parameter-level meaning beyond the schema; it only refers generically to 'specified memory entries.' Thus it neither hurts nor improves the agent's understanding of the parameters.

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 opens with a specific verb ('Grant'), the resource ('memory entries'), the recipient ('another wallet') and the scoping constraint ('time-bounded'). This clearly distinguishes it from siblings like memory.revoke (which removes access) and memory.write (which writes memory content). An agent can assign the tool's role immediately.

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 clearly conveys when to use the tool: to give another wallet temporary, category-scoped access to memory entries. It does not explicitly name alternatives or state when not to use it, so it misses the full when-not guidance, but the intended context is unambiguous from the phrasing.

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?

Annotations already cover readOnly, idempotency, and non-destructiveness, and the description adds valuable behavioral context: the result is non-binding, the 402 list price is unchanged, GDPR Art. 5 compliance applies, and each call costs $0.01. No contradiction with 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 compact and front-loaded with the core action before supporting details. Each sentence contributes functional context, though 'Returns JSON hint' is somewhat redundant given the output schema.

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 read-only, idempotent tool with full schema coverage and an output schema, the description covers key contextual aspects: cost, compliance, non-binding nature, and unchanged list price. It does not explain how the tool relates to other memory pricing tools, but that is more of a usage-guidelines 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?

Schema description coverage is 100%, so the parameters are already well-documented. The description adds no additional meaning about entity_id, tool_name, owner_wallet, or wallet_signature beyond what the schema provides, matching the baseline.

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 clear action ('Retrieve') and a specific resource ('signed, non-binding recommendation of verification-call cost from memory'), and clarifies the outcome ('Returns JSON hint'). It does not explicitly differentiate from related memory tools like memory.subscription_quote, 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?

The description implies usage in a pricing-context scenario but gives no explicit guidance on when to use this tool versus alternatives such as memory.subscription_quote or memory.query. No exclusions, prerequisites, or alternative routing 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?

Annotations declare readOnlyHint=true and idempotentHint=true, and the description adds the crucial fact that it returns ciphertext, never plaintext, which is a significant behavioral disclosure that the annotations do not cover. It also mentions cost per call and compliance references, adding context beyond annotations. No contradiction with 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 concise, with three sentences, but it front-loads the key purpose and critical behavior (ciphertext) before legal/cost details. It is not overly verbose and every sentence adds value.

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 has 12 parameters, a complex output schema (output schema exists), and the description covers the key behavioral aspects (ciphertext, signature requirement), it is reasonably complete. However, it does not detail return value structure, pagination, or error scenarios, which might be expected for a query tool with such rich filters.

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 the schema documents all parameters. The description lists some filter dimensions (entity_type, category, tags, time range) but adds little detail beyond what the schema gives. For example, the schema already describes each parameter. The description does not introduce new semantics that aren't already in 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 specifies the verb 'Query' and the resource 'owner memory entries' with clear filter dimensions. It distinguishes from likely write tools (memory.write) and read tools (memory.read) by focusing on querying with filters corrected. However, it doesn't explicitly differentiate from memory.read, though the mention of filters and metadata suggests a more advanced read.

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 states it requires a wallet signature, which implies when authentication is needed, but it does not explicitly say when to use this vs memory.read or when not to use it. The context is clear for querying filtered memory, but no alternatives are mentioned.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context beyond annotations: it discloses that the tool returns ciphertext, nonce, and content_hash (never plaintext), requires a wallet signature, and mentions GDPR compliance and cost. This is meaningful additional transparency about the operation's nature and constraints.

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 three sentences with zero waste. It front-loads the core action and return type, then adds the signature requirement, compliance note, and cost. Every sentence earns its place, and the structure is scannable for an agent.

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 tool has an output schema, so return values need not be explained in the description. The description covers the essential context: what is returned, the signature requirement, compliance, and cost. It does not explicitly explain the owner vs. grantee role distinction or the deterministic read message, but the schema covers those parameter details. For a read-only tool with rich schema and annotations, this is nearly complete.

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 the schema already documents all 7 parameters thoroughly. The description adds a high-level note about requiring a wallet signature, which maps to the wallet_signature parameter, but it does not add meaning beyond what the schema provides. Baseline 3 is appropriate because the schema carries the heavy lifting.

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 ('Retrieve'), a resource ('client-encrypted memory entries'), and a target ('for an entity'). It also distinguishes the tool's core behavior from siblings like memory.write and memory.query by emphasizing that it returns ciphertext, nonce, and content_hash, never plaintext. This makes the tool's purpose immediately clear and distinct.

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 provides clear context: it requires a wallet signature and is for retrieving encrypted memory entries. It does not explicitly name alternatives or state when not to use this tool, but the sibling list includes memory.query and memory.write, and the description's emphasis on 'never plaintext' implies a read-only, client-encrypted access path. The absence of explicit exclusions or alternative routing keeps this from a 5.

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?

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context beyond annotations: it returns a JSON revocation receipt, cites GDPR Art. 7/17 compliance, and states the per-call cost. It does not contradict 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?

Three short sentences with the core action front-loaded. Each sentence adds distinct information: operation, return value, compliance, and cost. There is no fluff or repetition of schema details.

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 simple three-parameter mutation with an output schema and annotations, the description covers the operation, return format, compliance, and cost. It does not describe error behavior for already-revoked or invalid grants, but the output schema likely covers that, so the description is sufficiently complete.

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%, and each parameter (grant_id, grantor_wallet, wallet_signature) already has a clear schema description. The tool description adds no parameter-specific meaning beyond what the schema provides, 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?

The description uses a specific verb ('Revoke') with a precise resource ('previously issued memory grant') and adds the temporal qualifier 'immediately'. This clearly distinguishes it from sibling tools like memory.grant and memory.attest without requiring schema inspection.

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 'previously issued memory grant' implies this tool is for existing grants, but it does not explicitly state when to use it versus memory.grant or other memory tools. No when-not-to-use or alternative routing is provided, so usage guidance is only implicit.

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?

Beyond the readOnly/idempotent/destructive annotations, the description adds valuable behavioral details: it returns JSON, requires x402 prepaid funding, costs $0.01 per call, and cites GDPR compliance. This goes well beyond the structured annotations and helps the agent anticipate side effects and costs.

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 three short, information-dense sentences. It front-loads the core purpose and then adds cost, funding, and compliance details without redundancy or irrelevant fluff.

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 small parameter set, full schema coverage, output schema presence, and safety annotations, the description provides enough operational and business context. It covers purpose, return format, payment model, compliance, and cost, making the tool fully actionable.

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 schema already documents all three parameters. The description only indirectly maps 'wallet' to owner_wallet and 'signed' to wallet_signature, adding no meaningful parameter-level semantics 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 uses a specific verb ('Retrieve') and a specific resource ('signed, non-binding monthly subscription quote for a wallet'). This clearly distinguishes the tool from siblings like memory.pricing_hint or memory.read, which cover different semantics.

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 intended scenario is implied: use it when a wallet needs a signed monthly subscription quote. However, it does not explicitly say when to prefer this over related tools such as memory.pricing_hint, nor does it state exclusions or prerequisites beyond what the schema already requires.

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?

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds valuable beyond-annotation context: it guarantees no ciphertext is returned, cites GDPR compliance, and states a per-call cost. These are behavioral traits an agent would otherwise not know.

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?

Three concise sentences, each earning its place: the main action and scope, the critical safety guarantee, and the compliance/cost operational details. All essential information is front-loaded in the first sentence, with no filler or repetition of schema content.

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 a full output schema and 100% parameter documentation, the description needs to cover only behavioral and operational context, which it does well (sensitivity, compliance, cost). It could go slightly further by explicitly naming a sibling alternative, but that is a usage-guidance refinement rather than a missing piece.

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 the schema fully documents all four required parameters including entity_id, tool_name, owner_wallet, and wallet_signature. The description does not add parameter-level meaning beyond what the schema already provides, so the baseline of 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?

The description opens with the specific verb 'Retrieve' and the resource 'non-sensitive metadata on prior tool invocations for an entity', followed by concrete fields (count, timestamps, last hash). This clearly distinguishes it from memory.read/query, which likely return content, and the phrase 'Never returns ciphertext' reinforces what the tool is and is not.

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 provides clear context: it is a metadata-only retrieval tool, safe in terms of sensitivity, and with a stated cost. It does not explicitly name when to use it over siblings like memory.read, but the 'never returns ciphertext' statement strongly implies it is for non-sensitive metadata access, giving an implicit exclusion.

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?

Annotations already indicate read-only, idempotent, and non-destructive behavior conocimiento. The description adds value by specifying the return format (JSON validity result), offline verification capability, compliance (GDPR), and cost. This goes beyond annotations by providing operational and compliance context.

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 concise (three sentences) and front-loaded with the core action. The compliance and cost details are useful but placed at the end, which is acceptable. No wasted words, but could be slightly more structured with a clear use-case statement.

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 (1 parameter, output schema present), the description is adequate. It covers key aspects: what it does, output type, offline capability, compliance, and cost. With the output schema and annotations, the agent has enough to invoke it correctly. It lacks explicit error scenarios or edge cases, but those are not critical for this context.

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 the parameter 'envelope' is already described. The description does not add further detail about the envelope structure or required fields beyond what the schema provides万余字. It meets the baseline but does not exceed it.

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 the tool verifies a memory attestation envelope against the platform key registry. It identifies the specific action (verify), the resource (attestation envelope), and the context (platform key registry). However, it could better distinguish from siblings like verify_agent_attestation, though the 'memory' prefix provides some differentiation.

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 implies usage for verifying envelopes and mentions offline verification, but it does not explicitly state when to use this tool versus alternatives like verify_agent_attestation or when not to use it. No prerequisites or specific conditions 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?

The description substantially extends beyond the annotations by disclosing client-side encryption, 'Server never sees plaintext (PBKDF2/AES-256-GCM)', wallet-signature auth, JSON receipt return, GDPR compliance, and per-call cost. This gives an agent crucial behavioral and operational context that annotations alone do not provide.

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 compact and well-structured: purpose first, then security/auth behavior, then receipt and compliance/cost notes. Every sentence contributes substantive operational information without redundancy.

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 12-parameter cryptographic write tool, the description covers purpose, security, auth, return type, compliance, and cost. The output schema and full input schema already cover return and parameter details. A slight gap is the lack of explicit retry/idempotency implications, though the idempotentHint=false annotation partially covers this.

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 3tons but the description adds meaningful context: 'client-encrypted' links to ciphertext/nonce/hash parameters, 'Requires wallet signature' clarifies owner_wallet and wallet_signature, and the encryption details help explain the required content fields.

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-resource pair: 'Store a client-encrypted memory entry for an entity.' It clearly identifies the write operation and differentiates from siblings like memory.read, memory.query, memory.revoke, and memory.attest by emphasizing client-side encryption and entity-scoped storage.

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 providedgett. The description does not name any alternatives or conditions, leaving the agent to infer usage solely from the tool name and sibling context.

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?

All annotations are false and carry no safety profile, so the description bears the full disclosure burden. It adds substantial value: discloses the £150 per-call cost, the non-certificate legal status, the returned attestation format, and the compliance regime. An agent is clearly warned this is a paid, state-changing request (readOnlyHint=false), matching the 'request' verb in the name.

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?

Four sentences, zero waste. Core purpose is front-loaded in the first sentence, then output type, then compliance, then the dual-cost/legal disclaimer packed efficiently into the final sentence. Nothing redundant — 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?

An output schema exists, so return format is documented elsewhere. The description covers purpose, method, output, proof mechanism, compliance context, cost, and legal exclusions. Minor gaps — prerequisites, rate limits, and error/queuing behavior for the paid request — exist, but the description is rich enough for an agent to invoke 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 100% and each parameter is well-documented with examples, constraints, and the NDVI range already enforced. The description adds no parameter-level detail beyond the schema — the Lean 4 verification mechanics for claimed_ndvi_min are already present in the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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 ('Verify'), the resource ('carbon project's MRV claim'), the method (Sentinel-2 and MWCM-Oh), and the exact output (signed Ed25519 attestation with Lean 4 proof hash). These details differentiate it from sibling verification tools like verify_biodiversity and verify_site_certification, and the 'Not a carbon credit certificate' disclaimer prevents confusion with credit-related tools like issue_agent_attestation.

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?

Provides implied usage context through compliance references (EU AI Act Art. 14, ISO 14064-3) and a practical cost signal (£150 per call), but never names sibling alternatives or states explicit when-to-use/when-not-to-use conditions. The 'Not a carbon credit certificate' disclaimer is a weak negative constraint, not real routing guidance.

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?

Annotations provide no safety profile (all hints false), so the description carries the full burden. It does disclose cost ($0.50/call), compliance constraints, and the JSON result shape, which is useful. But it does not state whether the call has side effects, requires auth, or has rate limits, leaving mutability ambiguous.

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?

Three short sentences: purpose, output, compliance/cost. No filler, and the most important information is front-loaded. Every sentence 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?

The description covers purpose, output, compliance, and cost, and an output schema exists to describe return values. However, for an 8-parameter tool with nested objects, it omits when-to-use guidance and side-effect clarity, making it adequate but not strong.

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 the schema already documents all 8 parameters. The description adds no parameter-specific guidance beyond what the schema provides, so the baseline 3 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 clearly states the tool verifies pre-deployment agent behavior against a Worker Remit and returns JSON maturity, gaps, and recommendations. It identifies a unique purpose (ABV, Worker Remit) that distinguishes it from sibling verify/get tools, but it never explicitly names a sibling or contrast, so it does not fully meet the 5 criterion.

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 'pre-deployment' qualifier gives clear context for when this assessment is appropriate, and the output/cost/compliance notes reinforce its evaluation role. However, no explicit when-not-to-use guidance or alternative tool names are provided, so it falls short of a 5.

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 annotations already provide readOnlyHint=false and openWorldHint=true; the description adds valuable call-time behavior by disclosing the £99 per-call cost and the compliance scope (EU AI Act Art. 50, schema.org). It does not detail side effects or whether an audit record is persisted, but 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 three short sentences with no filler: it front-loads the action and target, then gives the output shape, compliance scope, and cost. Every sentence contributes a distinct piece of decision-relevant 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?

For a 3-parameter tool with a full output schema, the description covers the essential invocation facts: what is audited, what is returned, compliance constraints, and pricing. It lacks explicit when-to-use guidance relative to siblings, but that gap is already captured under usage_guidelines, so invocation-level completeness is strong.

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%, and each parameter already has meaningful documentation, including the agent-card default path and the HTTPS requirement for url. The description's mention of 'schema.org, feed, agent-card' loosely maps to the parameters but adds no semantic detail beyond what the schema already provides, so the schema-heavy baseline of 3 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 opens with a specific verb-resource pair: 'Verify generative-engine optimization for a merchant URL' and enumerates the audited surfaces (schema.org, feed, agent-card). It also states the return type, a JSON GEO score with gaps, which clearly distinguishes it from generic verification tools in the sibling list.

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 implies when to use the tool by framing it as a merchant GEO audit and noting compliance and cost, but it never explicitly states when to prefer it over alternatives such as run_abv_assessment or get_agent_visibility. There are no exclusions or 'use this instead when...' conditions, so the guidance is implied rather than explicit.

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?

Annotations already cover readOnly, idempotent, non-destructive, and non-open-world behavior. The description adds useful extra disclosure: the verification is fail-closed, returns a JSON validity result, cites compliance frameworks, and costs $0.02 per call. This complements the annotations without contradicting them.

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 compact and front-loaded with the core purpose. The following sentences add relevant operational details (fail-closed, JSON result, compliance, cost) without verbose fluff. It is not perfectly minimal because compliance citation names are somewhat lengthy, but every segment 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 the high schema coverage, annotations, and an output schema, the description is largely complete: it states the input purpose, key behavioral trait, return type, and compliance framing. It does not explain the shape of the attestation envelope beyond the schema's own description, but the output schema and parameter schema reduce that burden.

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%, and the schema already describes agent_did as an optional DID that must match the attestation agent_id, as well as the attestation object. The description does not add substantial parameter-level meaning, so the baseline score of 3 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 clearly names the verb ('Verify') and a specific resource ('an agent's IATP codebase/config attestation') and adds technical detail ('Ed25519, fail-closed'). This is more specific than just the tool name, though it does not explicitly distinguish itself from siblings like verify_agent_trust or memory.verify_attestation, so it falls just 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?

The description gives no direct guidance about when to use this tool versus alternatives such as issue_agent_attestation, verify_agent_trust, or memory.verify_attestation. The compliance references imply compatibility, but there is no explicit when-to-use, prerequisites, or 'use instead' guidance.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: the score is specifically 'after FACT slashing', the output is JSON with score and trust level, and there is a cost of $0.01 per call. It does not contradict annotations. It could have disclosed rate limits or whether the score is cached, but the added context is meaningful.

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?

Three sentences with zero waste. The core action and output are front-loaded, followed by compliance and cost details. Every sentence earns its place, and the description is compact enough to be parsed quickly by an agent.

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 single-parameter read-only tool with a full output schema and complete schema coverage, the description is nearly complete. It covers what the tool returns, the context (FACT slashing), compliance, and cost. The only minor gap is that it doesn't describe error conditions or rate limits, but these are not essential for a simple read operation with annotations already covering safety.

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 the schema already fully documents the single parameter (agent_did). The description adds the context that the score is an IATP reputation trust score after FACT slashing, which reinforces the parameter's purpose, but it does not add new syntax or format details beyond the schema. Baseline 3 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 states a specific verb ('Retrieve'), a specific resource ('an agent's IATP reputation trust score'), and a precise scope ('after FACT slashing'). It also names the output format ('JSON score and trust level') and the score range (0-10), which distinguishes it from sibling tools like verify_agent_trust or get_agent_maturity. The title and description align, and the tool's purpose is immediately clear.

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 implies when to use this tool: when you need an agent's IATP reputation trust score after FACT slashing. It also lists compliance frameworks (EU AI Act Art. 14, KYA-OS, IETF AID) and cost, which gives context for selection. However, it does not explicitly state when NOT to use it or name alternatives like verify_agent_trust, so it falls short of a 5.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: returns a signed Ed25519 envelope, fail-closed attestation, compliance references, and cost per call. This goes beyond what annotations provide.

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?

Three sentences with zero waste. The core purpose is front-loaded, followed by the return type, behavioral guarantee, compliance context, and cost. Every sentence 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?

The tool has an output schema, so return values are documented elsewhere. The description covers purpose, return type, behavioral guarantee, compliance, and cost. It could mention what 'fail-closed' means in practice or when verification would fail, but for a read-only verification tool with an output schema, this is largely complete.

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 the schema already documents both parameters (agent_did and context). The description adds the default context value ('mrv_verification') and an example DID format, which is helpful but not extensive. Baseline 3 is appropriate since the schema carries the parameter documentation 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 clearly states the tool verifies an AI agent's identity (KYA-OS DID) and behavioral trust score, and returns a signed Ed25519 TrustVerification envelope. It distinguishes itself from siblings like verify_agent_attestation and verify_agent_reputation by focusing on identity + trust score with a fail-closed attestation.

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 implies when to use this tool (verifying an agent's identity and trust score) and mentions compliance context (EU AI Act Art. 14, KYA-OS). It doesn't explicitly name alternatives or exclusions, but the sibling list and the specific KYA-OS DID focus provide enough context for an agent to select it over verify_agent_attestation or verify_agent_reputation.

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?

Annotations already establish the tool as read-only, idempotent, and non-destructive, and the description adds meaningful behavioral context beyond those: it returns a signed Ed25519 attestation, includes a Lean 4 NDVI proof, is compliance-relevant, is not a tradable credit, and costs £150 per call. The 'Returns signed attestation' phrasing does not contradict readOnlyHint because it describes an output, not a persistent state change.

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 compact and front-loaded: the primary purpose appears in the first sentence, followed by the key output and proof mechanism, then compliance and cost constraints. Every sentence earns its place; there is no filler, repetition, or boilerplate.

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 tool has a rich input schema, output schema, and safety annotations, and the description fills the remaining business and operational gaps: proof format, compliance, non-tradability, and cost. An agent has enough information to decide whether to call this tool, understand what it will receive, and avoid misuse.

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?

All three parameters are fully described in the input schema (100% coverage), so the baseline is 3. The description references claimed_score_min but the schema already explains that it is compared against the computed score, so the description adds little semantic value beyond the structured field definitions. It provides no additional detail about habitat_id or species_list beyond what the schema already gives.

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 ('Verify') with a clear resource ('a biodiversity claim for a geographic habitat') and a distinctive outcome ('signed Ed25519 attestation with Lean 4 NDVI proof'). This distinguishes it from sibling verification tools like verify_site_certification or verify_transaction_evidence, which target different resources. The 'Not a tradable credit' phrasing further sharpens what the tool is and is not.

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 gives clear context for when this tool is appropriate: verifying a biodiversity claim against a claimed minimum score, with regulatory compliance framing (EU AI Act Art. 14, TNFD). It also states an exclusion ('Not a tradable credit') and a practical constraint (cost £150 per call). It does not explicitly name alternative sibling tools or contrast them, so it stops just short of a 5.

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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is known. The description adds valuable context: returns a signed Ed25519 attestation, a 30-year compliance trail, compliance standards, and a cost range. This goes beyond the annotations and helps the agent anticipate output and financial impact.

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 three sentences with zero redundancy. It front-loads the primary purpose, then adds the return type and cost. Every sentence earns its place, making it highly concise and well-structured.

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 that annotations cover safety and an output schema exists, the description is largely complete. It explains the purpose, the return format, compliance standards, and cost. It does not mention any usage context or alternatives, but that is partially covered by the purpose statement. For a read-only verification tool, this is sufficient.

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 all three parameters are already described in the input schema. The description does not add extra meaning about the parameters themselves; it only references the development_ref in the context of the compliance trail, which is already in the schema. Baseline 3 is appropriate for high coverage.

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 the tool verifies city planning constraints for a development site, which is a specific verb-resource pair. It also mentions the return of a signed attestation and compliance trail, distinguishing it from generic verification tools. However, it does not explicitly name sibling tools or contrast with them, so it loses a point for lacking direct differentiation.

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 provides no guidance on when to use this tool versus the many other verify_* siblings. It does not state exclusions, prerequisites, or alternative tools. The purpose is implied, but there is no explicit usage direction, so this scores low.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds important non-obvious behavior: the return format (JSON passport with Lean 4 proof hash), legal compliance (EU AI Act Art. 14), and the £10 per-call cost. No contradiction exists.

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 three short sentences with no filler. It front-loads the core action and resource, then concisely states the return value, compliance note, and cost—each earning 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?

With only two fully documented parameters, an output schema, and safety-relevant annotations, the description provides sufficient extra context: return shape, proof hash, compliance, and cost. Nothing critical is missing for correct 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 input schema provides 100% coverage of parameter descriptions for skip_id and manifest_hash, so the description does not need to add parameter-level detail. It adds no additional semantics beyond the schema, so the baseline score of 3 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 uses an active verb, 'Verify', and identifies a distinct resource: the circular-economy Skip Passport against the waste-diversion twin. This differentiates it from sibling verify_* tools such as verify_biodiversity and verify_agent_trust.

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 provides clear operational context for what the tool does, but it does not explicitly state when to use this tool versus sibling verification tools or provide exclusion criteria. Usage is implied rather than explicitly routed.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful context beyond that: the return format is signed JSON with provenance, there is a $0.05 per-call cost, and the tool carries compliance obligations under EU AI Act Art. 14 and KYA-OS. No contradiction with 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 compact and front-loaded: the core action and target come first, followed by return format, compliance context, and cost. Every sentence earns its place, with no filler or repetition of schema details.

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 read-only, idempotent verification tool with a full output schema and well-documented parameters, this description covers purpose, return behavior, compliance context, and cost. It does not explicitly describe prerequisites beyond 'completed', but the schema and annotations make the tool safe and callable without much additional context.

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 the schema fully explains transaction_id, agent_did, and amount_usdc. The description does not add parameter-level meaning beyond that, but because the schema already carries the burden, a baseline of 3 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 clearly identifies the specific verb (verify) and resource (completed M2M transaction evidence pack, Lean 4 hash, and settlement). This is distinct from sibling tools like verify_agent_attestation or verify_site_certification, even without naming them, because the M2M transaction + evidence pack + Lean 4 hash scope is unique.

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 'Verify a completed...' implies when the tool is relevant and implies a prerequisite (the transaction must be completed). However, there is no explicit guidance about when not to use it or which sibling alternative to prefer, so usage guidance remains implied rather than explicit.

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