Japan Public Ledgers MCP

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

With no annotations, the description carries full burden. It only implies read-only via 'Query' but does not disclose behavioral traits like auth requirements, rate limits, or whether the operation is destructive. Minimal behavioral info.

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 sentence, but it underspecifies the tool. For a tool with 7 parameters and no schema descriptions, it is too concise; every sentence should provide value, and here it does not.

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 and no annotations, the description should explain what the tool returns, but it only mentions 'query agent actions' without describing result format, available filters, or any other contextual information. Completely inadequate.

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%, yet the description adds no meaning beyond 'with filters'. The 7 parameters (to, from, limit, agentId, riskMin, sessionId, actionType) are not explained; the agent cannot infer their formats or expected values from the description alone.

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 verb 'Query' and the resource 'agent actions', and mentions 'filters', indicating a filtering capability. However, it does not differentiate from sibling tools like agent_audit_record or agent_audit_report, lacking specificity for precise selection.

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 such as agent_audit_record (likely for a single action) or agent_audit_report (likely aggregated data). The description does not specify prerequisites or 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?

No annotations are provided, so the description carries full burden. It only says 'Record an agent action', implying mutation, but does not disclose whether it overwrites, idempotency, auth requirements, rate limits, or other behavioral traits. Minimal disclosure for a write operation.

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, which is concise but too brief given the complexity (7 parameters, no schema descriptions). It could include essential parameter guidance without being verbose; currently under-specified.

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 7 parameters, 0% schema coverage, no output schema, and no annotations, the description is fundamentally incomplete. It does not tell the agent what inputs are needed, how to structure the request, or what the response contains. Fails to provide a usable tool specification.

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 provides zero information about parameters. It does not explain what 'agentId', 'actionType', 'actionName', etc., mean or how to use them. The tool has 7 parameters, all left undocumented.

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 'Record an agent action for audit and compliance', which specifies a clear verb ('Record'), resource ('agent action'), and purpose. It distinguishes from siblings like 'agent_audit_query' (querying) and 'agent_audit_report' (reporting).

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; no mention of prerequisites, exclusions, or conditions. The description is too sparse to help an agent decide when to invoke 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?

No annotations provided. Description does not disclose side effects, authorization needs, rate limits, or whether the report is generated on-the-fly or stored. Lacks behavioral 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?

Single sentence, straightforward and front-loaded. No wasted words, but lacks necessary detail.

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

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

With no output schema, 4 parameters at 0% schema coverage, and minimal description, the tool definition is incomplete. Missing details on required parameters, report scope, and return format.

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%. Description only hints at the 'format' parameter (json/markdown/soc2), but does not explain 'agentId', 'from', or 'to' meanings. Leaves semantic gaps.

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 generates an audit report, with verb 'generate' and resource 'audit report', and lists supported output formats. It distinguishes from siblings like agent_audit_query and agent_audit_record by focusing on report generation.

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 (e.g., agent_audit_query). No prerequisites or use cases 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?

With no annotations provided, the description must disclose behavioral traits. It only says 'Solve a CAPTCHA' without detailing how the solving works, what it returns, or any side effects. This is insufficient for a complex 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 sentence with no wasted words, but it is overly brief given the tool's complexity. It sacrifices necessary detail for 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?

With no output schema, no parameter descriptions, and a vague description, the tool is severely incomplete. The agent cannot determine return format, error handling, or how to use different CAPTCHA types.

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%, so the description must compensate. It fails to explain any of the 6 parameters (type, action, pageUrl, etc.), leaving the agent without guidance on how to construct valid inputs.

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 verb 'Solve a CAPTCHA' and the resource 'domain you own', distinguishing it from sibling tools like agent_captcha_verify_domain which likely verifies ownership rather than solving.

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 mentions 'for a domain you own or have explicit permission to access', providing some usage context but no explicit when-not-to-use or alternatives. It implies a prerequisite with the sibling agent_captcha_verify_domain but does not specify.

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. The description does not disclose any behavioral traits such as consequences of verification, required authentication, rate limits, or what 'ownership' entails. It merely states the action without elaboration.

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, which is concise but at the expense of providing necessary detail. It front-loads the purpose but lacks structure or any additional sections.

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 and output schema, and only 2 parameters with 0% schema coverage, the description is insufficient. It does not explain what verification means, what the output looks like, or any side effects, leaving significant 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 adds no meaning to the two required parameters ('domain' and 'method'). The enum values for method are not explained, leaving the agent to infer their semantics from the enum names alone.

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 action ('Verify ownership') and resource ('domain'), with added context 'before using CAPTCHA solving' that hints at a prerequisite. It distinguishes from sibling 'agent_captcha_solve' but lacks explicit differentiation from other verification tools.

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 'before using CAPTCHA solving' implies a usage context, but there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites beyond the implied sequence.

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. The description only mentions the listing action and ordering, but does not disclose other traits such as rate limits, pagination behavior, error handling, or authentication requirements beyond the owner-only hint.

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 sentence of 11 words, very concise. It front-loads the verb and resource. However, it sacrifices detail for brevity, leaving parameter descriptions unaddressed.

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?

Despite the tool's simplicity (2 params, no output schema), the description lacks necessary details like parameter explanations and behavior for edge cases. It is minimally complete but insufficient for an agent to use reliably without 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 0%. The description indirectly references identityId by mentioning 'for an identity', but does not explain either parameter (identityId or limit) with any additional meaning 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 clearly states the verb 'List', the resource 'activity records for an identity', and includes ordering ('newest first') and access restriction ('owner only'). This distinguishes it from siblings like agent_identity_record or agent_audit_query.

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 a context clue ('owner only') but does not explicitly state when to use this tool versus alternatives like agent_audit_query, nor does it give any explicit when-to-use or when-not-to-use 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?

No annotations exist, so the description carries full burden. It implies read-only via 'Get' but omits details on permissions, error scenarios, or what the badge contains. Minimal disclosure.

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 extraneous words. Every word 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?

For a simple getter with one parameter and no output schema, the description is minimally adequate but lacks context about the badge structure or expected return value, which could help agents select and use 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 description coverage is 0%, and the description does not elaborate on the single parameter 'identityId'. No format, validation, or examples are provided.

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 verb 'Get' and the specific resource 'issuer-signed badge and signed fields', distinguishing it from sibling tools like agent_identity_lookup or agent_identity_register.

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, nor any prerequisites or exclusions. The agent must infer usage from the tool 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?

The description includes a useful caveat about signatureValid being only issuer+integrity, not an authenticity/safety signal. However, without annotations, it lacks disclosure of read-only nature or potential 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 very concise: two sentences, front-loaded with the verb, and no superfluous words. Efficiently communicates the core purpose and a key behavioral note.

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 one-parameter tool with no output schema, the description covers the action, return fields, and a caveat. However, the parameter explanation is missing, and the overall completeness is adequate but not comprehensive.

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 only parameter 'identityId' is not described beyond its name. With 0% schema description coverage, the description should explain the expected format or type, but it does not.

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 action ('Look up an identity') and the return fields (signatureValid and disclaimer). It is specific but does not explicitly distinguish from sibling tools like agent_identity_record or agent_identity_badge.

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 (e.g., agent_identity_activities or agent_identity_record). No exclusions or context for selection.

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 burden. It mentions 'hash-chained' implying immutability and ordering, but does not disclose error conditions, concurrency behavior, or whether it overwrites previous records. The 'self-reported' note for provenance adds a small behavioral hint, but overall transparency is low.

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 concise with two short sentences. However, this brevity sacrifices essential information, making it under-specified rather than efficiently compact. It front-loads the main action but omits needed 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?

