mcp-revenue-empire — Japan public-data ledgers

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

With no annotations, the description carries full responsibility for behavioral disclosure. It states 'Query' (implying read-only) and 'with filters' but gives no details on pagination, limits, error handling, or what happens with invalid parameters. This is insufficient for an agent to understand the tool's 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 extremely short (4 words), which could be seen as concise, but it lacks essential details. It does not earn its place as it fails to provide enough information for effective tool invocation.

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 (7 parameters, no schema descriptions, no output schema, no annotations), the description is severely incomplete. It neglects to describe return format, parameter formats, or any constraints, making it nearly useless 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%, and the description does not explain any of the 7 parameters (to, from, limit, agentId, riskMin, sessionId, actionType). The phrase 'with filters' is too vague to add meaning, leaving the agent to guess parameter purposes from 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 'Query agent actions with filters' identifies the verb (query) and resource (agent actions), and implies filtering. However, it lacks specificity about what exactly constitutes 'agent actions' and does not clearly differentiate from sibling tools like agent_audit_record or agent_audit_report, though the verb 'query' suggests a list operation.

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 context, prerequisites, or exclusions, leaving the agent to infer usage from the name alone.

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

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

No annotations provided, and description fails to disclose side effects, permission requirements, or behavioral traits such as idempotency or rate limits. The description only states the action without 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?

One sentence with 8 words is concise, but it sacrifices valuable information. It earns its place only minimally; the brevity leads to ambiguity.

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

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

Given no output schema, no annotations, and no parameter explanations, the description is inadequate for a tool recording audit data. Missing details on record structure, required fields, and expected behavior.

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, and the description adds no meaning to any of the 7 parameters. The agent must infer parameter semantics solely from names and types.

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 'Record an agent action for audit and compliance,' which communicates a write operation distinct from query/report siblings. However, 'agent action' is vague and could be more 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?

No guidance on when to use this tool versus alternatives like agent_audit_query or agent_audit_report. No context on prerequisites or expected use cases.

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

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

With no annotations provided, the description carries full burden but only states the basic action. It does not disclose behavioral traits such as whether the operation is read-only or destructive, what happens with the report (e.g., returned or stored), or any auth requirements. The agent cannot infer safety or side effects.

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

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

The description is a single sentence with no unnecessary words. It conveys the core action and available formats efficiently. However, it could benefit from slight restructuring (e.g., listing required parameters) 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 the absence of an output schema and annotations, the description is incomplete. It does not explain what the audit report contains, the purpose of agentId and date range, or any output format details. The tool generates a report, but an agent would need to infer return type and behavior from the name alone.

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 description does not explain any parameters beyond what the schema provides. The description mentions format options but does not elucidate agentId, from, or to (e.g., what agentId represents, the date-time range format). The default value and enum for format are already in the schema, so no added 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 explicitly states the action ('generate audit report') and lists the available formats (json, markdown, soc2), which matches the input schema enum. It clearly distinguishes from sibling tools like 'agent_audit_query' (queries existing audits) and 'agent_audit_record' (records an event), as this tool generates a report.

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

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

No guidance is provided on when to use this tool versus alternatives. Sibling tools exist (e.g., agent_audit_query, agent_audit_record) but are not mentioned or contrasted. The description does not specify prerequisites, such as the need for a prior audit record or the scope of the report.

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 disclose behavioral traits. It only mentions permission requirements but omits details like return format, error handling, rate limits, or destructive potential. This is a significant gap for an agent deciding to invoke the 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 efficient sentence that front-loads the main action and constraint. However, it could benefit from additional structured detail 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 no output schema, no behavioral details, no parameter descriptions, and 6 parameters including optional ones, the description is severely incomplete. An agent would struggle to understand how to properly provide inputs like 'imageBase64' or which 'type' to choose for a given CAPTCHA.

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 6 parameters with 0% coverage in descriptions. The description adds no explanation of parameter meanings, such as the enum values for 'type' (e.g., differences between recaptcha_v2 and image_text). Despite the self-explanatory names, the lack of guidance forces the agent to guess correct usage.

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 solves a CAPTCHA for owned/permitted domains. It uses the specific verb 'solve' and resource 'CAPTCHA', and the permission constraint distinguishes it from related tools like agent_captcha_verify_domain.

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 'for a domain you own or have explicit permission to access' provides clear context on when to use the tool (i.e., when authorized). It implies exclusions for unauthorized domains, though no explicit alternatives or 'when not to use' guidance is 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 provided, but description indicates a non-destructive verification operation. Lacks details on side effects or 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?

Single sentence, front-loaded, no unnecessary words. Efficient communication of purpose.

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

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

Given no output schema, no annotations, and 0% parameter descriptions, description is too minimal. Missing behavioral and parameter 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?

With 0% schema coverage, description adds no meaning to parameters. It does not explain 'domain' or 'method', relying solely on 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 verifies domain ownership and positions it as a prerequisite for CAPTCHA solving. Distinguishes from sibling 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?

Implies usage context by stating 'before using CAPTCHA solving', but does not explicitly mention 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?

With no annotations, the description carries full burden. It mentions ordering ('newest first') and access restriction ('owner only'), but fails to disclose pagination behavior, what 'activity records' contain, error handling, or rate limits. This is insufficient for a tool with no annotation support.

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

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

The description is one sentence of 10 words, front-loaded and efficient. However, it omits necessary parameter details, so conciseness comes at the cost of completeness.

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 list tool with two parameters and no output schema, the description covers core purpose, ordering, and access restriction. However, it lacks parameter documentation and output shape, leaving gaps for an agent to use it correctly.

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

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

Schema description coverage is 0%, yet the description does not explain the 'limit' parameter (pagination, default) or explicitly map 'identityId' to the identity. It adds minimal value beyond the schema field names.

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

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

