Language hu

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

There are no annotations to provide safety or side-effect context, so the description carries the burden. It mentions 'task text discarded' and that it returns connection methods, but it does not disclose whether the tool performs external calls, whether it is read-only, or whether it incurs costs, especially since 'pay-per-call' is mentioned ambiguously.

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

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

The description is brief and avoids unnecessary padding. The phrase 'task text discarded' is a useful disambiguator even though the overall purpose is somewhat unclear.

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 nine optional parameters, many sibling tools, and no output schema, the description is not complete enough for an agent to know what output to expect or how parameters should be combined. It also lacks details about the returned connection methods and any constraints on input.

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 parameter descriptions already provide basic meaning. The tool description adds little beyond that and does not explain how the various optional parameters influence the gateway search, leaving their role in the tool's operation unclear.

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 finds a public pay-per-call tool gateway and returns connection methods, so the core intent is somewhat clear. However, the tool name 'agent-tool-index' and the phrase 'task text discarded' introduce ambiguity about what the tool actually indexes and how it selects a gateway.

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

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

The description gives examples of tasks like weather, search, scrape, or voice, but does not explicitly state when to use this tool versus any of the many sibling tools. There is no clear guidance about which parameters should be provided or how the tool relates to the alternative utility 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?

The only disclosed behavior is that no browser is launched, which is a useful constraint. However, it does not mention whether network requests are made, whether the operation is read-only, what side effects occur, or what the return value looks like. Given the lack of annotations, this is insufficient transparency.

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

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

The description is extremely short—one sentence—which is concise but at the cost of necessary detail. It is front-loaded with the primary action, but it lacks essential context like what 'open' entails and how the numerous parameters factor in. The brevity is not effective because it omits critical 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?

The tool has 9 parameters, no output schema, and no annotations, yet the description gives almost no context about expected inputs, outputs, or behavior. An agent would not be able to invoke this tool correctly or interpret the result based solely on the description. It is severely incomplete for its 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 brief descriptions, but the descriptions are inconsistent with the tool's stated purpose. For example, 'city name' and 'IANA timezone name' have no clear connection to checking a URL. While each parameter is individually described, their collective role and how they affect the tool's behavior is not explained, making the semantics confusing.

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 says it checks whether a URL can be opened and that no browser is launched, but it is ambiguous what 'can be opened' means (syntactic validity, reachability, etc.). The parameter list, which includes city, feed, json, zone, etc., is unrelated to a simple URL check, creating confusion about the tool's actual purpose.

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

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

The description provides no guidance on when to use this tool over siblings such as normalize-url or fetch-status. It does not state any preconditions, alternatives, or scenarios where this tool is preferred, leaving the agent without direction.

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

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

Beyond noting that the expression is discarded, the description discloses nothing about the tool's actual behavior, side effects, return value, or error conditions. With no annotations to fill the gap, the description fails to provide any meaningful transparency.

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

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

The description is very brief, but it is not appropriately sized for the tool's complexity: it omits essential information about the 9 parameters and the overall purpose. It is front-loaded in the sense that the first sentence states the supposed action, but the second sentence adds confusion rather than clarity.

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 rich schema (9 optional parameters) and absence of an output schema, the description is grossly incomplete. It does not explain how any of the parameters relate to the tool's function, nor what the tool returns or how to interpret results.

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

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

All 9 parameters have generic, unrelated descriptions (e.g., Git ref, URL, city, feed) that have no apparent connection to arithmetic evaluation. The tool description mentions an 'expression' but no such parameter exists in the schema, so parameter semantics are entirely obscure and unhelpful.

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

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

The description states a verb ('Evaluate') and a resource ('a+b style arithmetic'), but it is highly ambiguous because the input schema contains no expression parameter, and the phrase 'Expression discarded' suggests the tool does not actually evaluate anything. This misalignment with the schema severely undermines clarity.

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 any of the 28 sibling tools. It only states that the expression is discarded, leaving the intended use case completely unexplained.

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

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

The description discloses that page content is not stored, which is a positive transparency note about data handling. However, it does not mention other behavioral aspects like network access, rate limits, or potential side effects. Since there are no annotations, this lack of detail leaves some uncertainty.

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

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

The description is extremely concise, consisting of two short sentences. It directly states the core functionality and a key caveat without any verbose or redundant information. This is an exemplary model of 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?