The tool has 4 parameters (2 required), nested objects, and no output schema. The description does not explain the return value, the nature of 'hash-chained' from the caller's perspective, or prerequisites. It fails to provide a complete picture for safe and correct usage.

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 only 25%. The description clarifies the provenance parameter as 'self-reported' and 'NOT verified', but leaves identityId and activityType unexplained. content is completely unspecified. This adds some value but fails to document the majority of 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 states it appends a hash-chained activity record, which is a specific operation on a resource. However, 'owner only' is ambiguous and does not clearly distinguish it from sibling tools like agent_identity_register or agent_identity_activities. The purpose is somewhat clear but lacks 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?

No explicit guidance on when to use this tool versus alternatives. The mention of 'owner only' hints at access restrictions but doesn't clarify context for use or exclude any scenarios. Sibling tools are not 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?

With no annotations, the description carries the full burden. It discloses that agent_name and metadata are self-reported and unverified, and indicates outputs. However, it does not mention whether the operation is destructive, requires authentication, or has side effects, leaving significant behavioral 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 two sentences, front-loaded with the main purpose, and contains no extraneous information. 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's complexity (3 params, nested objects, no output schema), the description provides the core purpose and a caveat but lacks parameter details for publicKey, output format, and behavioral specifics. It is adequate but not fully comprehensive for an AI agent to use without 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 0%, so the description must compensate. It adds meaning for agentName and metadata (self-reported) but omits any mention of publicKey. The description partially covers 2 of 3 parameters, leaving a key parameter undocumented.

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 verb 'register' and the resource 'agent', and specifies the outputs: 'unique identity ID + issuer-signed badge'. The caveat about self-reporting distinguishes it from verification tools like agent_identity_lookup.

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 (for registering a new agent) but does not explicitly state when not to use or mention alternatives. The caveat about self-reporting provides some guidance but not sufficient for clear differentiation from 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?

No annotations provided, and the description does not disclose critical behavioral traits such as irreversibility, authentication requirements, or what constitutes 'all memories' deletion. For a destructive action, this is insufficient.

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 sentence with no unnecessary words, achieving conciseness. However, it could benefit from a slightly more structured format, e.g., indicating the effect of omitted vs. provided parameters.

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 and no annotations, the description is too sparse. The agent lacks information about return values, error conditions, or side effects, making it incomplete for a delete operation.

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 does not explain parameter meaning beyond their names. For instance, it doesn't specify whether 'key' is optional or how namespace interacts with key. This leaves ambiguity for the agent.

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 deletes memories, optionally all in a namespace, distinguishing it from get/search/store siblings. However, it could be more precise about the deletion behavior (e.g., key vs. namespace conditions).

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 vs. alternatives like agent_memory_store or agent_memory_get. The description lacks context about typical use cases or when to prefer this over other memory 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 exist, so the description must carry the burden. It only implies a read operation via 'retrieve' but provides no details on side effects, permissions, rate limits, or behavior on missing keys. For a tool with zero annotations, this is insufficient.

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, front-loaded with action and key information. Very concise, though it could benefit from more detail without harming conciseness. No wasted words.

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 3 parameters (2 required), no output schema, and no annotations, the description is woefully incomplete. It fails to specify what a 'memory' is, how keys work, the role of namespace, or what the return value looks like. For a tool that likely returns stored data, this is a significant 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 0% and the description does not explain any parameter meaning. AgentId, key, and namespace are not elaborated. The description adds no semantic value over the raw 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 'Retrieve a stored memory by key' clearly states the verb (retrieve), resource (stored memory), and method (by key). It distinguishes from sibling tools like agent_memory_store (write) and agent_memory_delete (remove) which have different purposes.

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 like agent_memory_search. No when-to-use or when-not-to-use context provided. The description simply states the action without usage scenarios.

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 provided, so description must disclose behavioral traits. It only lists search criteria, missing details on idempotency, pagination, or whether results are ordered. Insufficient for a search 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?

Single sentence with no redundancy. Could be expanded with parameter details without losing 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?

With 6 parameters, no output schema, and no annotations, the description is too minimal. Lacks return format, pagination details, and parameter usage guidance.

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

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

Schema has 0% description coverage. Description mentions 'prefix, tags, or type', mapping partially to keyPrefix, tags, type. It does not explain agentId, limit, or namespace. Fails to compensate for low schema 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 verb 'Search' and the resource 'memories' with specific criteria (prefix, tags, type). It distinguishes from sibling tools like agent_memory_get (single retrieval) and agent_memory_store.

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 (e.g., agent_memory_get for single memory). No context on 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?

No annotations are provided, so the description bears full responsibility. It mentions key-value nature and TTL but does not disclose important behaviors like overwrite semantics, idempotency, authorization needs, or what happens on TTL expiry. The behavioral disclosure is insufficient.

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 sentence with no wasted words. It is front-loaded with the core purpose. However, given the tool's complexity, a bit more detail would be helpful, but it remains concise and efficient.

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 6 parameters, 3 required, nested objects (metadata), no output schema, and no annotations, the description is too brief. It fails to explain expected responses, key uniqueness constraints, or how metadata is used. The agent lacks sufficient context to use 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 33% (only 2 of 6 parameters have descriptions). The description adds context by naming key-value, TTL, and metadata, which maps to parameters key, value, ttlSeconds, metadata. However, it does not explain namespace or the fact that agentId is required. Partial compensation for low coverage, but not fully adequate.

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 action ('Store a memory'), the resource ('for an AI agent'), and the format ('key-value, with TTL and metadata'). This is specific and distinguishes it from sibling tools like agent_memory_get or agent_memory_delete.

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. It doesn't mention that this tool is for storing new memories, while retrieval should use agent_memory_get, etc. No context is provided for appropriate usage.

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?

Discloses robots.txt enforcement and proxy rotation behavior, but with no annotations, the description could provide more detail on error handling, redirects, or rate limits.

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?

Extremely concise, two sentences, front-loaded with the core action. No wasted words.

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 7 parameters including nested objects and no output schema, the description is far too sparse. It does not explain how to use body, headers, method, sessionId, or what the response contains.

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 0% description coverage, and the description only hints at 'region' and 'type' but adds no concrete meaning for parameters like body, headers, method, or sessionId.

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 it fetches a URL via a rotating proxy with selectable region and type, and mentions robots.txt enforcement. This distinguishes it from sibling tools like agent_proxy_session or agent_captcha_solve.

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. Does not mention prerequisites, alternatives, or when not to use 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 must fully disclose behavior. It only mentions 'sticky' and 'same IP', but omits details about session lifecycle, persistence after TTL, rate limits, or how the session is referenced in subsequent requests. This leaves significant behavioral uncertainty.

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, which is front-loaded. However, it sacrifices necessary detail to maintain brevity. It could be slightly expanded without losing 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?

Given the tool has three optional parameters, no output schema, and many related sibling tools, the description fails to provide enough context for correct usage. Agents are left unsure about how to specify parameters, what the return value is, and how session persistence works.

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%, meaning no parameter descriptions exist. The description adds no information about the enum type values, the region format, or the TTL meaning. The agent must infer from parameter names alone, which is insufficient for correct invocation.

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 creates a sticky proxy session that maintains the same IP for multiple requests. This specific verb-resource combination distinguishes it from sibling tools like agent_proxy_fetch, which likely fetches a single proxy.

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 does not provide any guidance on when to use this tool versus alternatives such as agent_proxy_fetch. There is no mention of context, prerequisites, or when not to use 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?