The description clearly states the action ('List'), the resource ('activity records for an identity'), and key properties ('newest first', 'owner only'). It effectively distinguishes from siblings like agent_identity_record (likely single record) and agent_identity_lookup (likely 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?

The description implies the tool is for listing activities of an identity, but does not provide explicit guidance on when to use it versus alternatives, nor does it mention exclusions or prerequisites beyond 'owner only'.

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 fails to disclose behavioral traits such as being read-only, auth requirements, or rate limits. As a get operation, 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, front-loaded sentence with no wasted words. However, it could convey more useful information without increasing length.

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 simplicity of the tool (one parameter, no output schema, no annotations), the description lacks necessary details about what a 'badge' or 'signed fields' are, how to provide the identityId, and what the return value looks like.

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 does not add any meaning to the single parameter 'identityId'. It neither explains the format nor provides examples.

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 ('Get') and the resource ('issuer-signed badge and signed fields for an identity'), distinguishing it from sibling tools like agent_identity_lookup or agent_identity_record.

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. The description does not mention when-not-to-use or provide context for selecting among identity-related siblings.

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

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

With no annotations provided, the description carries the full burden. It discloses that signatureValid is only a signature integrity signal, not an authenticity/safety check, and mentions a disclaimer. It adds moderate context beyond the name, but lacks details on error handling or 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 extremely concise, with a single sentence for the primary action and a clear note about the return values. No wasted words, and the most important information is 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 simple lookup tool with one parameter and no output schema, the description covers the basic purpose and the key nuance of the return value. However, it omits the structure of the response, potential errors, and the format of identityId, leaving some 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 0%, yet the description provides no information about the identityId parameter (e.g., format, type beyond schema). It fails to compensate for the low schema coverage, leaving the agent with no guidance on how to provide the identity.

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 'Look up an identity' and specifies the return values (signatureValid and disclaimer), providing a clear verb-resource pairing. However, it does not differentiate from sibling tools like agent_identity_record, so it falls short of a 5.

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

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

No explicit guidance on when to use this tool versus alternatives. The note about signatureValid not being an authenticity signal provides an indirect caveat but no positive selection criteria or comparison to other identity 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?

With no annotations, the description discloses key traits: hash-chaining implies immutability and append-only behavior, 'owner only' scopes access, and provenance is self-reported and unverified. This provides good behavioral context beyond a simple 'append record'.

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, concise but not optimized for quick scanning. It front-loads the core action but omits important context like required parameters and record structure.

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 (2 required), no output schema, and complex nested objects, the description is insufficient. It doesn't explain the content field, return value, error conditions, or how 'hash-chained' affects 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 coverage is only 25% (provenance described). The description adds little beyond restating provenance as optional self-reported. The content, identityId, and activityType parameters remain undocumented in both schema and description, leaving ambiguity.

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 (append) and resource (hash-chained activity record), and specifies 'owner only' which distinguishes it from tools like agent_identity_register or agent_audit_record.

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. The phrase 'owner only' implies restricted scope but doesn't explain when not to use it or what alternatives exist for other users.

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 correctly discloses that agent_name and metadata are self-reported and unverified. However, it omits other behavioral aspects such as whether the tool is idempotent, what happens on duplicate agentName, or response structure.

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 unnecessary words. The key information is front-loaded: the action and output, then the caveat about data verification.

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

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

Given the lack of annotations, output schema, and the presence of 3 parameters (one required, with nested object), the description is insufficient. It does not specify the return format, parameter roles for publicKey, or any preconditions/errors.

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 clarify each parameter. It only mentions agentName and metadata (noting they are self-reported) but omits the publicKey parameter entirely. It does not explain the metadata object structure or constraints.

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 (register an agent) and the result (unique identity ID + issuer-signed badge). It distinguishes from siblings like agent_identity_lookup by focusing on creation. The note about self-reported and unverified data adds specificity.

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 (to register an agent) but does not explicitly state when not to use or mention alternatives. Given the sibling tools, an agent might benefit from knowing that agent_identity_lookup is for retrieval, but this is not stated.

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

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

No annotations provided, so description carries full burden. Only states the action without disclosing irreversible nature, permissions needed, or what happens on success/failure.

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 is concise but lacks necessary detail. Could be restructured to include parameter hints without much length increase.

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?

Incomplete for a delete operation with 3 parameters and no output schema or annotations. Missing key usage (how to delete single vs all), and return behavior.

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% (no parameter descriptions), and the description does not explain any parameters. Agent cannot understand the role of key, agentId, or namespace beyond basic names.

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

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

Description clearly states verb 'Delete' and resource 'memory or all memories in a namespace', distinguishing it from siblings like get, search, store. Purpose is unambiguous.

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?

Implies usage for deleting memories but provides no guidance on when to delete single vs all, no alternatives, no prerequisites or context about namespace 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?

No annotations are provided, and the description does not disclose behavioral traits such as what happens if the key doesn't exist, whether it is read-only, or any side effects. This is a significant gap.

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

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

The description is a single short sentence, which is concise but lacks necessary information. It could include more context without becoming verbose.

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

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

With three parameters, no output schema, and no annotations, the description is highly incomplete. It does not explain what the return value is, the nature of the memory, or any constraints.

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 description coverage is 0%, meaning no parameter descriptions exist. The tool description does not explain the meaning or usage of the three parameters (agentId, key, namespace). It adds no value beyond the schema.

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

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

The description clearly states 'Retrieve a stored memory by key', which uses a specific verb and resource. It distinguishes from sibling tools like agent_memory_store, agent_memory_delete, and agent_memory_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?

No guidance is provided on when to use this tool versus alternatives. The agent must infer that it is for retrieving a specific memory by key, but there is no mention of when to use search or other siblings.

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 of disclosing behavior. It does not state that the operation is read-only, whether it requires specific permissions, or any side effects. The agent cannot infer safety or cost from this description.

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 wasted words. It immediately tells the agent what the tool does (search) and the resource (memories) followed by the key filters.

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 6 parameters and no output schema, the description is insufficient. It does not explain return values, pagination via limit, or the role of namespace. The agent lacks context to craft a complete call (e.g., required agentId is not mentioned in description, only in schema).

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 description adds meaning by naming the search criteria (prefix, tags, type), which map to parameters keyPrefix, tags, and type. However, it omits agentId, limit, and namespace, leaving 3 of 6 parameters unexplained. With 0% schema description coverage, the description partially compensates but is incomplete.

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

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

The description states the tool searches memories by prefix, tags, or type, clearly identifying the action (search) and resource (memories). It distinguishes from siblings like agent_memory_get (single memory retrieval) and agent_memory_store (storage), but could be more explicit about the resource being agent-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?

No guidance on when to use this tool over alternatives. It does not mention when to use search vs get, nor does it specify prerequisites or excluded scenarios (e.g., exact match versus semantic search).

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 disclose behavioral traits. It mentions 'key-value, with TTL and metadata', but omits critical details such as whether storing overwrites existing keys (upsert behavior), what is returned on success, or required permissions. The agent lacks clarity on 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?

Single sentence of 12 words, front-loaded with the action and resource, parenthetical adds key details. No redundancy, every phrase 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?

With 6 parameters, no output schema, and no annotations, the description is too spare. It does not explain return values, error conditions, namespace behavior, or idempotency. The agent cannot reliably infer how to invoke the tool or what to expect from it.

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 33%, only defining agentId and value. The description adds context for 'key', 'value', 'TTL' (ttlSeconds), and 'metadata', partially compensating for missing parameter descriptions. However, 'namespace' and 'agentId' remain unexplained beyond the schema, and the description does not provide explicit parameter mappings.

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 'Store a memory for an AI agent' with verb 'store' and resource 'memory'. It distinguishes from sibling tools like agent_memory_delete, agent_memory_get, and agent_memory_search by implying creation/update versus retrieval or deletion.

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_search for retrieval, agent_memory_delete for deletion). The description does not specify prerequisites, best practices, 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, the description should disclose behavioral traits. It mentions rotating proxy and robots.txt enforcement but omits crucial details like redirect handling, default method, rate limiting, error handling, and session usage.

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 two-sentence description is short but lacks structure. It is not wasteful but fails to convey necessary information efficiently.

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 (7 parameters, no annotations, no output schema, 0% schema description), the description is completely inadequate. It does not explain return values, behavior, errors, or parameter relationships.

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 only vaguely mentions region and type being selectable, without explaining any of the 7 parameters (e.g., url, body, headers, sessionId). The description adds no value beyond 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 clearly states the tool fetches a URL via a rotating proxy with selectable region/type and enforces robots.txt. This is a specific verb+resource combination that distinguishes it from sibling tools like agent_proxy_session.

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_webhook_poll), nor any 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?