While the description states the output includes host, scheme, and HTTP status, it does not specify the format or structure of the output, nor does it mention error handling or which parameters are relevant. Given the complexity of the schema with many seemingly unnecessary parameters, the description leaves the tool's overall context partially unexplained.

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 includes 9 parameters with descriptions, but many appear to be decoys (e.g., 'Git ref name; discarded after the shape check', 'City name for a public weather hint'). The description does not clarify that only the 'url' parameter is actually used for the primary function, leaving the parameter semantics ambiguous and potentially misleading for an agent.

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

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

The description clearly states the tool's purpose: returning host, scheme, and HTTP status for a URL. It uses a specific verb and identifies the resource, but it does not explicitly differentiate itself from sibling tools like fetch-status or normalize-url, though the specific output makes it distinguishable.

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

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

The description provides a hint that page content is not stored, which implies the tool is for metadata-only checks, but it does not explicitly state when to use this tool versus alternatives such as web-fetch or status-catalog. The guidance is implicit rather than explicit.

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

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

The description and parameter notes disclose privacy behavior ('No identifiers are retained', values are 'discarded'), which is useful. However, with no annotations, it still omits side effects, return type, error behavior, and what the classification actually does.

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 and contains no redundant words. It is well-structured as short prose, though the brevity contributes to the lack of context.

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

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

There is no output schema, example, or explanation of classification categories, making it impossible to know what the tool returns or how to interpret results. The privacy note and parameter labels provide only fragmentary 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?

Each parameter has a one-line schema description, so individual fields are labeled clearly. Yet the descriptions are heterogeneous ('normalize or cite', 'weather hint', 'validate', 'length check') and do not explain how they relate to a unified classification or compatibility result.

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 'Show how this request is classified' does not state what classification means, what output is produced, or what 'compatibility' refers to. The only clue is the tool name, but no resource or domain object is identified.

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

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

No guidance is given about when to use this tool or how it differs from sibling tools. There is no mention of alternatives, prerequisites, or intended call patterns.

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

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

With no annotations, the description carries the full burden of explaining side effects and behavior. It does not mention error handling, whether the tool performs network calls, or that most of the listed parameters appear to be ignored. The 'without WHOIS or ownership data' note is a small transparency step but 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 that names the action and the key non-goal. It wastes no words and is easy 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?

Given the complex nine-parameter schema and no output schema, the description leaves out critical context. It does not specify the expected output format, which parameters are required or ignored, or how errors are reported. An agent cannot reliably call this tool based solely on the provided description.

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?

Although every parameter has a schema description, most are unrelated to splitting a hostname and some are actively confusing (e.g., weather hints, RSS feeds, timezone names). The tool description does not clarify that only 'host' matters or explain what happens when multiple parameters are supplied. Schema coverage is high, but the semantic value is low.

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

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

The description clearly states a specific operation: split a hostname into labels. It also distinguishes itself by explicitly saying it does not provide WHOIS or ownership data. However, the presence of nine unrelated optional parameters creates ambiguity about which input is actually the hostname.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. The phrase 'without WHOIS or ownership data' hints at what the tool does not do, but it does not name sibling tools or explain when domain-shape should be preferred.

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

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

The description reveals the request method (HEAD) and that only status is returned, but it omits any details about error handling, rate limits, or side effects. The schema's placeholder-like parameter descriptions (e.g., 'discarded after the shape check') hint at behaviors that are inconsistent with simple status fetching, reducing transparency.

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

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

The description is a single, concise sentence that is easy to read and front-loaded with the main action. However, it sacrifices necessary detail about parameters and usage, making it too terse for the complex schema.

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

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

The description provides no output schema, no example usage, no mention of error handling or edge cases, and leaves the relationship between the nine parameters and the stated purpose entirely unexplained. This incomplete context would leave an agent uncertain how to invoke the tool correctly.

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

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

Although every parameter has a description, the descriptions are generic and often nonsensical relative to the tool's purpose. For example, 'ref' is described as a 'Git ref name' and 'city' as a 'City name for a public weather hint', but the tool is supposed to check URL status. None of the parameters clearly indicate which one represents the URL to check.

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

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