Without annotations, the description should disclose behavioral traits; it mentions 'auto-expires' which is a key behavior but omits details like what happens after expiration, whether addresses are unique, or how the TTL parameter works.

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 sentence, very concise. While it is efficiently short, it sacrifices important details for brevity.

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

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

With no output schema, 0% param coverage, and a creation tool that needs clarity on inputs and returns, the description is severely incomplete. The agent cannot infer what the tool returns or how to use the parameters correctly.

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

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

Schema description coverage is 0% and the description does not explain the two parameters (ttlSeconds, preferredPrefix). The term 'auto-expires' weakly hints at ttlSeconds but provides no meaningful semantics.

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 verb 'Create' and the resource 'temporary email address', and adds behavioral note 'auto-expires'. Among siblings like get/list/wait, this creation tool is distinctly identified.

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 (e.g., when to create vs get or list). The description lacks context about prerequisites or scenarios.

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 bears full responsibility. It only states it gets content and extracts codes, but does not disclose whether the operation is read-only, has rate limits, requires authentication, or what side effects occur. A 2 is appropriate as minimal disclosure.

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?

A single concise sentence that is front-loaded with purpose. No fluff, but it could benefit from a second sentence about parameters or usage. Still efficient.

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?

No output schema is provided, and the description does not explain the return format or what 'extracted verification links/codes' means. For a tool with 3 parameters and no output schema, the description is 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?

Schema description coverage is 0%, meaning the schema parameters have no descriptions. The tool description does not mention any parameters or add meaning to mailboxId, messageId, or includeRaw. With 3 undocumented parameters, the description fails to compensate.

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 'Get full message content with extracted verification links/codes' clearly states the verb (get), resource (full message content), and specialized output (verification links/codes). It distinguishes itself from siblings like agent_tempmail_list (which lists messages) and agent_tempmail_create (which creates mailbox).

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 or prerequisites. It does not mention that the user must first have a mailboxId and messageId from list/create tools, nor does it explain when to use this vs agent_tempmail_wait.

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 behavior. It does not mention whether messages are consumed, pagination, or ordering. The description is too sparse.

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. While concise, it omits essential information, making it insufficiently informative.

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?

Without an output schema, the description should at least mention that it returns a list of messages. It fails to do so, leaving the agent without key 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 0%, but the description does not explain any parameters (after, limit, mailboxId). The agent has no help understanding what these parameters mean.

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 'List received messages in a mailbox' clearly states the verb and resource. It distinguishes from sibling tools like agent_tempmail_create and agent_tempmail_get. However, it could be more specific about scope.

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 like agent_tempmail_get or agent_tempmail_wait. No prerequisites or context 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 mentions 'long polling' and a maximum duration of 60 seconds, which hints at behavior but is insufficient. With no annotations, the description should disclose that this is a blocking operation, what happens on timeout or when a message arrives, and any side effects. The current text is too vague.

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 very concise (one sentence), which is good for readability. However, it lacks structure and essential details. It could be expanded slightly while remaining concise to include behavior and parameter contexts.

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 4 parameters and no output schema or annotations, the description is incomplete. It does not explain filtering behavior (fromContains, subjectContains), timeout semantics, return format, or error handling. A more comprehensive description is needed for effective agent use.

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?

No parameter descriptions are provided in the description (0% schema coverage). While the schema shows parameters like mailboxId, fromContains, subjectContains, and timeoutSeconds, the description adds no additional meaning. The mention of 'max 60s' contradicts the default timeoutSeconds of 30, causing confusion.

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 'wait for an incoming message' with long polling and a maximum timeout of 60 seconds. It uses a specific verb 'wait' and resource 'incoming message'. While it does not explicitly distinguish from sibling tools like agent_tempmail_get, the action of waiting is distinct from creating, getting, or listing messages.

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. There is no mention of prerequisites, alternatives, or conditions for use. The description simply states what the tool does without any context about appropriate scenarios.

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 bears full responsibility. It only adds the max 100 limit but omits traits like read-only nature, error handling, or partial failure behavior.

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 sentence, front-loading key information (batch, max limit), with no 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?

Despite simplicity, the description lacks return value details, parameter format, and behavioral context. Given no output schema or annotations, it is insufficient for effective use.

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 provides no explanation of the 'subjects' parameter structure or the meaning of 'type' and 'value' fields, leaving the agent without necessary semantics.

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 'Get trust scores for multiple subjects in one call (max 100)', specifying verb, resource, and scope. It distinguishes from sibling 'agent_trust_score' which likely handles single subjects.

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 when multiple subjects are needed and notes a max of 100, providing context. However, it does not explicitly exclude single-subject calls or mention alternatives beyond the implied distinction.

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 behavioral traits, but it only indicates the action (submit feedback) without explaining effects, persistence, anonymity, or rate limits. The impact on trust scores is implied but not stated.

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 sentence, which is concise but lacks necessary detail. It is not verbose but sacrifices completeness for brevity.

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

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

Given the tool has 5 parameters (4 required), enums, a nested object, and no output schema, the description is insufficient. It does not explain return values, behavior, or provide examples, leaving significant gaps 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?

Schema description coverage is 0%, so the description must compensate. It mentions 'positive or negative', hinting at rating, but does not explain the rating scale, categories, evidence format, or subjectType values. Adds minimal 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 specifies submitting feedback about an agent or wallet, which distinguishes it from sibling tools like agent_trust_score (retrieves score) and agent_trust_batch (batch operations). However, it omits subject types domain and agent_card_url, making it slightly 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 is given on when to use this tool versus alternatives (e.g., agent_trust_score). There are no prerequisites or context for appropriate use.

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 carries the full burden. It fails to disclose behavioral traits such as idempotency, rate limits, required permissions, or how missing subjects are handled. This lack of transparency is a significant gap for a tool that likely has side effects or data dependencies.

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 with no redundant words. It is well-structured and easy to read, though its brevity limits its informativeness.

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 output schema, annotations, and parameter descriptions, the description is incomplete. It does not explain the return format (e.g., score range), error handling, or any constraints. Important context about the trust score's meaning and interpretation 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 coverage is 0%, meaning no parameter descriptions exist in the schema. The description only reiterates the enum values of subjectType without explaining subjectValue or includeDetails. It adds minimal value beyond the schema's own enum labels and does not help an agent understand the parameters' semantics or valid formats.

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 verb 'Get' and the resource 'trust score' along with acceptable subject types (wallet, agent card URL, domain). It is easily understandable and distinguishes itself from related siblings like agent_trust_batch and agent_trust_feedback by focusing on a single subject.

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 usage guidance is provided. The description does not indicate when to use this tool versus alternatives (e.g., agent_trust_batch for batch queries or agent_trust_feedback for providing feedback), nor does it mention any 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?

With no annotations, the description carries full burden. It only states the tool creates the endpoint but does not disclose authentication needs, rate limits, or what happens after creation (e.g., how requests are relayed, if there is a setup process).

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 brief but at the cost of missing critical details for a 6-parameter tool. It is not properly front-loaded with essential info.

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 complexity (6 parameters, nested objects, no output schema), the description fails to explain return values or parameter behavior, 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?