With no annotations, the description must disclose all behavioral traits. It only mentions stickiness and IP reuse, but omits details on session lifecycle, error conditions, or impact of parameters like ttlSeconds (e.g., what happens on expiry).

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, highly concise sentence. It front-loads the core action and differentiator. However, it sacrifices completeness for brevity, which slightly lowers the score.

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 tool description is critically incomplete. It does not explain return values (e.g., session ID, IP address), parameter details, or behavioral context needed 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%, meaning the description must explain each parameter. It does not address type (e.g., residential vs. datacenter), region (format or allowed values), or ttlSeconds (beyond a numeric default). The agent gains no 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 'Create' and the resource 'sticky proxy session', and specifies the key benefit 'same IP for multiple requests'. This effectively distinguishes it from sibling tools like agent_proxy_fetch, which likely provides a single-use 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 implies usage for scenarios needing persistent IP, but it does not explicitly state when to use this tool versus alternatives (e.g., agent_proxy_fetch), 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?

No annotations provided, so description must disclose behaviors. Only mentions auto-expiry but omits details like default TTL, rate limits, or what happens on expiration.

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 waste. It could be slightly more informative 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?

Does not mention return value, output format, or effect beyond creating. Lacks completeness for a create tool with no output schema.

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% (description says nothing about parameters). The description does not explain ttlSeconds or preferredPrefix, which is essential since schema lacks 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 action (create) and resource (temporary email address) with auto-expiration note. It distinguishes from siblings like agent_tempmail_get, agent_tempmail_list, and agent_tempmail_wait.

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. The description lacks context for appropriate 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?

With no annotations provided, the description must fully communicate behavioral traits. It mentions that the tool returns 'full message content' and 'extracted verification links/codes', suggesting parsing. However, it fails to disclose whether the operation is read-only, if authentication is required, rate limit implications, or any side effects. This lack of transparency is a significant gap for a tool that retrieves content.

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 that conveys the core purpose without extraneous words. However, it could be improved by adding parameter details without losing conciseness. It earns its place but is slightly under-informative given the tool's complexity.

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, the description is incomplete. It does not mention return format, error conditions, or relationship to sibling tools beyond implicit differentiation. The tool is straightforward, but the description leaves significant gaps in operational context, especially regarding parameter semantics and behavioral expectations.

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 of the three parameters (mailboxId, messageId, includeRaw). The description only hints at the output content but adds no meaning to the input schema. The agent receives no guidance on what values are valid, the role of includeRaw, or the format of IDs, which is critically insufficient.

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 'full message content', and specifies the extraction of verification links/codes, which differentiates it from sibling tools like agent_tempmail_list (which likely retrieves metadata) and agent_tempmail_wait (which waits for messages). This makes the tool's purpose highly specific and unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as when to choose get over list or wait. It does not mention prerequisites, use cases, or conditions for using optional parameters like includeRaw, leaving the agent to infer usage without 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 provided, and the description only says 'list'. It doesn't disclose whether this is a read-only operation, pagination behavior, or any side effects. Very little 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?

Extremely concise at one sentence, but at the cost of missing critical information. It's not overly verbose, but it sacrifices completeness.

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

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

For a tool with 3 parameters and no output schema, the description is too sparse. It doesn't explain the return format, default behavior (e.g., limit=50), or how after filters messages. Missing essential details for correct invocation.

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

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

Schema description coverage is 0%, meaning the description does not explain any of the three parameters (mailboxId, after, limit). This leaves the agent uninformed about required vs optional fields or their meanings.

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 'List received messages in a mailbox', which is a specific verb+resource. It distinguishes from siblings like agent_tempmail_create and agent_tempmail_get without explicit differentiation but still clear.

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

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

No guidance on when to use this tool versus alternatives like agent_tempmail_get or agent_tempmail_wait. No context on prerequisites or limitations.

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 disclose behavioral traits. While it mentions long polling and a 60s timeout, it omits critical details like what happens on timeout (returns null/error?), whether the operation is cancellable, and if it consumes messages or leaves them intact.

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 that efficiently conveys the core function. However, it omits enough detail that the conciseness comes at the cost of completeness.

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 annotations, no output schema, and four undocumented parameters, the description is far from complete. An agent lacks critical information about return values, error handling, and proper parameter usage to invoke this tool correctly without external knowledge.

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 adds no meaning to the four parameters. Key aspects like default timeout (30s vs the noted 60s max), filtering semantics (fromContains, subjectContains), and the required mailboxId's format or source are left entirely to the agent to infer from schema 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 ('Wait') and resource ('incoming message') with an important qualifier ('long polling, max 60s'). It implies a blocking operation distinct from sibling tools like agent_tempmail_list or agent_tempmail_get, which are likely immediate/retrieval operations.

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 other tempmail operations or alternatives. The agent receives no context about prerequisites, polling strategies, or whether to prefer synchronous waiting vs manual polling.

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 disclose behavioral traits. It only mentions a max 100 constraint but lacks details on idempotency, side effects, rate limits, or authentication needs.

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 short and front-loaded, which is good for conciseness, but it is under-specified and lacks detail that would justify its 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 complexity of a batch operation with nested parameters and no output schema, the description is insufficient. It does not cover error handling, output format, or parameter semantics.

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 what 'subjects' are, the meaning of 'type' and 'value', or expected formats. It adds no value beyond the bare 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 'Get' and resource 'trust scores' with a specific constraint 'multiple subjects in one call (max 100)'. This distinguishes it from singlesubject tools like 'agent_trust_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?

The description implies batch usage but does not explicitly state when to use it versus alternatives like 'agent_trust_score'. No when-not or explicit 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 are provided, and the description only states that feedback is submitted. It fails to disclose behavioral traits such as idempotency, authorization needs, rate limits, or whether feedback can be modified or deleted.

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 it sacrifices valuable information. It is not optimally structured for clarity; the phrase 'positive or negative' could be replaced with specific parameter 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 5 parameters (4 required), including a nested evidence object and no output schema. The description is far too minimal—it omits input format, return values, and behavior, making it inadequate for correct invocation.

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

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

With 0% schema description coverage, the description adds almost no parameter context. It mentions 'positive or negative' but does not map this to the rating parameter (integer -2 to 2). No explanation of subjectType, category, or evidence.

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

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