The description states a specific action ('HEAD a public URL and return status only') but does not distinguish this tool from sibling URL-checking tools like browser-url-ok or web-fetch. The presence of many unrelated parameters in the schema further blurs which resource is actually being operated on.

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 about when to use this tool versus alternatives. There is no mention of scenarios where a HEAD request is preferred, nor any examples or conditions that would make this tool the right choice.

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

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

The description discloses that the path is discarded, but it does not mention side effects, network access, or whether the operation is read-only. Since no annotations are provided, the description carries the full burden, and it fails to state any behavioral traits other than input 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 extremely brief and front-loaded with the primary purpose, which is good for conciseness. However, it is so minimal that it omits essential details, though that is more a completeness issue than a structure issue.

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

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

Given the tool has nine parameters, no output schema, and many siblings, the description is severely incomplete. It does not mention expected output, parameter relationships, or any edge cases, leaving an agent without enough information 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 description does not explain how any of the nine parameters relate to the Figma URL parsing purpose. While the schema provides individual parameter descriptions, they appear disjointed (e.g., 'City name for a public weather hint') and the tool description adds no clarity on how they are used together.

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

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

The description states a clear action (parse) and a specific resource (Figma file URL), and even notes that the path is discarded. However, it does not explicitly distinguish this tool from sibling tools like normalize-url or browser-url-ok, nor does it explain what the parsing produces.

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

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

There is no guidance on when to use this tool versus any of the many sibling tools, nor any mention of conditions or alternatives. The description is purely a statement of function without usage 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?

The description discloses one important behavioral trait: 'No disk access' — indicating the check is static and non-destructive. However, it does not explain what 'safe' means, what the return value is, or how errors are reported, leaving some aspects implicit.

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, consisting of two short sentences that deliver the essential message without any redundancy. It is well-structured and easily parsed.

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 (9 parameters, no required fields, and no output schema), the description is far too brief. It does not explain what 'safe' means, what the return value is, or how to interpret the various parameters, leaving an agent without sufficient context to use the tool correctly.

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

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

The description only references 'path', but the input schema lists eight other parameters (ref, url, city, feed, host, json, zone, query) without any explanation of their role. The description fails to clarify which parameters are actually used and how they relate to the tool's purpose, making it largely unhelpful for understanding the parameter semantics.

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

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

The description clearly states the tool's purpose: checking whether a path looks safe, with an explicit note that no disk access occurs. This makes the core function unambiguous, though it does not explicitly differentiate from sibling tools that might also deal with path-like inputs.

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 browser-url-ok or normalize-url. There is no mention of conditions, use cases, or criteria for selecting this tool.

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

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

No annotations are provided, and the description does not disclose any side effects, error handling, or data persistence. The parameter descriptions (e.g., 'discarded after the call') are inconsistent with the tool's stated purpose, further reducing transparency.

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

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

The description is a single concise sentence, which is appropriate in length, but it lacks structure such as examples, parameter hints, or output expectations. It reads as a minimal stub rather than a well-formed specification.

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 nine parameters and no output schema, the description is severely incomplete. It does not state which input is required, how the place is identified, or what the output format will be, leaving the agent unable to invoke the tool reliably.

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 clarification on which of the nine parameters supplies the place name. The schema descriptions themselves are misleading (e.g., 'city' for a weather hint, 'query' for a length check), so the description fails to map parameters to functional inputs.

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

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

The description clearly states the tool returns latitude and longitude for a place, distinguishing it from siblings like weather-hint and timezone. However, it does not specify which parameter actually denotes the place, 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 offers no guidance on when to use this tool over alternatives (e.g., weather-hint, timezone) or any conditions for selection. No context about typical use cases 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 present, and the description does not clarify side effects, read-only behavior, error handling, or what happens with invalid inputs. The verb 'Parse' implies a read-only operation, but this is not made explicit.

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

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

The description is extremely brief and direct, with no redundant words. It front-loads the essential action and target, making it easy to scan.

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

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

Given the simple stated purpose, the description is too sparse. It lacks information about expected URL format, return shape, handling of non-GitHub URLs, and the role of the many extra parameters. The tool appears to have broader or templated behavior that is not communicated.

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?

Although each parameter has a schema description, many of them (city, feed, host, json, path, zone, query) appear unrelated to the stated purpose of parsing GitHub owner and repo. The description does not explain which parameters are used, ignored, or required for the core operation.

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

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