Schema description coverage is 0%, and the description adds no information about parameters like agentId, pushUrl, ttlSeconds, deliveryMode, etc. The agent must guess their meanings from names alone, which is insufficient for correct invocation.

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 creates a webhook endpoint that relays requests to the agent, distinguishing it from sibling tools like agent_webhook_list_requests (listing), agent_webhook_poll (polling), and agent_webhook_replay (replaying).

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, such as when to poll vs. use HTTP push. No prerequisites or context for usage are given.

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 full burden. It implies a read-only operation but does not disclose rate limits, authentication requirements, pagination behavior (though limit/offset exist in schema), or error conditions.

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 that is front-loaded and concise. It contains no unnecessary words, but could be slightly expanded to add value 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?

Given no output schema and 0% schema coverage, the description is insufficient. It does not describe the return format, pagination details, or what constitutes a 'request' in the response.

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

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

With 0% schema description coverage, the description should explain the parameters. It does not mention endpointId, limit, or offset, leaving the user to infer from parameter names alone.

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 action ('list') and the resource ('requests received by a webhook endpoint'). It distinguishes this tool from other webhook-related siblings like agent_webhook_create, agent_webhook_poll, and agent_webhook_replay.

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 agent_webhook_poll or agent_webhook_replay. The description does not specify usage context, 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?

Discloses that it uses long polling and has a 60s maximum timeout, which are behavioral traits beyond the schema. However, no annotations exist, and the description does not clarify whether it is read-only, what happens on timeout, or if it blocks.

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?

Extremely short—one sentence—but lacks essential details. While no words are wasted, the brevity comes at the cost of completeness. A middle score is appropriate as it is clear but under-specified.

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 4 parameters, no param descriptions, and no output schema, the description is severely incomplete. It does not explain parameters, return values, or how to use endpointId, leaving the agent with insufficient 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?

With 0% schema description coverage, the description should explain the parameters, but only indirectly references timeout via 'max 60s'. The meaning of 'after', 'limit', and especially 'endpointId' are not conveyed, leaving the agent to guess.

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?

Clearly states the action (poll) and resource (new webhook requests), with added detail about long polling and a max 60s timeout. However, does not explicitly distinguish from sibling agent_webhook_list_requests, which could be used for historical views.

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 like agent_webhook_list_requests or agent_webhook_replay. The description implies real-time polling but does not specify context 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?

No annotations provided, so the description must fully disclose behavior. It only says 'Replay' but does not explain whether it modifies state, creates new entries, or requires authentication. Minimal behavioral context beyond the verb.

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, no fluff, front-loaded purpose. However, it is too terse; conciseness should not sacrifice necessary detail. Scores are adequate but not excellent.

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 lack of annotations, output schema, and parameter descriptions, the description is incomplete. An agent needs more information about the replay action, return value, and how to obtain the stored request.

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% with no parameter descriptions. The description does not explain the meaning of endpointId, requestId, or toUrl. For a tool with three parameters, this is a critical gap.

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 'Replay a stored webhook request' clearly states the specific verb 'Replay' and the resource 'stored webhook request'. It distinguishes from sibling tools like agent_webhook_create which creates a webhook, and agent_webhook_list_requests which lists requests.

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 like agent_webhook_list_requests or agent_webhook_poll. Missing prerequisites such as needing a stored webhook request from previous listing.

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?

Discloses key behavior: only fires on NEW matching events, backfill never fires, notifications pushed to destination. No annotations provided, so description carries full burden, and it does so adequately.

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

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

Two sentences, each focused: first defines purpose, second details filters and backfill. No waste, front-loaded with essential 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?

Covers purpose, filters, backfill, and notification. No output schema, but the description does not explain destination enums or management. Adequate for a creation tool given schema covers enums.

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?

Adds meaning beyond schema by clarifying filter requirements (at least one of keyword/entity), case-insensitivity, and optional ledger. With 80% schema coverage, the description enhances understanding.

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 it creates a saved watch that pushes notifications for new matching events. It distinguishes from sibling 'alerts' tools (delete, list) but does not explicitly contrast with other watch creation tools like sanction_watch or grant_watch.

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 explains filters (ledger, keyword, entity) and requires at least one filter. It implies use for notifications on new events but does not explicitly state when not to use or 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?

Discloses soft delete and notification cessation, which is good for a simple tool without annotations. However, lacks mention of auth requirements or rate limits, which would be useful for full transparency.

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?

One sentence, under 20 words, front-loaded with the action and key behavioral details. No fluff; 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?

For a simple 1-parameter tool with no output schema, the description covers the action and effect. However, lacks details like reactivation possibility or return value, but acceptable given the simplicity.

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 required parameter (watchId) is self-evident from the schema, but the description does not explain what it is, its format, or how to obtain it. With 0% schema description coverage, the description should compensate but barely does.

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 deactivates a saved watch by ID, includes the nuanced behavior of soft delete and stopping notifications, and distinguishes itself from sibling tools like alerts_create_watch and alerts_list_watches.

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?

Implied usage when wanting to stop a watch, but no explicit guidance on when to use versus alternatives or prerequisites. Given the many watch-related siblings, explicit when/why not would help.

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 provided; description is minimal. It implies a non-destructive read operation returning a list, but doesn't detail what constitutes a watch, potential pagination, or ordering. Given simplicity, this is adequate but could be more explicit.

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, front-loaded, no wasted words. Every word 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?

For a zero-parameter list tool without output schema, description is minimally complete. It could benefit from clarifying the return format or scope (e.g., 'Returns an array of watch objects' or 'Includes all active alert watches').

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?

No parameters exist (0 params), schema coverage 100%. Baseline 4 applies as description doesn't need to add param info.

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 it lists saved watches, clear verb+resource. Differentiates from alerts_create_watch and alerts_delete_watch by listing versus crud. However, it doesn't explicitly clarify that these are alerts watches (vs other watch types), but name implies scope.

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 vs alternatives. Does not mention prerequisites or typical use case, leaving agent to infer 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?

No annotations to rely on, and the description only mentions returned fields. Does not disclose behavioral aspects such as authentication requirements, error handling for invalid itemId, or whether the operation is read-only. For a simple get, minimal transparency.

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 very concise with two sentences and no extraneous information. It could be slightly improved by including parameter details, but it is not 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?

Given the tool's simplicity (one parameter, no output schema), the description is adequate but incomplete. It states what is returned but does not explain other potential fields, error cases, or usage context. With no annotations, more detail would help.

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 only parameter (itemId) has no description in the schema, and the description does not clarify its format, expected values, or how it relates to the tool's functionality. Schema coverage is 0%, and the description adds no parameter meaning.

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 retrieves a bid notice detail plus full event timeline, specifying returned fields. It distinguishes from siblings like bid_watch_search and bid_watch_timeline by combining both detail and timeline.

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 similar tools like bid_watch_timeline or bid_watch_search. No prerequisites or alternatives 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?