The description clearly states the action (submit feedback) and the resource (agent/wallet) and mentions positive/negative feedback. However, it lacks differentiation from sibling tools like agent_trust_batch (batch submission) and agent_trust_score (querying 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?

No guidance on when to use this tool versus alternatives. The description does not mention batching or scoring, leaving the agent without decision 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 provided; description lacks behavioral details such as authentication requirements, rate limits, or response structure, which is critical for a read 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?

Single sentence, front-loaded with verb, no wasted words. However, more structure could improve readability.

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 output schema or annotations, the description leaves gaps: no definition of trust score, no explanation of includeDetails, and no indication of response 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 0%, and the description only lists subject types without explaining subjectValue or includeDetails, failing to add meaningful context 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 'Get trust score' and lists three specific subject types (wallet, agent card URL, domain), distinguishing from related tools like batch query or feedback.

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?

Implies usage for single trust score queries but gives no explicit guidance on when to choose this tool over siblings like agent_trust_batch or agent_trust_feedback.

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 behavioral traits, but it only states the creation action. It fails to mention any side effects, return values, authentication needs, or rate limits, leaving significant gaps in understanding the tool's 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 very concise at one sentence, but it is too sparse. It could be more structured while maintaining conciseness, such as mentioning key parameters or what the tool returns.

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 (six parameters, nested objects, no output schema), the description covers only the high-level action. It lacks details about parameter usage, return values, and operational context, making it inadequate for an agent to use the tool effectively.

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 description adds no information about the six parameters, which have 0% schema coverage. Even the enum 'deliveryMode' is not explained. The agent must rely on parameter names and enum values 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 for relaying requests to an agent. While it uses a specific verb and identifies the resource, it does not differentiate from sibling webhook tools like listing or polling, but the verb 'create' sufficiently implies the action.

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 prerequisites or the order of operations (e.g., need to create before polling). The description lacks any context 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?

With no annotations, the description should disclose behavioral traits, but it only states the basic function. Missing details like read-only nature, pagination behavior, error handling, 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?

The description is very brief (6 words), but it omits essential information about parameters and usage, making it too short for adequate understanding.

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

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

Given 3 parameters, no output schema, and no annotations, the description fails to provide enough context about result format, ordering, default behavior, or error cases.

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 explain parameters, but it does not mention endpointId, limit, or offset at all, leaving the agent to infer meaning from the tool name 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 resource (requests received by a webhook endpoint), distinguishing it from sibling tools 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?

The description does not provide any guidance on when to use this tool versus alternatives (e.g., agent_webhook_poll) or any usage prerequisites or limitations.

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

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

With no annotations, the description must disclose behavior. It mentions 'long polling, max 60s', indicating blocking behavior, but omits details like what happens on timeout, whether it is read-only, or the nature of returned data.

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, front-loading the action and key behavior (long polling, max 60s). It avoids verbosity but at the cost of missing parameter and usage 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?

Given four parameters, no output schema, and no annotations, the description is incomplete. It does not explain the return format, how to use the 'after' parameter for pagination, or the implications of the timeout, leaving agents to guess critical usage 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 description coverage is 0%, so the description must explain parameters. It fails to clarify the meaning of 'after', 'limit', 'timeout', or 'endpointId', providing no semantic value beyond the schema's type and default 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 verb 'poll' and resource 'webhook requests', with 'long polling, max 60s' distinguishing it from sibling tools like agent_webhook_list_requests. However, it does not elaborate on the concept of 'new' or how polling differs from a one-time fetch.

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

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

No guidance is provided on when to use this tool versus alternatives like agent_webhook_list_requests. The description does not mention prerequisites, exclusions, or appropriate contexts.

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 side effects. 'Replay' implies resending the webhook, but it doesn't state whether it modifies state or has other consequences.

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

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

While the description is a single sentence, it is too minimal and does not earn its place by adding value beyond the name. It could include more context without sacrificing 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 three parameters and no output schema or annotations, the description is insufficient. It omits essential details like what the 'toUrl' parameter does and what happens after replay.

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 explanations for the three parameters (endpointId, requestId, toUrl), leaving the agent without guidance on how to populate them.

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

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

The description 'Replay a stored webhook request' uses a specific verb and resource, clearly differentiating it from sibling tools like agent_webhook_create and agent_webhook_list_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 is provided on when to use this tool versus alternatives, such as when to replay vs. create or poll a webhook.

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 discloses key behaviors: only watches for NEW events, does not backfill, and pushes notifications. However, it does not mention idempotency, error handling, or authorization needs, leaving some 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 concise (two sentences plus filter list) and front-loads the purpose. Every sentence adds information without redundancy. Room for minor improvement in structure (e.g., bullet points for filters).

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

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

The description omits the return value (e.g., watch ID) and error scenarios. Since no output schema is provided, the description should cover what the tool returns. This gap makes it incomplete for an agent to fully understand the tool's behavior.

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 description adds value beyond the schema by stating that keyword and entity are case-insensitive substrings, and that at least one filter (keyword or entity) is required despite the schema only requiring destinationType and destinationTarget. It does not elaborate on destination parameters, but schema covers them (80% 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 creates a saved watch that triggers notifications on new matching events. It uses a specific verb ('Create') and resource ('saved watch'), and distinguishes from sibling watch tools (e.g., alerts_list_watches, alerts_delete_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 provides filter requirements (at least one of keyword/entity) and clarifies that backfill never fires. It implicitly guides when to use (for new event notifications) but does not explicitly mention alternatives like alerts_list_watches for viewing existing watches.

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?

Description explicitly states 'soft delete' and 'stops future notifications', providing key behavioral insight beyond what annotations would. No annotations 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?

Single sentence front-loads core purpose and key side effect (soft delete, stops notifications). 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?

For a one-parameter tool with no output schema, description adequately covers purpose, effect, and soft-delete behavior. Could mention return value or error cases.

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 coverage, description adds meaning by clarifying 'by id'. However, it could be more explicit about the parameter format or type.

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?

Tool name and description clearly state it deactivates a watch by ID (soft delete). Distinguishes 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 for deactivating watches, but no explicit guidance on when to use vs. alternatives or when not to use (e.g., if watch already inactive).

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'List' implying a read operation, but does not mention authentication requirements, rate limits, pagination behavior, or the nature of the returned data (e.g., whether it includes details or just IDs).

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 conveys the core function with no extraneous words. It is appropriately short for the simplicity of the tool.

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

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

Given the lack of an output schema, the description would benefit from explaining what the returned watches contain (e.g., watch ID, query, timestamp). The current description is minimal and leaves the agent guessing about the response format, making it slightly incomplete.

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

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

The input schema has no parameters (100% coverage), so the description does not need to add parameter meaning. The description is consistent with the schema, and no additional semantic value is required.

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' and the resource 'the calling user's saved watches', distinguishing it from sibling tools like alerts_create_watch and alerts_delete_watch. However, it does not specify what a 'watch' represents in this context, leaving some ambiguity.

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

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

The description implies usage when you need to list the user's saved watches, but it provides no explicit guidance on when to use this tool versus alternatives (e.g., creating or deleting watches) or any constraints or prerequisites.

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

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

No annotations provided, so description must fully disclose behavior. It states returns but does not confirm read-only nature, error handling, or whether it has side effects. Lacks detail on what happens with invalid IDs.

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?

Very concise at two sentences, front-loading the main purpose. Could be slightly more detailed without harming 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 no output schema or annotations, description should provide more context on return structure and usage. Only mentions two fields, missing full account of what the detail and timeline include.

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 description adds no meaning for the single parameter 'itemId'. It does not explain what itemId represents or how to obtain it, leaving the agent guessing.

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 retrieves a bid notice detail and its full event timeline, specifying returned fields. This distinguishes from siblings like bid_watch_search and bid_watch_timeline, though not explicitly naming them.

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

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

No guidance on when to use this tool versus alternatives such as bid_watch_search or bid_watch_timeline. No context on prerequisites or typical use cases.

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

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

No annotations provided, so description carries full burden. It explains the scope (all bid notices) and output fields (firstSeenAt, ledgerVerified), but lacks disclosure of side effects, security requirements, or performance characteristics. Adequate but not thorough.

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 succinct sentences: first defines purpose and scope, second describes output fields. No redundancy or filler.

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

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

Without output schema or annotations, and with only 1 of 3 parameters explained, the description is insufficient. The return structure is partially described but not fully, and differences from numerous sibling tools are not addressed.

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 mentions the 'since' parameter implicitly (ISO8601 timestamp) and ignores 'limit' and 'entity'. The 'entity' parameter is unexplained, and no details on default or format are provided 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 returns recent bid notice events (appearance, deadline-move, close, cancel, award) since an ISO8601 timestamp, which differentiates it from other bid watch tools. However, it doesn't explicitly contrast with siblings like bid_watch_search or bid_watch_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 alternatives. The description only implies use for recent changes but doesn't address filtering, prerequisites, or comparison to other watch 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?

With no annotations provided, the description must disclose behavioral traits. It only states that it searches and returns hits with two fields. It does not mention whether it is read-only, any authentication requirements, rate limits, pagination behavior, or side effects. This is 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?

The description is very concise (one sentence) and front-loads the source and result fields. However, it could be slightly more structured (e.g., grouping parameters or providing an example). It is minimally sufficient but not bloated.

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 and annotations, the description should provide more completeness about the return format, pagination, error handling, and limitations. It only mentions two fields in the response. The complexity of the tool (6 parameters, many siblings) warrants more detail.

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 33% (only 'entity' and 'bidType' have descriptions in the schema). The tool description adds no additional meaning to parameters like 'query', 'since', 'limit', or 'status'. It does not explain how parameters interact or provide examples. The description does not compensate for the 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 it searches Japanese public-procurement bid notices from a specific source (kkj.go.jp) and mentions that results include 'firstSeenAt' and 'ledgerVerified'. This differentiates it from sibling tools like 'bid_watch_get' (retrieval) and 'bid_watch_recent_changes' (list 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?

The description does not explicitly state when to use this tool versus alternatives. While the purpose is clear, there is no guidance on scenarios where other tools (e.g., 'bid_watch_get') would be more appropriate. Usage context 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?

No annotations exist, so description bears full burden. It mentions return fields (firstSeenAt, ledgerVerified) but omits behavioral traits like read-only status, auth requirements, 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?

Two sentences are efficient, but the second sentence listing fields is somewhat sparse. No front-loading issues; every sentence serves a purpose.

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

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

Given simple schema (1 param) and no output schema, description explains purpose and return fields but lacks details on parameter semantics, ordering, or additional 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?

With 0% schema coverage, the description must explain parameters. It does not mention the required 'itemId' parameter at all, offering no guidance on its purpose or format.

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 provides 'time-ordered events only for a bid notice', listing specific event types. It distinguishes from siblings like bid_watch_get by emphasizing the chronological, historical nature.

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?

It defines when to use (for timeline of events) and implies not for current state, but lacks explicit alternatives or when-not conditions. Context is clear but no exclusions stated.

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

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

No annotations are provided, so the description carries the full burden. It lists return fields but does not disclose whether the tool is read-only, destructive, or requires authentication. The behavior is implied as a read operation, but not stated explicitly.

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 lists return fields. Every word earns its place; no filler.

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

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

For a simple tool with one parameter and no output schema, the description covers the purpose and return fields. However, it lacks parameter documentation and behavioral context, making it minimally viable but with 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 0% and the description does not mention the only parameter 'itemId' at all. It does not explain its format, meaning, or constraints, providing no added value over the bare 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 verifies hash-chain integrity of a bid notice for tamper detection, which is a specific verb-resource combination. It distinguishes from sibling bid_watch tools (get, recent_changes, search, timeline) and other verify_ledger tools by specifying 'bid notice'.

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

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

The description provides clear context: use this tool when you need to verify the integrity of a bid notice. However, it does not explicitly exclude scenarios or mention alternatives among the many bid_watch tools, so it lacks exclusions.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool is 'pure compute' (side-effect-free, idempotent) and 'price 0.0 (free)', which are key behavioral traits. It does not detail what happens on invalid input (e.g., negative kWh) or specify rate limits, but for a simple estimation tool, the core behavior is adequately communicated.

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: one sentence and a short clause totaling about 20 words. It front-loads the action and output ('Estimate electricity CO2e (kg)') with no extraneous 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?

Given there is no output schema, the description should fully explain the return value. It indicates the output is in 'CO2e (kg)' but does not specify the structure (e.g., a single number vs. an object), nor does it mention error handling or constraints beyond the schema. For a simple tool this may be sufficient, but more detail on the output format 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?

Schema coverage is 100% with descriptions for both parameters. The description adds meaningful context: it explains that the region parameter provides a 'regional grid-intensity factor' and clarifies that the default is the 'IEA world average'. This enhances understanding beyond the schema's enum list and default mention.

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' and the resource 'electricity CO2e (kg)' from 'energy use (kWh) and a regional grid-intensity factor'. It differentiates from similar carbon tools (e.g., carbon_estimate_emission_factor) by specifying the computation of emissions rather than returning a factor, and it mentions the default factor source (IEA world average). The phrase 'pure compute; price 0.0 (free)' further clarifies the nature of the tool.

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 kWh data and want to compute emissions for electricity, and it mentions the default regional factor. It explicitly states 'pure compute; price 0.0 (free)', which is a strong usage signal (no cost, no side effects). However, it does not explicitly state when not to use it or directly contrast it with siblings like carbon_estimate_emission_factor, which could provide clearer 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?

With no annotations provided, the description carries the full burden. It discloses that the tool is 'pure compute' and free, but omits details like error handling, caching, or authorization 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?

Two sentences with zero waste. The first sentence immediately conveys the exact purpose, and the second adds a cost/behavior 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 lookup tool with one parameter and no output schema, the description adequately covers what the tool returns (value, unit, category) and provides examples. However, it lacks details on error states or response 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% (the only parameter 'activity' has a description). The description adds no additional meaning beyond the schema's examples, 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 the verb 'Look up' and the resource 'published emission factor (value, unit, category)' for a specific activity key, differentiating it from sibling tools like carbon_estimate_compute_emissions which compute full 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 indicates it is a pure compute, free operation, implying safe and cost-free usage. It clearly implies when to use (looking up a single factor) but does not explicitly exclude or compare to 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?

No annotations provided, but the description states 'Pure compute; price 0.0 (free)', indicating no side effects and statelessness. This adds transparency about the tool's behavior, though it could mention that no external calls are made.

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 that front-load the main purpose and key behavioral trait (free pure compute). 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 single-parameter, no output schema tool, the description provides sufficient context: input is kg CO2e, output is USD cost and tree/forest-year equivalents, and the computation is based on published constants. Nothing is missing for an agent to use it correctly.

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

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

The schema already documents the single parameter kgCO2e with description. The description adds context about output (USD, tree-year equivalents) but does not add meaning to the parameter beyond the schema. Baseline 3 applies due to 100% 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 estimates voluntary-market offset cost (USD) and tree/forest-year equivalents for a given kg CO2e, using published constants. It differentiates from sibling carbon_estimate tools (e.g., compute_emissions) by focusing on offset estimation.

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 offset cost estimation but does not explicitly state when to use or when not to use, nor does it provide alternatives. The pure compute nature is noted, but guidance on when to prefer this over other carbon tools is lacking.

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 states 'Pure compute; price 0.0 (free)' suggesting no side effects, but does not disclose return format, synchronization, or potential 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?

Two sentences, no filler. Purpose and pricing are front-loaded. 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?

For a simple compute tool with 3 parameters, the description covers purpose, inputs, and pricing. Lacks explicit output format, but output is implied as CO2e in kg.

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 adds the output unit 'kg CO2e' but does not elaborate on each parameter beyond what the schema provides.

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

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

The description clearly states the tool estimates freight CO2e from weight, distance, and mode using standard emission factors. It specifies 'freight' which distinguishes it from sibling tools like carbon_estimate_travel_emissions. The verb 'estimate' and resource 'freight CO2e' 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 use for freight shipping emissions but does not explicitly compare to sibling tools like carbon_estimate_compute_emissions. It mentions being free, but lacks when-not or alternative 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?

With no annotations, description says 'pure compute' and 'free', but doesn't disclose limits (e.g., distance bounds, mode assumptions) or whether results are cached. Adequate but not detailed.

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, direct and efficient. No 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?

Lacks output description (likely a number), and doesn't specify if distance is one-way or round trip, or handling of mixed modes. Adequate for simple tool but not 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%, so description adds minimal value beyond naming inputs. Mentions 'embedded per-passenger-km factors' but doesn't elaborate on factor sources.

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 estimates CO2e (kg) for passenger travel from distance and mode, using embedded factors. It distinguishes from siblings like carbon_estimate_shipping_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?

Mentions it's pure compute and free, implying it's a lightweight calculation. No explicit when-to-use vs alternatives, but sibling names provide 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?

With no annotations provided, the description carries full burden. It explicitly states 'Read-only' (non-destructive) and 'price 0.0 (free)', which are key behavioral traits. However, it does not disclose rate limits, authentication requirements, or other constraints.

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

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

The description is a single, well-structured sentence. It front-loads the core purpose (score 0-100 with rationale) and then lists input options efficiently. No redundant or verbose phrasing.

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 (score computation from product data), the description covers inputs and basic behavior (read-only, free, transparent rationale). However, no output schema exists, and the description does not detail the output format beyond 'score with rationale'. This is acceptable for a score tool but could be slightly more explicit.

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% (all three parameters have descriptions). The description merely restates the parameters ('from a url, raw html, or inline product') without adding new semantics. Baseline 3 is appropriate as schema already documents parameters adequately.

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 ('score') and resource ('product readiness for autonomous agents'), specifying the output range (0-100) and input sources (url, html, inline product). It distinguishes from sibling tools like commerce_catalog_availability_check and commerce_catalog_price_compare, which address different aspects of product 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?

The description explicitly lists the three input modes (url, raw html, inline product) and notes it is read-only and free. While it doesn't contrast with alternatives, the sibling tools serve distinct purposes (availability, validation, price, extract), making the usage context clear without needing explicit 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 adds value by stating it is read-only and free, but does not disclose other behavioral traits like error handling 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?

Two sentences efficiently convey the core function, output, 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?

The description specifies the output coarse signal values, and is sufficient for a simple read-only tool. Minor gap: no mention of error handling.

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 each parameter described. The description summarizes the three mutually exclusive options, adding little 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 resolves stock availability into a coarse signal (in_stock/out_of_stock/limited/preorder/unknown), distinguishing it from sibling commerce tools which focus on extraction, validation, or price comparison.

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 specifies the input modes (url, html, product) but does not provide explicit when-to-use or alternative guidance. The context is clear but lacks exclusions.

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

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

With no annotations provided, the description carries full burden. It states 'Read-only; price 0.0 (free)', which adds transparency about side effects and cost. However, it lacks details about response format, limits, or what happens with invalid inputs.

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: first delivers purpose and output, second states read-only and cost. No fluff, front-loaded, and efficient for an agent to parse.

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 parameter coverage, the description lacks details about the output (completeness score, required fields), error handling, or how the input sources differ. For a validation tool in a large catalog, agents would benefit from more context on return values and behavior.

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

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

Schema description coverage is 100%, so the schema already documents the three parameters. The description briefly mentions 'url, raw html, or an inline product object' but adds no additional meaning beyond the schema's descriptions. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool validates product-feed completeness, listing required fields, completeness score, and three input sources (url, html, product). This specific verb+resource combination distinguishes it from sibling tools like product_extract or availability_check.

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 validating completeness and specifies input options but does not explicitly guide when to use this tool over alternatives like commerce_catalog_product_extract or commerce_catalog_availability_check. No exclusions or when-not advice.

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 'Pure; price 0.0 (free)', indicating no side effects and no cost. It also notes the non-empty requirement. It could add error handling details, but the provided info is helpful.

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 function, second adds prerequisites and cost. Every sentence earns its place 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?

The description explains the return values (cheapest, most expensive, spread, per-offer ranking) despite no output schema. It covers the tool's core function but omits error handling 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 coverage is 100%, so parameters are already described. The description adds the constraint that the array must be non-empty and explains the result, but does not add significant meaning beyond 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 tool's verb 'compare' and resource 'offers' are specific. It clearly states it returns cheapest, most expensive, spread, and ranking. No sibling tool performs price comparison, distinguishing it effectively.

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 explicitly requires a non-empty offers array, providing a clear precondition. However, it does not mention when to avoid using the tool or suggest alternatives, which would improve 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?

Describes the tool as read-only and free, and specifies it works on Schema.org/JSON-LD markup. No annotations present, so description carries the burden. Could mention what happens if no markup is found, but core behaviors are 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?

Two concise sentences with no fluff. Front-loaded with purpose and key details (input type, cost). 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?

Lacks details on output format or response structure (no output schema). While it lists example fields, it doesn't specify whether extraction returns all fields or only those present, or behavior on errors (e.g., missing markup). Adequate for a simple tool but incomplete for robust 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 coverage is 100% for the two parameters (url, html). Description adds minimal extra context: 'Provide a url to fetch or raw html' reiterates the schema's 'one of' constraint. No additional format or constraint details beyond 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 extracts normalized product data (name, price, currency, etc.) from Schema.org/JSON-LD markup. Verb 'extract' and resource 'product' are specific. Distinguishes from sibling commerce tools which deal with availability, validation, or price comparison.

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?

Explicitly says to provide a URL to fetch or raw HTML, indicating how to invoke. Declares read-only and free pricing. However, lacks guidance on when to use versus 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?

With no annotations provided, the description carries the full burden. It states 'Read-only; price 0.0 (free)', which covers safety and cost, but lacks details on rate limits, data freshness, supported jurisdictions, or error handling.

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 efficiently conveys the core purpose, required inputs, and key attributes (read-only, free). 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 no output schema, the description includes a list of returned fields (name, status, dates, type, address) and the data source (OpenCorporates), which is adequate for a simple fetch tool. However, it could mention expected response format or limitations.

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 both parameters. The description merely reiterates 'jurisdiction' and 'company number' without adding new semantic 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 'Fetch', the resource 'company profile', and lists specific fields (name, status, dates, type, address). It distinguishes itself from sibling tools like `company_registry_search_company` by requiring a jurisdiction and company number.

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 indicates usage when a jurisdiction and company number are known, but does not explicitly compare to alternatives like `company_registry_search_company` for unknown numbers or `company_registry_jurisdiction_info` for jurisdiction data.

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 the tool is pure compute and free, implying no side effects. It does not detail return format or errors, but for a simple lookup this is adequate.

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 plus a brief note on pricing. It is front-loaded with the core purpose and wastes no 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?

For a one-parameter lookup without an output schema, the description sufficiently covers purpose, input, and behavioral traits (free/compute). It could mention potential error cases but is otherwise complete.

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

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

Schema coverage is 100% with a clear description of the 'code' parameter. The description adds context about outputs ('name, registry details') beyond the schema, aiding understanding of what the tool returns.

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 'Look up metadata for a jurisdiction code' with specific outputs like 'name, registry details'. It distinguishes itself from sibling tools like company_registry_company_profile which focus on individual companies rather than jurisdiction 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 implicitly tells when to use this tool (when needing jurisdiction metadata) and notes it is 'Pure compute; price 0.0 (free)', indicating no cost. It lacks explicit alternatives but is clear enough for an agent to decide.

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 for behavioral disclosure. It states 'Read-only' and price 0.0, which is useful. However, it omits details like rate limits, pagination, or error handling. The read-only hint is helpful but incomplete for a full behavioral picture.

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 a parenthetical list of output fields. It is concise, front-loaded, and contains no redundant information. 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 listing tool with 2 parameters and no output schema, the description covers purpose, input, output fields, source, and cost/read-only status. Missing details like pagination or response structure are minor gaps; the listed output fields partly compensate for the lack of output schema.

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 both parameters. The description mentions 'by jurisdiction + company number', matching the schema but adding no extra semantics such as format examples or allowed values. Baseline 3 is appropriate given full 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 lists company officers, specifies output fields (name, position, dates, current flag), and required inputs (jurisdiction + company number). It names the data source (OpenCorporates) and is distinct from sibling tools like company_registry_company_profile (profile) or company_registry_search_company (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?

The description notes it is read-only and free, which helps usage decisions. However, it does not explicitly state when to use vs. alternatives like company_registry_company_profile for detailed company info or when not to use (e.g., no company number). The sibling tools' purposes are different, so the context is reasonably clear.

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 disclose behavior. It states the tool is read-only and free, but does not mention rate limits, pagination, or response structure. The description is adequate but not rich.

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

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

The description is two sentences long, front-loaded with the verb and resource, and contains no redundant information. Every word is purposeful.

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?

Though there is no output schema, the description mentions that it returns candidate companies for disambiguation, which provides enough context for a simple search tool. It lacks details on result fields but is adequate given low complexity.

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 schema already documents all parameters clearly. The description adds context ('optionally scoped to a jurisdiction') but no new 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 verb (Search), resource (companies), and scoping (by name and optionally jurisdiction). It distinguishes from sibling tools like company_registry_company_profile by mentioning OpenCorporates API and disambiguation.

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 'Returns candidate companies for disambiguation' implies this tool is a first step before getting full profiles, but it does not explicitly mention when to avoid it or list alternatives. The context is clear enough for typical 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 provided, so the description must fully convey behavioral traits. It states 'Pure compute' to indicate no side effects, and lists the return values (valid flag, normalized value, reason) and pricing (free). This provides sufficient transparency for a validation tool, though it could mention that it only checks format, not registry existence.

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: three short sentences deliver the purpose, behavioral note, return summary, and pricing. Every sentence adds value, and the most critical information (what it does) is front-loaded. 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 the tool's simplicity (2 required params, no output schema, no nested objects), the description adequately covers the core task, output summary, and pricing. It does not detail potential error cases or behavior for unknown jurisdictions, but for a pure validation tool with a clear return structure, it is mostly 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%, so the schema documents both parameters with examples. The description does not add additional semantics beyond the schema; it mentions jurisdiction and company number implicitly but provides no new information about parameter format, constraints, or meaning. A score of 3 is appropriate as the description is not required to repeat schema details.

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 explicitly states the tool's purpose: validating a company-registration number against expected format for its jurisdiction. It uses specific verbs ('validate') and resources ('company-registration number'), and clearly distinguishes from sibling tools like company_registry_company_profile and company_registry_search_company, which fetch or search data rather than validate format.

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 this tool is for format validation only ('Pure compute'), but does not explicitly state when to use it versus alternatives. It does not mention that this tool does not check the existence of the company or provide additional data, which would help differentiate it from siblings. The lack of explicit 'when to use' or 'when not to use' guidance keeps this at a 3.

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 disclose behavioral traits. It mentions the tool uses lexical-diversity and burstiness signals, provides a transparent rationale, and is free with no network calls. However, it does not describe the return format, idempotency, or any potential side effects, which are needed for a tool with no output schema.

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 at 28 words across two sentences. It front-loads the core purpose and key constraints (free, no network), with no unnecessary words or repetition.

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

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

Given the lack of an output schema, the description should clarify the return value. It mentions a 'likelihood (0-100)' and 'transparent rationale', but does not explicitly state the output structure (e.g., object with score and explanation). The tool's simplicity mitigates this, but completeness could be improved.

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% description coverage for the single 'text' parameter, with a clear description 'Text passage to score'. The description reinforces this but does not add significant new semantic information beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: assessing the heuristic likelihood (0-100) that a text passage is AI-generated, using lexical-diversity and burstiness signals. It is distinct from sibling content_authenticity tools that deal with C2PA, domain reputation, provenance, and watermark detection, which are for different media types and methods.

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 the tool is suitable for scoring text passages and is free with no network calls, but it does not explicitly state when to use this tool over alternatives or when not to use it. No contrast with other tools is provided, leaving the agent to infer usage from purpose 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?

No annotations are provided, so the description carries the full burden. It discloses read-only behavior, that it performs one HTTPS GET, and that it is free. This is good transparency for a simple tool, though it does not mention failure modes or output 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?

Three sentences: each sentence serves a distinct purpose (action, instruction, behavioral context). No redundancy, front-loaded with key 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 no output schema, the description hints at the output ('lifting any human-readable claim generator') but does not fully specify return value structure. It covers main aspects of input and behavior, making it mostly complete for a simple 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%, so the schema already documents the parameter. The description adds 'Provide an image url,' which repeats the schema description without additional semantics. 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 detects a C2PA/Content Credentials manifest by scanning raw image bytes for JUMBF markers and lifting the claim generator. It distinguishes from sibling tools like watermark_detect or ai_likelihood by specifying the technical method and output.

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 needing to check for C2PA credentials on an image URL but does not explicitly state when to use this tool versus alternatives, nor does it provide exclusion criteria. Usage is implied but not 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?

With no annotations, the description discloses it is read-only and free, and outlines the methodology (age, TLS, DNS/MX/SPF/DMARC via DoH/RDAP/CT), providing good transparency for a simple 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?

A single sentence efficiently captures purpose, methodology, and cost with no waste. All information is front-loaded and relevant.

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 mentions the score range (0-100) which partially covers return values. It is mostly complete for a simple tool, though exact response structure 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?

The schema already describes the domain parameter. The tool description adds context about the signals used, which adds some meaning, but does not elaborate beyond the schema's 'Domain name to score.'

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 provides a heuristic reputation score (0-100) for a domain based on multiple signals. However, it does not explicitly differentiate from the sibling tool domain_intel_reputation, leaving some ambiguity.

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

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

No guidance on when to use this tool versus alternatives like domain_intel_reputation or other domain tools. The description only explains functionality, not selection criteria.

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 the full burden. It clearly states the tool is read-only and free (price 0.0), and mentions that rationale is provided. This adequately discloses key behavioral traits for a read-only, non-destructive 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 two additional short statements, all front-loaded. Every element adds value: the action, the components, the read-only and cost attributes. 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?

For a simple tool with one parameter and no output schema, the description covers the core functionality, cost, and safety. It does not detail the response format, but the mention of 'rationale' provides some expectation. Overall sufficient for the complexity.

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 a single parameter described as 'Image URL to check'. The description adds context by specifying 'image url' and 'media-provenance verdict', but the schema already provides the essential meaning. The description adds marginal 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 explicitly states the tool produces a combined media-provenance verdict for an image URL, combining C2PA presence and domain reputation with rationale. This clearly distinguishes it from sibling tools like content_authenticity_c2pa_inspect and content_authenticity_domain_reputation.

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 indicates the tool is read-only and free, but does not explicitly state when to use this combined check versus individual sibling tools. However, the presence of sibling tools and the description's emphasis on 'combined' implies the appropriate use case.

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 best-effort behavior and read-only nature, but does not detail failure modes, rate limits, or authentication needs. More context on what happens when markers are not found would be helpful.

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, using two sentences to convey purpose, required input, and safety/cost. Every sentence adds value, and the key info is 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 simple tool with one parameter and no output schema, the description covers purpose, required input, and behavioral traits (best-effort, read-only, free). It lacks a brief note on the likely return format (e.g., list of detected markers), but overall it is quite 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 a single parameter 'url' described as 'Image URL to inspect'. The description adds context about 'raw image bytes', providing slight additional meaning. Baseline is 3 since schema already covers the parameter well.

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 function: best-effort detection of watermark and provenance markers (C2PA/IPTC/XMP) from an image URL. It distinguishes itself from sibling tools like content_authenticity_c2pa_inspect by being broader and lighter.

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 specifies that the user should provide an image URL and notes the tool is read-only and free. While it implies context for use, it does not explicitly state when to choose this tool over alternatives like c2pa_inspect or ai_likelihood.

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 free pricing, plus the backend (Cloudflare 1.1.1.1 JSON). Lacks details on rate limits, error handling, or response structure. Adequate but not thorough.

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 sentence plus a short phrase. All information is front-loaded and necessary.

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; description does not explain return format or behavior for missing records. Simple tool, but could mention 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 already provides 100% coverage with descriptions for both parameters. The tool description restates record types but adds no new semantic value beyond 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 it resolves specific DNS record types (A, AAAA, MX, TXT, NS, CNAME) for a domain via DNS-over-HTTPS. Differentiates from sibling domain intel tools like whois, email auth, reputation, TLS by focusing on DNS records.

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. Mentions read-only and free, but does not compare to sibling tools or provide 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, the description carries full burden. It discloses read-only behavior, cost, and 'best-effort DKIM selector probing' as a limitation. It does not detail error handling or response format, but the information provided is adequate for safe invocation.

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

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

The description is three concise sentences, front-loaded with the main action, then detailing extraction specifics, then behavioral/cost info. 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 the tool's simplicity (2 params, no output schema), the description sufficiently explains what is extracted. It lacks output format details, but that is acceptable without a schema. Error handling is not mentioned, but the tool is straightforward.

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 both parameters. The description adds value by stating 'Optional DKIM selectors to probe (default: common selectors)', clarifying the default behavior beyond the schema's 'Optional DKIM selectors to probe'.

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 'Parse SPF / DMARC / DKIM presence and policy from TXT records (via DoH)', specifying the exact verb and resource. It details the extracted policies (SPF all-qualifier, DMARC p/pct/rua, DKIM selectors), distinguishing it from sibling tools like domain_intel_dns_lookup which is a generic DNS 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 includes 'Read-only; price 0.0 (free)', providing clear usage context. It lacks explicit guidance on when to use this tool over alternatives like domain_intel_dns_lookup, but the specific focus on email authentication implicitly directs the agent.

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 discloses that the tool is read-only, free, returns a heuristic score with a rationale, and is not a security guarantee. This covers key behavioral traits, though it lacks details on rate limits or error handling.

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 (four sentences), front-loaded with the core purpose and components, and 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 one parameter and no output schema, the description explains the score range (0-100), components, and that rationale is included. It is mostly complete but could benefit from specifying the output format (e.g., JSON 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?

The only parameter 'domain' has a schema description 'Domain name to score'. The tool description reinforces this but adds no additional format, validation, or examples. With 100% schema coverage, a baseline of 3 is appropriate.

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

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

The description clearly states it computes a heuristic reputation score (0-100) combining domain age, TLS validity, email-auth strictness, and MX signal. It distinguishes from sibling tools like domain_intel_dns_lookup by being a composite score rather than a raw 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 mentions 'Informational only, not a security guarantee' which provides a caution, but does not explicitly state when to use this tool over alternatives like domain_intel_email_auth_check or content_authenticity_domain_reputation.

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

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

No annotations are provided, so the description carries the full burden. It discloses read-only nature and zero cost, which is helpful for safe invocation. It mentions the source and selection logic (freshest leaf). However, it does not cover potential error conditions (e.g., domain not found), rate limits, or authentication requirements, leaving gaps for the agent.

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 filler. The first sentence establishes core purpose and source, the second adds specific output details and cost/read-only reminder. Information is front-loaded and every phrase earns its place.

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

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

The description covers the essential aspects: source, selection logic, key output fields, and safety/cost. However, without an output schema, it does not fully describe the return structure (e.g., format of SAN summary, data types). A slightly more detailed output description would elevate completeness to a 5.

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% description coverage for the single parameter 'domain', which is described as 'Domain name to inspect'. The tool description does not add additional semantics beyond the schema, such as format expectations or validation rules. A baseline score of 3 is appropriate since the schema already suffices.

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 TLS certificate issuer, validity, and SAN summary from public Certificate-Transparency logs. It specifies the data source (crt.sh JSON) and key output fields (currentlyValid, daysUntilExpiry). This distinctly differentiates it from sibling domain intelligence 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 implies the tool is for TLS certificate inspection but does not explicitly state when to use it versus alternatives. There are no usage exclusions or comparisons to other domain intel tools. While the context is clear, explicit guidance on when not to use it or which sibling to choose instead is missing.

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 the tool is read-only and free, and mentions the protocol (RDAP over HTTPS). However, it lacks details on rate limits, authentication requirements, or what happens if the domain does not exist or is invalid.

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 front-load key outputs, protocol, and cost. Every word adds value 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 no output schema, the description lists expected return fields, making it fairly complete for a simple lookup tool. It could mention error responses or domain validation, but overall provides sufficient 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% (one parameter 'domain' described as 'Domain name to look up'). The description adds no additional meaning beyond the schema's existing description, 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 the tool provides a domain WHOIS summary via RDAP, listing specific fields like registeredAt, expiresAt, ageDays, registrar, status, and nameservers. It distinguishes itself from sibling tools like domain_intel_dns_lookup by focusing on RDAP/WHOIS data rather than DNS or email auth.

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 indicates this is for WHOIS summary lookups but does not explicitly mention when to use it over other domain tools (e.g., DNS lookup, reputation). No guidance on when not to use or alternatives 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, so description carries full burden. Discloses output structure (grouped per ledger, matchedField, summary, detailUrl) and defines ledgerVerified integrity meaning. Lacks mention of rate limits or pagination but covers key behavioral aspects.

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 filler. First sentence sets scope and purpose, second explains output. Perfectly front-loaded 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?

Adequate for a simple search tool with 2 params and no output schema. Covers output grouping and ledgerVerified concept. Could expand on matchedField and summary, but not critical.

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 description adds little beyond schema. Repeats 'partial match' and limit range. No additional semantic explanation.

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 searches company/person names across ALL listed ledgers, distinguishing it from per-ledger watch siblings. The verb 'search' and resource 'entity across all ledgers' is 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?

Implicitly provides context for cross-ledger search vs per-ledger watches, but does not explicitly state when to use or not use alternatives.

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