The description clearly states a specific action ('Parse') and the target resource ('owner and repo from a GitHub URL'). It is concise and understandable, though it does not explicitly distinguish it from other URL-parsing sibling tools.

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

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

There is no guidance on when to use this tool versus alternatives like normalizing URLs or checking URL shapes. Sibling tools with similar purposes exist, but no conditions or exclusions are provided.

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

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

No annotations are provided, and the description does not disclose side effects, network access, caching, error behavior, or return format. It also does not state whether the tool is read-only or what it returns beyond a count.

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

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

The description is brief and front-loaded with the main action, but the appended 'Titles discarded' is cryptic and does not clarify output or behavior. It adds ambiguity without earning its place.

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

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

With nine optional parameters and no output schema, the description leaves out how to invoke the tool, what it returns, and how it relates to sibling tools. The tool is incomplete for an agent to use 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?

All nine parameters have descriptions, but they appear unrelated to the purpose: ref, url, city, feed, host, json, path, zone, and query with generic descriptions like 'JSON text to validate' or 'IANA timezone name'. None of them are explained in the context of counting Hacker News stories, and all are optional, leaving parameter semantics effectively meaningless.

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

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

The description clearly identifies the tool's function: count current Hacker News front-page stories. It names a specific verb and resource, though the phrase 'Titles discarded' is ambiguous about what the tool actually returns.

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 sibling tools like web-fetch or fetch-status. It does not mention prerequisites, context, or alternatives.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose any behavior—whether the tool reads, writes, mutates, or returns data. The schema notes that some parameters are 'discarded' (e.g., ref, city, json), but the description itself omits all behavioral context, including side effects, return format, or restrictions.

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 in length, but it is under-specified rather than efficient. It omits essential details and does not earn its place because it fails to clarify the tool's function, making it unhelpful despite 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?

For a tool with nine parameters, no annotations, and no output schema, the description is grossly incomplete. It does not explain what the tool does, how to use the parameters, what to expect as output, or any side effects. An agent has no basis for correct invocation.

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

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

The schema descriptions for each parameter are detailed (e.g., 'HTTPS URL to normalize or cite'), so the schema itself provides 100% coverage. However, the tool description adds no value in relating these parameters to the tool's stated purpose, and the mix of parameters (url, city, feed, etc.) conflicts with the timezone theme, making it hard for an agent to understand how to compose 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 'Common IANA timezone names for clock calls' hints at a timezone-related tool but does not state an explicit action (e.g., list, validate, resolve). The schema contains nine unrelated parameters (url, city, feed, host, json, path, query) that do not align with timezone names, making the purpose ambiguous and not distinguishable from siblings like timezone or utc-time.

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

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

There is no guidance on when to use this tool versus alternatives such as timezone or utc-time. No use cases, prerequisites, or exclusions are provided, leaving the agent without direction on 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?

No annotations are present, and the description fails to disclose that the tool likely makes an external network request or whether it is read-only. It does not mention potential side effects or failure modes.

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

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

The description is a single, concise sentence with no redundant wording. It is front-loaded with the core action and output.

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 nine optional parameters and no output schema, the description leaves the agent without essential context. It does not specify which parameter provides the target (e.g., host vs. url), what the return format is, or any constraints, making correct invocation nearly impossible.

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 descriptions are actively misleading—they reference unrelated concepts (e.g., city weather hints, git refs, JSON validation) that have nothing to do with robots.txt. The relevant parameters like url or host have vague or incorrect descriptions, adding confusion rather than clarity.

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 public robots.txt and returns group counts only, using a specific verb and resource. The word 'only' distinguishes it from broader fetching or inspection tools.

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

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

The description provides no guidance on when to use this tool compared to siblings like fetch-status or web-fetch. It does not mention alternative tools or conditions 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?

It discloses that the key is discarded, which is a useful privacy/retention signal, but it does not state whether the tool is read-only, makes network calls, returns a boolean or error, or has any other side effects. With no annotations, most behavior is left implicit.

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 text is short and front-loaded, with no filler words. However, it is too terse to convey essential invocation details, so the conciseness is not well balanced with 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?

The tool has a 9-parameter schema and no output schema or annotations, but the description provides no information about valid key format, return value, error behavior, or parameter selection. It is far from enough for an agent to correctly use this tool.

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

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