No annotations are present, so the description carries the burden. It states the tool returns events with firstSeenAt and ledgerVerified, indicating a read operation. However, it does not disclose other behavioral aspects like idempotency, rate limits, or authentication requirements. There is no contradiction with annotations (none 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 two sentences with no redundancy. It front-loads the core functionality and includes key details efficiently. 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 no output schema and low schema coverage, the description is incomplete. It does not specify the response format, pagination, or error handling. The return values are only partially described. For a tool with this complexity, more detail 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?

Schema description coverage is 0%, so the description should explain all parameters. It only explains 'since' (the timestamp) but does not describe 'limit' or 'entity'. This leaves a significant gap in parameter understanding.

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 it tracks recent events (appearance, deadline-move, close, cancel, award) across all bid notices since a given timestamp, and specifies each item includes firstSeenAt and ledgerVerified. This distinguishes it from siblings like bid_watch_get (specific notice) and bid_watch_search (search by criteria).

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 monitoring recent changes since a timestamp but does not explicitly state when to use this tool versus alternatives like bid_watch_search or bid_watch_timeline. No when-not or alternative guidance 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 provided, so description must disclose behavioral traits. It only mentions output fields but lacks information on authentication, rate limits, error behavior, or whether it's read-only. Minimal disclosure.

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

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

Two sentences, front-loaded with purpose and a useful output detail. No wasted words, but could expand slightly on usage 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?

Tool has 6 parameters (none required) and no output schema or annotations. Description omits explanation of query, limit, since, entity, status, bidType. Output only mentions two fields, leaving the rest unspecified. Incomplete for effective use.

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 only 33% (from context). Description does not explain any parameters; it only mentions output fields. With low coverage, description should compensate but fails to add meaning 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?

Description clearly states the tool searches Japanese public-procurement bid notices from kkj.go.jp, mentions key result fields (firstSeenAt, ledgerVerified), and distinguishes it from sibling tools like bid_watch_get or bid_watch_recent_changes.

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 like bid_watch_get or watch tools for other domains. No exclusions or context 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, so the description carries the full burden. It discloses the tool returns events with 'firstSeenAt and ledgerVerified' but does not mention read-only behavior, authentication needs, rate limits, or error handling (e.g., invalid itemId).

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, front-loaded with the core purpose and key differentiators. Every word adds value without repetition or 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?

For a simple tool with one parameter and no output schema, the description covers purpose and key fields but lacks details on return format, pagination, or error scenarios. It is adequate but could be more 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?

The input schema has one parameter (itemId) with 0% coverage, meaning no description in schema. The tool description does not explain what itemId represents beyond the context of 'bid notice', missing format, example, or required characteristics. This is insufficient compensation for low schema 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 returns 'time-ordered events only for a bid notice' and lists specific event types (appearance, deadline moved, closed, cancelled, awarded). This distinguishes it from sibling tools like bid_watch_get (likely details) and bid_watch_recent_changes (likely summary).

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 timeline retrieval with 'the differentiator' phrasing but does not explicitly state when to use this over alternatives or when not to use it. No exclusion criteria or alternative tool names 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?

The description explains that the tool checks hash-chain integrity for tamper detection and lists the output fields. It implies a read-only operation, but since annotations are absent, it largely relies on the description for transparency. Additional details like required permissions or rate limits are missing, but the core behavior is clear.

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 sentence that front-loads the purpose and efficiently lists the return values. Every word earns its place, and there is no repetition or 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 tool's simplicity (one parameter, no output schema), the description covers purpose and output, but lacks an explanation of the itemId parameter and any prerequisites. It does not mention error cases or when this verification is valid, making it moderately 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?

The only parameter, itemId, is a string with no description in the schema (0% coverage). The description does not explain what itemId represents (e.g., the bid notice ID), leaving the agent without necessary guidance. This is a significant gap for a required parameter.

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 hash-chain integrity for tamper detection, and lists the return fields. It specifies 'bid notice', distinguishing it from other verify_ledger tools like grant_watch_verify_ledger or landprice_watch_verify_ledger.

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 does not provide any guidance on when to use this tool versus alternatives, such as bid_watch_get or other verification tools. It neither mentions prerequisites nor scenarios where this tool is preferred.

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 discloses that the call is 'Pure compute; price 0.0 (free)', implying no side effects or costs. However, it does not mention rate limits, caching, or whether results are deterministic. Given the lack of annotations, the transparency is adequate but not comprehensive.

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 concise at two sentences, with the primary action and key details front-loaded. Every word serves a purpose, and no redundant information is present.

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?

Despite the lack of an output schema, the description covers the essential return information (CO2e in kg). For a simple computation tool, this is largely sufficient. However, a brief mention of the output format (e.g., single number) would 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?

With 100% schema description coverage, the baseline is 3. The description adds value by clarifying the default regional intensity ('defaults to the IEA world average') and specifying the output unit ('CO2e (kg)'), which enhances understanding beyond the schema's enum and type descriptions.

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 verb ('Estimate'), resource ('electricity CO2e'), and key inputs ('kWh', 'region'). It distinguishes itself from sibling carbon tools by specifying 'Pure compute; price 0.0 (free)', indicating it's a simple calculation rather than a real-world API call.

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 electricity emissions estimation but provides no explicit guidance on when to use this tool versus alternatives like carbon_estimate_shipping_emissions or carbon_estimate_travel_emissions. No exclusions or context about prerequisites 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?

No annotations provided, so the description must fully disclose behavior. It states the tool is 'pure compute' and free, but omits details on error handling for invalid activity keys, authentication requirements, or rate limits. The behavioral disclosure is minimal.

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 concise—two sentences with no filler. It front-loads the action ('Look up the published emission factor') and efficiently provides examples and pricing.

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, the description mentions the return fields (value, unit, category) but does not elaborate on the response structure. For a simple lookup tool, this is adequate but could be more informative about expected output format.

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% with the activity parameter already described as a canonical key. The tool description adds extra examples (beef, electricity_global) beyond the schema, providing additional context for valid values.

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's purpose: looking up published emission factors for a named activity key. It provides specific examples (shipping_air, electricity_global, etc.) and distinguishes itself from sibling tools like carbon_estimate_compute_emissions by focusing on a single factor lookup.

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 over alternatives. While it mentions 'Pure compute; price 0.0 (free)', it does not describe when to choose this vs. other carbon estimation tools (e.g., compute_emissions, offset_estimate).

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 burden. It explicitly states 'Pure compute; price 0.0 (free)', which discloses key behavioral traits (no side effects, no cost). However, it does not mention rate limits or potential data sources, but for a simple compute tool, this is sufficient.

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 concise: two sentences, each providing essential information. It is front-loaded with the main action and resource, and every sentence earns its place. No superfluous words.

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, the description should clarify return values. It mentions 'offset cost (USD) and tree- / forest-year equivalents', which adequately informs the agent of the output types. However, it could be more explicit about the exact structure (e.g., numeric values, possibly an object). Still, it is reasonably complete for a simple compute 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% for the single parameter 'kgCO2e', with a clear description. The tool description adds value by explaining what the output will be (offset cost and equivalents), but does not elaborate on the parameter 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 clearly states the tool estimates voluntary-market offset cost and tree/forest-year equivalents for a given kg CO2e. The verb 'estimate' and resource 'offset cost' are specific, and it naturally distinguishes from sibling tools like carbon_estimate_compute_emissions which compute emissions.

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 by stating 'for a given kg CO2e' but does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. The 'Pure compute; price 0.0 (free)' note gives some context but is not enough for clear usage differentiation.

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 provided, so description bears full burden. States 'Pure compute; price 0.0 (free)' indicating no side effects and cost. However, it does not disclose behavior for edge cases (e.g., zero weight) or accuracy of estimates.

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?

Extremely concise: one functional sentence plus a short note on pricing. Every word adds value; no 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 simple compute tool with all parameters described in schema, the description is mostly complete. It mentions output (CO2e in kg) and that it uses GLEC/DEFRA factors. Could indicate return format more explicitly.

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 baseline is 3. Description reiterates inputs (weight, distance, mode) but adds no new meaning beyond the schema descriptions.

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 clearly states the tool estimates freight CO2e using specific inputs and emission factors. It specifies verb and resource, but does not explicitly differentiate from sibling tools like carbon_estimate_compute_emissions or carbon_estimate_travel_emissions.

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. No mention of prerequisites, limitations, or scenarios. Only states it's free and pure compute.

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, description adds value by stating 'Pure compute' (no side effects) and 'price 0.0 (free)'. Discloses that it uses 'embedded per-passenger-km factors' for methodology. Adequate for a simple compute 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 concise sentences, front-loaded with core purpose, additional behavior note appended. No wasted words.

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?

Lacks output schema, and description does not specify return structure (e.g., response is a number). While unit 'kg CO2e' is provided, completeness is only adequate for a straightforward tool; missing response details.

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 100% of parameters with descriptions. Description merely reiterates 'distance and travel mode' without adding new semantic meaning, meeting 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?

Clearly states verb 'Estimate' and resource 'passenger-travel CO2e (kg)' with inputs distance and mode. Distinguishes from sibling carbon tools like shipping_emissions by specifying 'passenger-travel'.

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 vs alternatives. Mentions 'Pure compute; price 0.0 (free)' but does not direct agent to use for travel estimates versus other carbon 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 provided, so description carries full burden. It discloses read-only and free pricing, but does not describe output structure (e.g., response format), rate limits, or authentication requirements.

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 that is front-loaded with core purpose and then specifies inputs and key traits. No redundant information.

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

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

With 3 parameters fully documented in schema and no output schema, the description covers the tool's purpose, input flexibility, read-only nature, and transparency of rationale. Missing explicit output structure slightly reduces 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?

Schema coverage is 100%, so baseline is 3. The description groups the three parameters as input sources but adds no additional syntax, constraints, or usage details beyond the schema descriptions.

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 computes a readiness score (0-100) for product structure for autonomous agents, with inputs from URL, HTML, or inline product. It distinguishes from sibling commerce_catalog tools (e.g., product_extract, price_compare) by its scoring focus.

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 via specifying input sources and notes read-only/free nature, but does not explicitly state when to use this tool vs. alternatives like product_extract or when not to use 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?

The description explicitly states 'Read-only; price 0.0 (free),' which is good for transparency given no annotations. However, it does not disclose behavior for unreachable URLs, invalid input, or response structure beyond the coarse signal categories. More detail about error handling or default behavior would improve the score.

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 packs key information (purpose, input types, output signal, behavioral traits). It could be slightly more structured (e.g., separate sentences for input constraints), but it is front-loaded with the most important action.

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 three parameters and no output schema, the description lacks critical details about the return format (e.g., JSON structure, whether it returns a string or object). It also does not specify how the output signal is presented or any constraints on the product object input. This leaves the agent guessing about how to parse the result.

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% with descriptions for each parameter. The description adds high-level context ('from a url, raw html, or inline product') but does not provide additional semantic details, such as expected formats, object structures, or how to choose among the three inputs. 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 specifies the tool's exact function: resolving stock availability into a coarse signal with enumerated output values (in_stock, out_of_stock, limited, preorder, unknown). It lists the three input sources (url, html, inline product), distinguishing it from sibling tools like commerce_catalog_product_extract or commerce_catalog_price_compare.

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, nor when not to use it. The description implies use for stock availability checking, but it would benefit from context like 'Use this to check product availability; for full product details, see commerce_catalog_product_extract.'

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, description carries full burden. Discloses read-only and free status, but lacks detail on rate limits, auth requirements, or error handling. Provides basic transparency but not exhaustive.

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

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

Two sentences, no fluff. Front-loaded with action and output. Highly efficient.

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?

Describes output (fields present/missing and score) despite no output schema. Clarifies input exclusivity. For a simple validation tool, it 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 coverage is 100% with good descriptions. The description reinforces mutual exclusivity of parameters, adding minimal extra value 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?

Clearly states the action (validate), target (product-feed completeness), and output (present/missing fields and score). Distinguishes from sibling tools like commerce_catalog_product_extract by focusing on validation.

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?

Specifies that inputs can be url, raw html, or inline product object, and mentions it's read-only and free. However, does not explicitly state when NOT to use it or provide alternatives like product_extract for extraction.

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 takes on the burden of transparency. It states the tool is 'pure' (no side effects) and has 'price 0.0' (free), which are helpful behavioral cues. It does not detail error handling or exact output structure, but the mentioned traits are sufficient for a read-only operation.

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 concise: two sentences that convey purpose, prerequisite, and key behavioral attributes. Every sentence adds value 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?

Given the simple input (one parameter) and no output schema, the description gives a reasonable overview of what is returned (cheapest, most expensive, spread, ranking). It could be improved by specifying the return format precisely, but it is sufficient for an agent to understand the tool's function.

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 covers 100% of the parameter descriptions, so the baseline is 3. The description adds the requirement that the array be non-empty, which is an important constraint not fully captured by the schema. However, it does not elaborate on the individual properties beyond what the schema already 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 clearly states the tool compares offers and returns specific results (cheapest, most expensive, spread, ranking). It uses a specific verb ('compare') and resource ('offers'), and it's distinct from sibling tools like commerce_catalog_availability_check or product_extract.

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 a clear prerequisite ('Requires a non-empty offers array') and notes the tool is free and pure. However, it doesn't explicitly state when to use this tool over alternatives, though in context it's the only price comparison tool.

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 burden. It declares read-only and free behavior, which is helpful. However, it does not disclose error handling, rate limits, or what happens for invalid markup. The behavioral disclosure is minimal but accurate.

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 concise—two short sentences. It front-loads the verb and resource, includes key details (fields extracted, input requirements), and contains no unnecessary information. 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?

Despite having no output schema, the description only partially describes the output (list of fields with ellipsis). It doesn't explain the return format (e.g., JSON), error conditions, or what happens if no markup is found. Given the tool's simplicity, this is adequate but not fully 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?

The input schema covers 100% of parameters with descriptions, but the description adds the important constraint that exactly one of url or html should be provided (mutual exclusivity). This semantic guidance is not present in the schema, adding 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 clearly states the tool extracts a normalized product from Schema.org/JSON-LD markup, listing specific fields. It distinguishes from other commerce catalog tools (e.g., availability_check, price_compare) by focusing on structured data extraction. However, it could be more explicit about its uniqueness among 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?

The description provides context for use (when you have a URL or HTML with markup) and notes it is read-only and free. It does not explicitly state when not to use this tool or suggest alternative tools, leaving some ambiguity.

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 burden. It states 'Read-only' and 'price 0.0 (free)', indicating safe, free usage. However, it lacks details on rate limits, authentication needs, error handling (e.g., company not found), or data source caching, which would enhance transparency.

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, well-structured sentence that includes the core purpose, source, method, and cost. Every element is necessary, and there is no redundant or verbose language.

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 is no output schema, the description provides a useful list of returned fields (name, status, dates, type, address). It mentions the source (OpenCorporates) and cost. However, it could mention the response format or additional fields for 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 schema covers both parameters fully (100% coverage). The description simply reiterates the parameters ('by jurisdiction + company number') without adding new semantic meaning or constraints beyond what the schema already 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 clearly states the action ('Fetch a company profile') and specifies the resource (company profile with fields like name, status, dates, type, address). It distinguishes from sibling tools like company_registry_search_company and company_registry_officers by requiring both jurisdiction and company number for a direct profile lookup.

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 when you have a specific company number and jurisdiction, and it notes the tool is read-only and free. However, it does not explicitly mention alternatives or when not to use it, though the context of sibling tools provides some differentiation.

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 provided; description says 'Pure compute' indicating no side effects, but lacks details on error handling, rate limits, or behavior for invalid codes.

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

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

Two sentences, directly to the point, no unnecessary words. Excellent 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?

For a simple lookup tool with one parameter and no output schema, the description covers the purpose and pricing. Could mention the return type but 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 coverage is 100% for the single parameter, and the description restates the same example format. No additional meaning is added 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?

Clearly states 'look up metadata for a jurisdiction code (name, registry details)', which distinguishes it from sibling tools like company_profile or officers that focus on specific company data.

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?

Mentions 'Pure compute; price 0.0 (free)' but does not specify when to use this tool over others (e.g., when you need jurisdiction metadata vs company search). Usage is implied but not 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?

With no annotations provided, the description carries full burden. It states the tool is read-only and free, which are key behavioral traits. However, it does not disclose potential rate limits, pagination, data freshness, or authentication requirements.

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 sentence that is front-loaded with the action and key details. Every word contributes meaning—no filler or 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?

Given the tool's low complexity (2 parameters, no output schema), the description adequately covers what the tool does and its inputs. It lists the output fields (name, position, dates, current flag), which is helpful. Missing details on output structure or limits are minor given the tool's simplicity.

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 coverage is 100%, so the schema already documents both parameters. The description adds context like 'e.g. gb, us_de' for jurisdiction, but this is also in the schema's description. No additional 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 clearly states the tool lists company officers with specific fields (name, position, start/end dates, current flag) and specifies required inputs (jurisdiction + company number). It distinguishes itself from sibling tools like company_registry_company_profile by focusing on officers.

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 mentions required inputs ('by jurisdiction + company number') and declares the tool as read-only and free. However, it does not provide explicit guidance on when to use this tool versus alternatives (e.g., search_company) or when not to use 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?

Explicitly states 'Read-only; price 0.0 (free)', which covers safety and cost. With no annotations provided, this disclosure is valuable. Could mention rate limits or pagination, but acceptable for a simple search.

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 concise sentences: first states purpose and API source, second adds key context (returns candidates, read-only, free). No redundancy, efficiently 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?

For a 3-param search tool with no output schema or nested objects, the description covers purpose, scope, and safety. Missing details like result format or error handling, but these are predictable for a search 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 coverage is 100% with clear descriptions. Description adds little beyond 'optionally scoped to a jurisdiction' and 'partial match' which mirrors schema. 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?

Clearly states 'Search for companies by name (optionally scoped to a jurisdiction)' with a specific verb and resource. Distinguishes from sibling tools like company_profile and officers by focusing on disambiguation search.

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?

Implicitly suggests use for initial disambiguation, but no explicit guidance on when to use this vs alternatives or when not to use it. Mentions read-only and free, which is helpful for safety but not comparative.

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 burden. It declares 'Pure compute' meaning no side effects, and mentions price 0.0 (free). It does not detail rate limits or idempotency, but the core behavior is well disclosed.

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 no redundancy. Every sentence adds value: purpose, behavior, and return info. Highly efficient.

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, the description mentions the return values (valid flag, normalized value, reason). It covers what the tool does, its inputs, its side-effect-free nature, and pricing. No 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 coverage is 100% and includes descriptions for both parameters. The description adds no new parameter-level details beyond the schema, so 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 uses a specific verb ('Validate') and resource ('company-registration number'), and clarifies the jurisdictional context. It clearly distinguishes from sibling tools like company_profile or search_company.

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's 'Pure compute' and free, implying safe repeated use, but does not explicitly say when to use it instead of alternatives or when not to use it. Context is clear but no exclusions or alternatives 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?

With no annotations, the description adds some behavioral context: it's heuristic, free, and has no network dependency. But it doesn't disclose potential limitations, such as text length constraints or the format of the 'transparent rationale' in the output.

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 (two sentences) and front-loaded with the core purpose and output range. No unnecessary words.

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 no output schema and no annotations. The description mentions the output is a 0-100 likelihood and 'transparent rationale', but doesn't fully describe the response structure. For a simple tool, it's somewhat complete but could specify the exact output fields.

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 has 100% coverage, so baseline is 3. The description adds meaning by explaining the tool uses lexical-diversity and burstiness signals, beyond the schema's simple 'Text passage to score' description.

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 gives a heuristic likelihood (0-100) of AI-generated text using lexical-diversity and burstiness signals. This distinguishes it from sibling tools like watermark_detect or provenance_check, which focus on other authenticity aspects.

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 mentions the tool is 'Pure, no network; price 0.0 (free)', indicating it's a local, free heuristic. However, it doesn't explicitly state when to use this tool versus alternatives like C2PA inspection or domain reputation checks, but the context is clear enough.

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?

Discloses that the tool is read-only, performs one HTTPS GET, and is free. With no annotations, this adds essential behavioral 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?

Two concise sentences: first explains core action, second adds usage and behavioral notes. No wasted words.

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?

Covers input requirements but does not describe output format or contents of the manifest. Suitable for a simple input schema but lacks completeness for a scanning 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?

Only one parameter 'url' with schema description 'Image URL to inspect'. The description repeats this, adding no extra meaning 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?

Clearly states the tool detects C2PA/Content Credentials manifests by scanning raw image bytes for JUMBF markers and lifting claim generators. Distinct from sibling tools like watermark_detect or ai_likelihood.

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 basic instruction ('Provide an image url.') but does not explicitly specify when to use this vs. alternatives or when not to use.

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?

Discloses read-only nature and zero cost, and mentions it uses free HTTPS endpoints. However, with no annotations, the description carries the full burden; it does not address rate limits, error handling, or data freshness.

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?

One sentence, front-loaded with key information (heuristic, score range, signals used, read-only, free). Every word adds value; no wasted text.

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 tool with one parameter and no output schema, the description provides sufficient context: what the score represents and the signals considered. It could mention the return format explicitly, but the score range is given.

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?

Only one parameter 'domain' with a schema description. Schema coverage is 100%, so the description adds no extra meaning beyond what the schema provides. 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?

Clearly states it computes a heuristic reputation score (0-100) for a domain using various signals. However, it does not differentiate from the sibling tool domain_intel_reputation, which could cause confusion.

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?

Mentions it is read-only and free, but provides no guidance on when to use this tool versus alternatives like domain_intel_reputation or other reputation tools. Lacks explicit when-to-use or when-not-to-use 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?

No annotations are provided, so the description must carry the burden. It discloses it is read-only and free (price 0.0), which is helpful. However, it does not mention rate limits, authentication requirements, or behavior for invalid URLs, leaving gaps in expected behavior.

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 sentence that front-loads purpose and includes key constraints (read-only, free). Every part is essential, and there is no wasted wording.

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 one parameter, no output schema, and no annotations, the description covers purpose, cost, and read-only nature. It lacks details on the return format (e.g., structure of verdict and rationale), but the simplicity of the tool reduces the need for extensive 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 coverage is 100%, so the description adds minimal extra value for parameters. It confirms the URL is an image URL, but the schema already states 'Image URL to check'. No parameter-specific guidance beyond the schema is provided.

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 it provides a combined Media-provenance verdict for an image URL, combining C2PA presence and domain reputation with rationale. This distinguishes it from sibling tools like content_authenticity_c2pa_inspect and content_authenticity_domain_reputation, which only cover one aspect.

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 a quick combined verdict, but does not explicitly state when to use this tool versus the separate C2PA or domain reputation tools. No exclusions or alternatives are mentioned, leaving the agent to infer context from sibling names.

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 adds 'Best-effort', 'Read-only', and 'price 0.0 (free)' – useful but incomplete. It does not disclose behavior on errors, missing watermarks, or output format, which would help an agent anticipate tool results.

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

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

Two sentences, no extra words. The first states the function, the second provides usage instructions 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?

For a simple tool with one parameter and no output schema, the description covers the essential purpose and input. It could be improved by hinting at the output (e.g., 'returns detected markers or confidence'), but overall it is sufficiently complete for its simplicity.

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 fully describes the 'url' parameter as 'Image URL to inspect' (100% coverage). The description adds 'raw image bytes' context, but that is marginal – the 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 states the tool does 'watermark and provenance-marker detection' from image bytes, using examples like C2PA/IPTC/XMP. This distinguishes it from siblings like content_authenticity_ai_likelihood and content_authenticity_c2pa_inspect which focus on AI likelihood or full C2PA metadata.

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 tells the user to 'Provide an image url' and notes 'Read-only; price 0.0 (free)'. While it implicitly guides usage for watermark detection, it does not explicitly contrast with alternatives like content_authenticity_c2pa_inspect, leaving some ambiguity.

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 must fully disclose behavior. It states the tool is read-only and free, and mentions the backend (Cloudflare 1.1.1.1). However, it does not cover error handling, response format, or any potential rate limits, leaving gaps in transparency.

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, front-loaded with the core purpose and support information. Every sentence adds value 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?

Given the absence of an output schema, the description does not explain the return value format (e.g., list of records). While the tool is relatively simple, this omission reduces completeness. The description could include a note about the response structure.

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%; both parameters (domain and types) are described in the schema. The description adds no extra meaning beyond what the schema provides, so 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 verb 'Resolve' and the resource 'A / AAAA / MX / TXT / NS / CNAME records for a domain'. It distinguishes from sibling tools like domain_intel_whois_summary by specifying the exact record types and the backend (Cloudflare DNS-over-HTTPS).

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 mentions the tool is read-only and free, providing some context for safe usage. However, it does not explicitly guide when to use this tool versus alternative domain intelligence tools (e.g., domain_intel_reputation) or when not to use 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?

No annotations are provided, so the description carries full burden. It discloses read-only, free, and use of DoH. It also mentions 'best-effort DKIM selector probing', which is a behavioral trait. However, it does not detail rate limits, error conditions, or response format.

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 clear, front-loaded sentences. The first sentence states the core action and method; the second provides key specifics (read-only, free, extraction details). No superfluous text.

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 2 parameters and no output schema. The description covers inputs, behavior, and pricing, but is missing what the return value looks like (e.g., JSON structure with SPF/DMARC/DKIM results). Given the lack of output schema, this is a notable 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 coverage is 100%, so the schema already describes both parameters. The description adds minimal value: it restates the domain parameter and implies default behavior for dkimSelectors ('best-effort'). However, it does not explain the format of domain or selector values.

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 it parses SPF/DMARC/DKIM from TXT records via DoH, listing specific extracts (SPF all-qualifier, DMARC policy, DKIM selectors). It distinguishes from sibling tools like domain_intel_dns_lookup by being specifically about email authentication.

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 email authentication checks and mentions read-only and free, but does not explicitly state when to use this tool versus alternatives like general DNS lookup or reputation checks. No when-not-to-use or alternative suggestions 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?

Discloses read-only, free, and that every contribution is returned in 'rationale' (no black box). No annotations provided, so description carries full burden and meets it well.

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 front-load key information: score range, components, rationale, limitations, and cost. No wasted words.

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, description adequately explains return value (rationale with contributions). Slightly lacking explicit output format details, but sufficient for agent understanding.

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?

Single parameter 'domain' is fully described in schema (100% coverage). Description adds no additional parameter semantics beyond schema, so baseline 3 applies.

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

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

Clearly defines tool as heuristic reputation score (0-100) combining domain age, TLS, email-auth, and MX signals. Distinguishes from siblings like domain_intel_dns_lookup and domain_intel_email_auth_check by being a composite score.

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?

States 'Informational only, not a security guarantee' and 'Read-only; price 0.0 (free)', guiding appropriate use. However, lacks explicit alternatives or when-not-to-use scenarios, though sibling tools are available for deeper checks.

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 discloses the tool is read-only and free, which is helpful. However, it does not explain behavior on invalid domains, rate limits, or error cases. Annotations are absent, so the description carries the full burden but lacks some important behavioral details.

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, front-loads the core purpose, and includes essential details (source, output fields, cost). No extraneous 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?

Given the tool's simplicity (one parameter, no output schema), the description covers input, source, and key output fields. It is mostly complete, but could mention error handling or response format for full 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?

Input schema has 100% coverage with a description for the 'domain' parameter. The description adds value by explaining the source (crt.sh) and what the tool reports, going beyond the schema's minimal description.

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 clearly states the tool provides TLS certificate issuer, validity, and SAN summary from crt.sh. It specifies it picks the freshest leaf and reports currentlyValid and daysUntilExpiry. This distinguishes it from other domain_intel tools like dns_lookup or whois_summary.

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 implies the tool is for inspecting TLS certificates, but does not explicitly state when to use it versus alternatives. No exclusions are mentioned, making it clear but not perfectly guided.

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 explicitly says 'Read-only; price 0.0 (free)' and mentions 'RDAP over HTTPS (no legacy port-43 WHOIS)', providing useful behavioral context. However, it lacks details on potential limitations like rate limits or handling of unregistered domains.

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: purpose, return fields, and safety/cost. Every sentence is informative without redundancy or 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?

The description covers the tool's input, output fields, and behavioral traits adequately for a simple lookup. It could mention error handling or response format, but given the lack of output schema, it is reasonably 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?

The only parameter 'domain' is described in the schema, and the description does not add extra meaning beyond what the schema already provides. Schema coverage is 100%, so 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 it provides a 'Domain age / registrar / expiry summary' using RDAP over HTTPS. It lists the exact return fields, distinguishing it from sibling tools like domain_intel_dns_lookup (DNS records) and domain_intel_reputation (reputation scores).

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 implicitly defines usage by listing the returned data (registeredAt, expiresAt, etc.), suggesting it is the tool for basic registration info. However, it does not explicitly state when to use alternatives or exclude 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 provided, so description carries full burden. It explains behavior beyond schema: returns hits grouped per ledger with fields (matchedField, summary, detailUrl, ledgerVerified) and clarifies ledgerVerified's meaning (proves record integrity, not data truth). No contradictions.

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

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

Two sentences, no wasted words. First sentence front-loads purpose and scope; second sentence clarifies ledgerVerified. Efficient.

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, the description explains return structure (grouped per ledger with fields). It lacks mention of pagination or total limits across ledgers, but overall is quite complete for a search 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 coverage is 100% (both parameters have descriptions). Description adds no extra meaning beyond what schema provides; 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 states it searches a company/person name across ALL listed ledgers, distinguishing it from sibling tools that search within a single ledger (e.g., sanctions_watch_search). The verb 'search' and resource 'all ledgers' are 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 broad cross-ledger searches but does not explicitly state when to use this over a ledger-specific search tool. No 'when-not' or alternatives are named.

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