The schema has nine optional string parameters with descriptions that appear copy-pasted from unrelated tools (e.g., city for weather, zone for timezone, feed for RSS); none of them obviously represents a Jira issue key. The descriptions do not clarify which parameter should be checked, and several ('HTTPS URL to normalize or cite', 'JSON text to validate') are actively misleading for a Jira-key-shape validator.

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 says 'Check a Jira issue key shape' but does not define what shape is valid or which input parameter carries the key; the schema lists unrelated parameters, so an agent cannot tell how to invoke the intended purpose. It is more specific than a generic verb, but the missing mapping makes the purpose unclear.

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

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

No usage guidance is provided: it never says when to prefer this over sibling tools like domain-shape, github-repo-shape, or normalize-url, nor what input to supply or what output to expect.

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, but it says nothing about side effects, read-only behavior, or outcomes. It does not disclose whether the tool performs mutations or just returns 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 terse, consisting of a single fragment. While it is concise in word count, it lacks a proper structure (no verb, no object) and is too short to convey any useful information.

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

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

Given the tool's 9 parameters and lack of output schema, the description is grossly incomplete. It does not explain the tool's purpose or expected behavior, leaving an agent with no idea how to invoke or interpret the result.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds no additional meaning to the parameters, but the schema already provides individual descriptions for each field.

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 is a noun phrase ('ISO 639 language tag hu.') with no verb or action. It fails to state what the tool actually does (e.g., validate, look up, or return information about the 'hu' tag).

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 or how it differs from siblings. There is no mention of scenarios, alternatives, 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?

The phrase 'Body discarded' is a useful behavioral detail, but the description does not mention side effects (e.g., making a network request), error behavior, or the fact that most input parameters are ignored. No annotations exist to fill this 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 very short and free of extraneous content, making it easy to parse. It could be more informative, but it is appropriately concise.

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 nine optional parameters, no output schema, and many sibling tools, the description is too sparse to fully instruct an agent. It doesn't explain which parameters are ignored, what the response looks like, or how this tool differs from similar URL-checking tools.

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

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

The tool description never identifies which of the nine parameters is the URL to check, and the schema's parameter descriptions conflict with the tool purpose (e.g., url is described as 'normalize or cite' rather than check status). Many parameters are unrelated or described as discarded, leaving the agent unable to determine correct input.

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 indicates the tool returns an HTTP status code and discards the response body, scoped to a public library docs URL. However, it lacks an explicit verb like 'returns' or 'checks', which slightly reduces clarity.

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 about when to choose this tool over sibling tools such as fetch-status, web-fetch, or browser-url-ok. The 'Body discarded' phrase implies body is not needed, but it never names alternatives or conditions.

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 transparency burden. It mentions that values are discarded and some parameter descriptions note 'discarded' or 'no disk access', but it does not disclose return behavior, errors, or whether any state is modified.

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 and front-loaded, with no unnecessary wording. The parameter descriptions are also short and direct, keeping the overall definition compact.

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 nine optional parameters and no output schema or annotations, the description is not fully complete. It lacks explicit instructions on which parameter to provide and what the result will look 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?

Although every parameter has a description, the descriptions are misaligned with the tool purpose (e.g., 'json' is described as 'JSON text to validate; discarded after the check' rather than as the object whose keys are counted). With nine optional parameters and no required fields, the input mapping is ambiguous.

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: count keys in a JSON object and ignore values. It is specific enough to distinguish from sibling tools like validate-json, though it does not explicitly name which parameter carries the JSON object.

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

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

There is no guidance about when to use this tool compared with alternatives such as validate-json or search-query-len. The intended use is only implied by the one-sentence description.

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

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

The description discloses that query and fragment are dropped, which is a behavioral detail. However, it does not mention error handling, valid input requirements (e.g., HTTPS enforcement from schema), or side effects. It lacks transparency about edge cases, invalid URLs, or any prerequisites. With no annotations provided, the description carries the full burden but falls short.

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, consisting of two short sentences with no redundant wording. It efficiently communicates the core functionality without unnecessary 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 the complexity of 9 parameters and the absence of an output schema, the description is incomplete. It does not explain the output format (e.g., string, object), how to specify the URL among the many parameters, or what happens to the unused parameters. The description leaves significant gaps for an agent to correctly invoke the 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?

The schema has 9 parameters, but the description only refers to 'URL', 'query', and 'fragment' vaguely. It does not clarify that the 'url' parameter is the primary input or that other parameters (ref, city, feed, etc.) are likely irrelevant. The schema's own descriptions are decent for individual parameters, but the tool description adds no additional clarity about which parameters are actually used and how they map to the URL normalization task.

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 action: 'Return origin, host, and path for a URL. Query and fragment are dropped.' This is specific and identifies the resource (URL components) and the verb (return). However, it does not explicitly distinguish it from sibling tools like browser-url-ok or figma-url-shape, though the focus on URL parsing is evident.

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

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

No guidance is provided on when to use this tool versus alternatives. The description simply states what it does without indicating conditions, use cases, or scenarios where it is preferable over other URL-related tools. There is no mention of 'use this when' or 'instead of'.

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

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

The description discloses that no browser is launched, but it does not explain what network requests are made, whether the URL is fetched, what side effects occur, or what the return value means. Many parameters are described as 'discarded', which is unusual and not fully explained.

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 uses only two sentences, making it highly concise. It avoids unnecessary detail.

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

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

The description does not explain the role of the nine parameters, the expected output, or the tool's relationship to sibling tools. Given the large parameter set and no output schema, the context is severely 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 schema has 100% parameter descriptions, but they are mismatched with the tool's purpose (e.g., 'url' is described as 'normalize or cite', and unrelated parameters like 'ref', 'city', 'zone' are included). This adds confusion rather than clarity and fails to explain how each parameter relates to checking a URL.

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

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

Description states a clear action ('check whether a URL can be opened') but does not distinguish this from sibling tools like 'browser-url-ok' or 'fetch-status' beyond a brief note about not launching a browser. The meaning of 'can be opened' is ambiguous.

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

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

No guidance is provided about when to use this tool instead of alternatives. The description lacks any conditions, contexts, or comparisons to sibling tools.

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

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

The phrase 'Query discarded' discloses that the input is not persisted, but the description omits other behavioral aspects such as read-only nature, network access, or side effects. The schema descriptions also suggest discarding for other parameters, but the tool description only addresses the query.

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 directly conveys the tool's purpose without unnecessary detail.

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

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

The description lacks essential context about the tool's behavior with the extra schema parameters, the expected output format, or error conditions. Without an output schema, the user is left guessing what the tool returns (e.g., just a number?). This incompleteness is amplified by the mismatch between the narrow description and the broad parameter list.

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 only mentions the 'query' parameter, while the schema includes eight additional parameters (ref, url, city, feed, host, json, path, zone) with generic descriptions like 'discarded after the shape check.' The description does not clarify how these relate to the tool's purpose or whether they are ignored, leaving their meaning ambiguous.

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: 'Count characters in a search query.' It specifies a precise action (count) and a resource (search query), distinguishing it from sibling tools that handle URLs, timezones, or validation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention scenarios, prerequisites, or contrast with sibling tools like 'normalize-url' or 'validate-json'.

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

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

The description does not disclose any behavior beyond the apparent read-only catalog function. No annotations are provided, so the description carries the full burden. It does not mention whether the tool performs any checks, validations, or has side effects, leaving the agent to infer safety.

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 brief for a tool with 9 optional parameters. While concise, it omits essential information about the parameters' roles. The one-sentence description is insufficient for an agent to understand how to invoke the tool meaningfully.

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 (9 parameters, no output schema), the description is incomplete. It does not explain what the tool does with the input parameters, whether they are filters, modifiers, or irrelevant, nor does it provide any usage context. The agent is left with a catalog description but no clue how to use the provided parameters.

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

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

The tool description does not explain how any of the 9 parameters relate to HTTP status codes. The schema descriptions are present but appear nonsensical for this purpose (e.g., 'Git ref name; discarded after the shape check' or 'City name for a public weather hint'). These descriptions actively mislead rather than clarify, making the parameters effectively meaningless in context.

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: it provides a short catalog of common HTTP status codes. This is specific and distinguishes it from sibling tools like fetch-status, which likely checks individual URLs.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention scenarios where a status code catalog is needed, nor does it compare with fetch-status or other related tools from the sibling list.

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 side effects, side effects, or discard behavior clearly. The phrase 'Prompt discarded' is ambiguous, and parameter descriptions like 'discarded after the shape check' suggest the inputs may be ignored, but this is not explained.

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, which is concise, but it is not front-loaded with useful information. It consists of a single misleading sentence and the parameter descriptions are repetitive and unhelpful, so the brevity does not contribute to clarity.

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

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

The tool has no output schema, no required parameters, and no explanation of how inputs affect the output. An agent cannot determine what the tool returns, what inputs are needed, or what 'three-step thinking template' means in this context.

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

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

Although every parameter has a schema description, those descriptions are semantically disconnected from the tool's stated purpose. For example, 'Git ref name; discarded after the shape check' gives no indication of how it relates to returning a thinking template. The descriptions do not help an agent decide what values to provide.

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 'Return a three-step thinking template' is vague and does not clarify what the tool actually does. The parameter names (ref, url, city, feed, host, json, path, zone, query) are unrelated to 'thinking template', so an agent cannot infer the tool's purpose.

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

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

No guidance is given on when to use this tool, what problem it solves, or how it differs from sibling tools like calc-eval or validate-json. The description does not mention any alternatives or conditions for 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?

The description does not disclose side effects, return format, or whether the tool is read-only. No annotations are provided to fill this gap, so an agent cannot infer the behavior beyond 'get current time'.

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 and therefore concise, but it is not well structured: it ignores the large parameter list entirely, omitting any mapping between the tool's purpose and its inputs. The brevity sacrifices necessary clarity.

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 is far from complete given the tool's complexity. It does not clarify which of the nine parameters is actually relevant, what the output looks like, or how the tool behaves in edge cases (e.g., invalid timezone names).

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 does not explain any parameters. Although the schema includes a 'zone' parameter with a sensible description, the other eight parameters (e.g., 'ref', 'url', 'city', 'feed', 'host', 'json', 'path', 'query') have descriptions that are irrelevant to timezone lookup, leaving an agent without clear guidance on which parameter to provide.

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 returns the current time in a named IANA timezone, which is a clear purpose. However, the accompanying schema lists nine unrelated parameters (e.g., 'ref', 'url', 'feed', 'host', 'json', 'path', 'query') with descriptions that do not align with the stated function, undermining an agent's ability to understand what the tool actually does.

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 'utc-time' or 'iana-zones'. It does not mention any conditions, limitations, 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 are provided, so the description carries the full burden of behavioral disclosure, which it does not meet. It does not mention that the parameters appear to be ignored, whether the call has any side effects, or what the exact output format is. The behavior is only trivially described as returning the current UTC timestamp, with no detail on edge cases or error conditions.

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

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

The description is a single, short sentence and is front-loaded with the purpose. However, for a tool with nine parameters, this level of brevity is under-specified rather than appropriately concise. It is not bloated, but it skips essential structural information that an agent needs.

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?

There is no output schema, no annotations, and the description provides no context about how the parameters relate to the tool, what values are valid, or what the return shape looks like. The disconnected parameter list and minimal prose leave an agent without enough context to call this tool correctly or confidently. The description is far from complete even for a simple timestamp utility.

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?

Although the schema covers 100% of parameters, every parameter description is clearly copy-pasted from unrelated tools (e.g., 'Git ref name', 'City name for a public weather hint', 'Search text; discarded after the length check'). These descriptions are misleading for a UTC-time tool and actively harm an agent's understanding rather than adding meaning. The parameter semantics are not just unhelpful—they are contradictory to the tool's apparent purpose.

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 'Current UTC timestamp.' clearly states the tool's function and distinguishes it from the sibling 'timezone' tool. However, it is minimal and does not address the nine unrelated-looking parameters, leaving the purpose somewhat muddled for an agent that reads the full schema. The core verb and resource are clear, but the surrounding context undermines full clarity.

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 about when to use this tool versus alternatives such as 'timezone' or when not to use it. There is no mention of prerequisites, expected inputs, or any scenario in which the tool is appropriate. The description offers zero usage direction.

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 mentions 'The body is discarded,' which indicates a side-effect-free operation for the JSON input. However, it does not disclose whether other parameters (e.g., url, path) have side effects or are ignored, nor does it mention permissions or rate limits. The description is minimal and leaves much behavioral uncertainty.

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

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

The description is a single, efficient sentence with a clear subject and verb, front-loaded with the core purpose. The second sentence adds a relevant behavioral note. No filler or redundancy.

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

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

For a tool with 9 optional parameters and no output schema, the description is insufficiently complete. It does not explain why many unrelated parameters exist, what the return value is, or whether the tool performs any network/disk access. An agent cannot confidently call this tool correctly without additional context from the schema, which is not enough for selection.

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 detailed descriptions for each parameter. The description adds no parameter-specific information beyond the schema. Per calibration, baseline 3 applies when schema covers all parameters, and the description does not compensate or enrich beyond that.

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

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

The description states a clear verb and resource: 'Check whether a body is valid JSON.' It identifies the tool's purpose without being a tautology. However, it does not explicitly differentiate from sibling validation tools like browser-url-ok or file-path-ok, though the JSON focus is a distinguishing trait.

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. It only implies usage for JSON validation. No exclusions, prerequisites, or alternative routing are mentioned, leaving the agent to infer selection from the resource type.

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 carry all behavioral detail, but it only states the outcome. It does not disclose return format, units, error behavior, or side effects, leaving the agent to guess what the tool actually emits.

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, focused sentence with no redundant words. It is well-structured and easy 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?

The tool has nine optional parameters and no output schema, but the description does not explain which parameters are meaningful, how to construct a valid request, or what response to expect. An agent cannot reliably invoke this tool based solely on the provided information.

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?

Although every parameter has a description, most are unrelated to weather (e.g., 'ref', 'url', 'feed', 'json') and appear to be generic filler. The 'city' parameter is relevant, but its description says 'discarded after the call,' which adds confusion rather than clarity about how the parameter is used.

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: retrieving current temperature for a city via Open-Meteo. It identifies the key resource and service, though it does not explicitly name sibling alternatives or scope conditions.

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

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

No guidance is provided about when to use this tool instead of related tools like web-fetch or geo-hint. The description implies a weather use case but does not specify appropriate conditions or contraindications.

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

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

The description discloses one behavioral trait: the body is discarded. However, it does not mention network side effects, potential errors, rate limits, or authentication requirements. With no annotations, more behavioral detail would be expected.

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 and well-structured, consisting of two short sentences that immediately convey the core functionality. No unnecessary words or redundancy.

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

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

The description covers the basic purpose but omits details about output format, error handling, or the fact that many schema parameters appear irrelevant. The missing output schema makes it harder to know what exact response to expect.

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 contains 9 parameters, but only 'url' aligns with the stated purpose. The other parameters (e.g., 'city', 'zone', 'json') have descriptions that suggest unrelated functionalities, and several are noted as 'discarded after the shape check'. This creates significant confusion about which parameters are actually used and how.

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: returning HTTP status and content type for a public URL. It names the specific verb/resource combination and distinguishes it from generic fetch tools.

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

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

No guidance is provided on when to use this tool versus the many sibling tools with overlapping purposes (e.g., fetch-status, browser-url-ok, normalize-url). The description does not mention alternatives or conditions 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 must carry the burden of disclosing side effects. 'Title discarded after the call' hints at no persistence, but it does not explicitly state that the tool is read-only, nor does it mention any side effects beyond discarding. The description is too minimal to provide meaningful transparency.

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

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

The description is brief and to the point, but it omits essential information such as which parameter is the title and what the return value indicates. Brevity alone does not make it concise; it is under-specified and lacks a clear structure to guide usage.

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 apparent purpose (checking Wikipedia title existence), the description fails to explain how to provide the title, what constitutes a valid request, or what the output means (e.g., boolean, error codes). The mismatched schema and lack of output documentation make the tool nearly unusable without additional context.

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

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

The parameter schema descriptions are misleading and disconnected from the tool's purpose. For example, 'ref' is described as a 'Git ref name' and 'city' as a 'City name for a public weather hint', which have no relation to checking a Wikipedia title. The descriptions actively confuse rather than clarify, providing negative 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 states a clear verb-object pair ('Check whether a Wikipedia title exists'), but it fails to identify which of the 9 parameters corresponds to the title. The parameter schema includes unrelated fields like 'ref', 'url', 'city', and 'query', making the purpose ambiguous and difficult to act on.

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 the many sibling tools (e.g., search-query-len, normalize-url, validate-json). The description does not mention any context, prerequisites, or alternative tools, leaving the agent without decision support.

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