America/Santarem clock

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

Annotations are absent, so the description carries the full burden. It discloses that 'Task text discarded' and lists the outputs, but it does not clarify whether the tool is read-only, has side effects, or requires auth. The schema shows many parameters are discarded, which is only hinted at by 'Task text discarded.' It adds some behavioral context but not enough 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 a single sentence that front-loads the purpose and includes return content. There is no wasted text, and it is efficiently structured. It could be slightly more structured (e.g., listing returns with commas), but it remains concise and readable.

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 vague on how inputs affect the output. With 9 optional parameters and no output schema, an agent cannot determine what to provide or whether any parameter is required. It says 'Task text discarded' but does not explain if any parameter is needed for the 'find' operation. Missing information on invocation makes the tool difficult 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?

Schema description coverage is 100%, so each parameter already has a clear description. The tool description adds no extra parameter meaning beyond the schema; it doesn't indicate which parameters are used or how they affect the result. Baseline 3 is appropriate because the schema covers the parameters, though the description could have clarified that most are discarded.

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

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

States a specific action ('Find') and a specific resource ('a public pay-per-call tool gateway (Monid)'), and lists the return content (CLI setup, how-it-works, skill file, remote MCP hops). It is distinct from the sibling tools, which are mostly URL/shape/format validators; this one targets a specific service discovery. The name 'Monid' is niche, but the purpose is clear enough.

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 explicit guidance on when to use this tool vs. the many siblings. It does not mention alternatives, exclusions, or the condition that should trigger this tool. The sibling list includes many shape-check tools, and this one is clearly different, but the description does not state 'use when you need Monid' or similar.

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 only says 'No browser is launched,' which clarifies what it doesn't do, but fails to disclose what it actually does—does it perform a network request, validate syntax, or something else? The presence of unrelated parameters (city, json, path) suggests multiple behaviors that are entirely unexplained, effectively contradicting the URL-only framing.

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 (two sentences), but this is under-specification, not effective concision. It omits critical context about parameters, behavior, and usage. The 'No browser is launched' clarification is helpful but insufficient to compensate for the lack of essential information.

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

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

With 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain what the tool returns, how parameters interact, or when to use it. An agent cannot confidently invoke this tool correctly based on the description 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 descriptions are 100% covered, so the baseline is 3, but the tool description adds no linkage between parameters and the stated purpose. It does not explain why a 'city' or 'json' parameter is relevant to checking a URL, leaving the agent confused about how to select or interpret parameters. This lowers the score below baseline.

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

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

The description states a verb and resource ('Check whether a URL can be opened') but leaves 'opened' ambiguous—does it mean HTTP status, reachability, or format? It does not differentiate from siblings like fetch-status or normalize-url. The tool name and many unrelated parameters (city, json, path, zone) suggest a broader purpose, making the stated purpose misleading.

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. the many URL-related siblings (fetch-status, web-fetch, normalize-url, etc.). No mention of prerequisites, exclusions, or conditions that would select this tool over others.

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 behavioral note is 'Expression discarded', which is vague and contradicts the arithmetic claim. With no annotations provided, the description carries the full burden but reveals nothing about side effects, permissions, or outcome. It neither confirms nor denies any 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 (two sentences) but is under-specified rather than concise. It omits essential information and fails to front-load any useful guidance. The brevity does not add 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 tool with nine parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain the purpose of the parameters, the expected input format, the return value, or any side effects. An agent cannot safely or correctly invoke this tool based on the given definition.

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 schema coverage is 100%, each parameter description merely states it is 'discarded' or checked and discarded, with no connection to the purported arithmetic operation. The tool description adds no meaning beyond the schema and fails to explain what any parameter does in the context of arithmetic evaluation.

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 claims to 'Evaluate a+b style arithmetic', but the input schema contains nine unrelated parameters (ref, url, city, feed, host, json, path, zone, query) with no expression field. This is misleading and fails to state what the tool actually does or how it relates to its parameters.

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 any of the 27 siblings. There is no mention of context, alternatives, or exclusions, leaving the agent without any basis 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?

No annotations exist, so the description carries the full burden. It discloses one behavioral trait: 'Page content is not stored,' which is useful privacy context. However, it does not state whether the tool performs a network request, how it handles invalid URLs, whether redirects are followed, or what error responses look like. The disclosure is partial.

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 primary action and includes a privacy note. Every word is necessary; no filler or redundancy. It is as concise as possible while conveying the core 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?

For a tool with 9 optional parameters, no output schema, and no annotations, the description is far too brief. It does not explain how the parameters relate (e.g., precedence, mutual exclusivity), what the return format is (JSON? fields?), or why unrelated parameters like 'city' or 'ref' exist. An agent cannot confidently construct a correct call beyond guessing the 'url' parameter.

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 says 'for a URL' but does not specify which of the 9 optional parameters is the primary URL input. It adds no meaning beyond the schema for any parameter. While the schema itself has descriptions, the tool description fails to guide which parameter to use, making the semantics ambiguous 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?

States a specific verb and resource: 'Return host, scheme, and HTTP status for a URL.' This is unambiguous and distinguishes it from siblings like normalize-url (which likely only normalizes) or fetch-status (which may return full page status). The addition of 'Page content is not stored' reinforces the scope.

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

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

No guidance on when to use this tool versus alternatives. There are many related siblings (fetch-status, normalize-url, browser-url-ok), but the description does not mention any of them or provide conditions for choosing this tool. An agent cannot infer when to prefer 'citation' over a sibling.

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 only mentions that identifiers are not retained, but does not state whether the tool is read-only, whether it performs external calls, or what side effects it might have. This is insufficient for an agent to understand the tool's operational 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 brief, but this brevity is under-specification rather than efficient conciseness. It lacks essential details and does not structure information effectively, so it fails to earn its place as a useful description.

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

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

The tool accepts nine optional parameters of widely different types, yet the description gives no indication of how they are used, what the tool returns, or how to invoke it correctly. Without an output schema and with such complexity, the description is grossly incomplete and leaves an agent unable 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?

Schema description coverage is 100%, so the schema already documents each parameter, including notes about discarding and no disk access. The tool description adds no additional parameter semantics, so it relies entirely on the schema. Baseline 3 is appropriate.

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

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

The description states a generic action ('show how this request is classified') but fails to specify what kind of classification, what inputs it accepts, or how it differs from the many sibling tools. It is vague and does not convey the tool's specific role, making it hard for an agent to know when to select it.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of conditions, alternatives, or use cases, so an agent has no basis to choose it over the 26 sibling tools.

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

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

Annotations are absent, so the description must disclose behavior. It only states 'without WHOIS or ownership data' and the core action, but says nothing about side effects, permissions, error cases, or what 'shape check' means for the varied parameters. The schema hints at discarding some inputs, but the description doesn't clarify.

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 it under-specifies the tool's full capability. Important context (multi-parameter nature, return behavior) is absent, and the sentence doesn't front-load any operational guidance.

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 9 parameters, no output schema, and no annotations, the description is severely incomplete. It covers only a narrow interpretation (splitting hostnames) while ignoring most of the tool's apparent surface area, leaving the agent unable to correctly invoke it for non-hostname 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?

Schema coverage is 100% with per-parameter descriptions, so the baseline is 3. However, the description fails to explain how most parameters (city, feed, json, zone, query) relate to splitting a hostname, making their semantics confusing. The description adds no extra meaning and even conflicts with the schema's breadth.

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 'Split a hostname into labels', which is a specific verb and resource, but the input schema lists 9 unrelated parameters (ref, url, city, feed, json, path, zone, query) that do not all relate to splitting a hostname. This mismatch makes the actual purpose unclear and fails to distinguish it from sibling shape tools like figma-url-shape or jira-key-shape.

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 guidance on when to use this tool versus alternatives. With many sibling shape-check tools (e.g., github-repo-shape, jira-key-shape), the lack of any selection criteria or exclusion conditions leaves the agent guessing.

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 it performs a HEAD request and returns only status, but it does not clarify how the nine input parameters are used—many are described as 'discarded' in the schema, yet the description implies only a URL is needed. This creates confusion about the tool's actual behavior and 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, extremely concise and front-loaded. It lacks structured detail but is not bloated. Conciseness is high, though structure is minimal.

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

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

This is a 9-parameter tool with no output schema and no annotations. The description only covers a narrow subset (URL status) and completely ignores the other parameters, their purpose, and the expected return format. It is inadequate for an agent to call correctly.

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

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

Schema description coverage is 100%, so each parameter is individually documented. The tool description adds no additional meaning beyond the schema and does not explain the relationship between parameters. Baseline 3 is appropriate because the schema carries the load.

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) on a resource (public URL) and the result (status only), which is clear. However, it does not differentiate from siblings like browser-url-ok or normalize-url, leaving some ambiguity about when this specific tool is preferred.

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. It does not mention scenarios where status-only checking is appropriate, nor does it exclude other tools. The agent must infer usage from the name and 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions that the path is discarded, which is a minor detail about the input, not about the tool's own behavior. It does not state whether the tool is read-only, performs network calls, has side effects, or what the return value looks like. For a tool with no annotations, this is insufficient.

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

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

The description is very short (one sentence), which is concise, but it is under-specified rather than appropriately sized. It front-loads the purpose but omits essential information like which parameter to use, what output to expect, and any behavioral constraints. The brevity here works against usefulness.

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 parameters, no required fields, and no output schema, this description is far from complete. It does not explain the primary input, the expected output format, or the tool's role among its siblings. The presence of many unrelated parameters without clarification makes it impossible for an agent to correctly invoke the tool for its stated purpose.

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% coverage with descriptions for all 9 parameters, but the tool description does not connect the stated purpose to any specific parameter. It says 'Parse a Figma file URL' without indicating that the 'url' parameter is the relevant one. Many parameters (city, feed, json, zone, etc.) appear unrelated to Figma URL parsing, creating confusion. The description adds no meaning beyond the schema's basic property descriptions and fails to compensate for the mismatch.

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

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

The description states a specific verb and resource: 'Parse a Figma file URL.' However, it does not clarify what 'parse' entails (validation, extraction, normalization) or how it differs from siblings like normalize-url or web-fetch. The phrase 'Path discarded' adds a detail but is ambiguous—does it mean the tool ignores the path when parsing, or that it discards the path from the output? This leaves the core purpose under-specified.

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. No mention of context, conditions, or exclusions. The description is a single imperative with no comparative or situational information, so an agent cannot decide between this and related URL tools.

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

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

Annotations are absent, so the description carries full responsibility for behavioral disclosure. It only states 'No disk access' for the path check, but does not explain behavior for other parameters (e.g., whether URLs are validated, whether network calls occur, or what 'discarded' means). This is severely under-disclosed for a tool with 9 parameters.

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

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

The description is a single short sentence, but it is under-specified rather than concisely informative. It omits critical information about the tool's full capabilities, making it ineffective. A concise description should pack essential details; this one leaves too much unsaid.

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

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

With 9 parameters, no output schema, and no annotations, the description is drastically incomplete. It does not explain the return value, how parameters interact, or which fields are validated. An agent cannot reliably determine how to invoke this tool correctly, especially given the unrelated 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?

Schema description coverage is 100%, giving a baseline of 3, but the description adds no extra meaning beyond the schema. It mentions only 'path' and ignores the other 8 parameters, which are each documented in the schema but not synthesized in the description. This omission could lead an agent to think only 'path' matters, undermining semantic understanding.

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

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

The description states a specific action for 'path' ('Check whether a path looks safe'), but the schema lists 8 other parameters unrelated to paths. This creates ambiguity about the tool's actual scope and fails to differentiate it from siblings like browser-url-ok or domain-shape, which are also shape-checking tools. The purpose is only partially clear and potentially misleading.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of preferred scenarios, exclusions, or conditions that would route an agent to this tool instead of a sibling like wiki-title-ok or validate-json. The description offers no usage context whatsoever.

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 mentions 'via Open-Meteo', implying an external API call, but does not disclose rate limits, error handling, network requirements, or what happens if the place is not found. It also does not explain why many parameters are 'discarded after the call', which is behaviorally puzzling. Minimal disclosure beyond the bare function.

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 structurally efficient. However, it is too terse to be useful, omitting essential guidance on parameter usage and output. It is not overly verbose, but under-specification is not the same as conciseness; a 3 reflects the brevity balanced against the lack of necessary detail.

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

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

Given the complexity of nine optional parameters with no required fields and no output schema, the description is severely incomplete. It does not explain which parameter identifies the place, what the output format looks like, or provide any examples. 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?

Schema description coverage is 100%, but the parameter descriptions are largely unrelated to geocoding (e.g., Git ref, URL, JSON text). The tool description does not clarify how any parameter maps to a 'place'. Since the schema descriptions are not helpful for the intended purpose, the description should compensate but does not, leaving the agent unsure which parameter to use.

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 core function clearly: 'Latitude and longitude for a place via Open-Meteo.' This gives a specific verb and resource, but it fails to specify how the place is identified among the nine parameters. The purpose is understandable at a high level, but the mismatch between the description and the parameter schema creates ambiguity, preventing a higher 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?

There is no guidance on when to use this tool versus the many sibling tools (weather-hint, timezone, normalize-url, etc.). No context is given about typical use cases, prerequisites, or exclusions. The description provides no hint about which parameter to supply or what distinguishes geo-hint from 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the parse action but does not reveal what happens with invalid URLs, whether the tool returns an error or a success object, or why the schema includes many unrelated parameters like city and feed that appear to be discarded. The schema mentions discarding for some parameters, but that is schema-level, not description-level, and the description adds no behavioral nuance.

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 filler. It is appropriately concise and front-loaded with the core action. However, it is so brief that it borders on under-specification for a tool with a complex schema, but strictly for conciseness it is efficient.

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

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

Given the tool's name and sibling context, the description is incomplete. It does not explain the presence of nine parameters when only 'url' seems relevant, nor does it describe the return value or error behavior. The mismatch between the GitHub-specific description and the generic schema creates confusion that is not resolved by the description. An agent cannot reliably determine what parameters to supply or what to expect as output.

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 description adds no extra parameter meaning beyond the schema; it only references the 'url' parameter implicitly. Since every parameter is already documented in the schema, the description does not need to compensate, and it does not add any value 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 'Parse owner and repo from a GitHub URL' uses a specific verb and resource, clearly indicating the tool extracts the repository owner and name from a GitHub link. It is unambiguous, but it does not explicitly differentiate itself from sibling shape tools like figma-url-shape or jira-key-shape, relying on the GitHub-specific mention to imply its niche. Thus it earns a 4 rather than a 5.

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

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

No guidance is given about when to use this tool versus alternatives. The description only states what it does, not when it should be preferred over, say, a generic URL normalizer or other shape checkers. There is no mention of exclusions, prerequisites, or fallback conditions, leaving the agent to infer usage context 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 are provided, so the description must carry the full behavioral burden. It only says it counts and discards titles, omitting whether it makes network calls, what the output looks like, or how the parameters affect 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 short and front-loaded with the main action, but it lacks any structure to convey the relationship between the many parameters and the counting task. It is concise but not adequately informative for a 9-parameter 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 tool's complexity (9 parameters, no output schema, no annotations), the one-sentence description is grossly inadequate. It doesn't explain what the parameters do, what the return value is, or any prerequisites, leaving the 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?

Schema coverage is 100%, so each parameter has a description in the schema. The tool description adds no meaning about how parameters are used, but the baseline of 3 is appropriate given the schema already documents 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 states a clear action ('Count') and a specific resource ('current Hacker News front-page stories'), distinguishing it from generic fetch tools. However, it doesn't explain how the nine unrelated parameters relate to this purpose, and 'Titles discarded' 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?

There is no guidance on when to use this tool versus alternatives. It doesn't mention any conditions, exclusions, or which sibling tools might be more appropriate for related tasks.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It does not explain what the tool does with the nine parameters, whether it has side effects, what it returns, or any operational constraints. The schema mentions some parameters are 'discarded' after checks, but the overall behavior remains opaque.

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), but this is under-specification rather than conciseness. It omits essential information about functionality, return values, and usage context. A well-structured description would front-load the purpose and include necessary behavioral 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?

With nine parameters, no annotations, and no output schema, the description is entirely inadequate. It fails to explain what the tool does, what inputs are relevant, what outputs are produced, or how it relates to sibling tools. An agent would have no reliable basis to select or invoke this tool correctly.

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

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

Schema description coverage is 100%, meaning each parameter has a description. However, the descriptions are generic (e.g., 'Git ref name; discarded after the shape check') and do not connect to the tool's purported purpose of IANA timezone names. The tool description adds no meaning beyond the schema, 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 'Common IANA timezone names for clock calls' is essentially a restatement of the tool name 'iana-zones'. It lacks a specific verb or action (e.g., 'returns', 'validates', 'lists'), and the parameter schema contains unrelated inputs like 'url', 'ref', and 'json', which are not explained by the description. This makes the tool's actual purpose 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?

There is no guidance on when to use this tool versus alternatives. Sibling tools such as 'timezone' and 'utc-time' exist, but the description does not indicate what distinguishes this tool or in which scenarios it should be preferred. No exclusions, prerequisites, or contextual hints 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, so the description carries the full burden. It claims a single action (fetch robots.txt) but the schema suggests multiple different validation behaviors, with parameters like 'discarded after the shape check' implying the tool does more than fetch robots.txt. The description hides this discrepancy and gives no behavioral detail such as side effects, error handling, or return 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?

The description is a single sentence, which is concise, but it is under-specified and does not explain the parameters or the actual behavior. It is not a model of conciseness that effectively communicates the tool's function; it omits critical 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?

With 9 optional parameters, no output schema, and no annotations, the description is completely inadequate. It does not explain how the parameters relate to the stated action, what the tool actually returns, or any edge cases. An agent cannot reliably invoke this tool based 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?

Schema description coverage is 100%, but the descriptions themselves are terse and imply a different tool purpose (e.g., 'Git ref name; discarded after the shape check'). The tool description adds no parameter context and fails to reconcile these parameters with the stated robots.txt action. Since the schema is the only source and it contradicts the description, the added value is negative.

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 ('Fetch a public robots.txt and return group counts only'), but the schema parameters (ref, url, city, feed, host, json, path, zone, query) are unrelated to robots.txt and instead describe generic shape checks. The description does not match the actual function implied by the schema, making it misleading rather than 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. The description does not mention any selection criteria, alternatives, or exclusions. Given the mismatch between description and schema, an agent cannot determine 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 provided, the description carries the full burden of disclosing behavior. The only behavioral hint is 'Key discarded,' which suggests the input is not retained, but it does not state whether the operation is read-only, what happens to other parameters, whether it makes network calls, or what the response format is. The description is far too sparse to convey the tool's actual 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 only two short sentences, which is extremely concise, but it is under-specified rather than efficiently concise. While the purpose is front-loaded, the lack of necessary detail (which parameter, what 'shape' means, return value) makes the brevity counterproductive. It does not earn its place because it leaves critical information out.

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, no output schema, and no annotations, this description is wholly inadequate. It provides no information about the expected input, the nature of the check, the return value, or any side effects. An agent cannot call this tool correctly without further investigation. It fails to cover even the most basic contextual needs.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters. The description adds no parameter-specific meaning beyond the schema, and it fails to connect the purpose ('Jira issue key') to any specific parameter. Since coverage is high, baseline is 3; the description neither enhances nor contradicts the schema, but the missing linkage is a notable gap.

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

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

The description states a specific verb (check) and resource (Jira issue key shape), which is not a tautology. However, it does not specify which of the 9 parameters holds the key, nor does it clarify what 'shape' entails (e.g., format validation like ABC-123). It also does not distinguish this from sibling shape-check tools (domain-shape, github-repo-shape), leaving the agent uncertain about which tool fits.

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 alternative. The description does not mention context, prerequisites, or exclusions. An agent would have no idea whether to pick this over similar shape-check tools or when to avoid it.

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

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

The description mentions 'Body discarded,' which is a behavioral trait, but no annotations exist to carry the burden of disclosure. It does not mention rate limits, authentication, error behavior, or the fact that most parameters are discarded after checks, even though that information is embedded in the schema but not in the description. The description is too thin to be transparent.

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 it lacks structural depth. It front-loads the primary purpose but omits necessary context, making it efficient yet insufficiently informative.

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

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

With 9 optional parameters, no output schema, and no annotations, the description is woefully incomplete. It does not explain the tool's behavior with respect to the diverse parameters, when it should be used, or what the response format is. An agent cannot reliably invoke this tool correctly based on the description 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?

All 9 parameters have descriptions in the schema (100% coverage), so the schema provides meaning. The tool description adds no additional semantic value beyond what the schema already states, so the baseline score of 3 applies.

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

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

The description states a specific purpose: HTTP status for a public library docs URL, with body discarded. However, it does not clarify how the 9 unrelated parameters (city, feed, json, zone, query, etc.) fit this purpose, making the tool's actual scope ambiguous. It also does not differentiate itself from sibling tools like fetch-status or normalize-url.

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 fetch-status, normalize-url, or web-fetch. The description gives no context about prerequisites, selection criteria, or exclusions, leaving the agent to guess.

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 only mentions 'Values discarded,' which hints at a non-mutating operation but says nothing about side effects, permissions, return format, or failure modes. For a tool with no annotation safety net, this is severely 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 concise sentence with no filler, which earns credit. However, it is under-specified to the point of being unhelpful; it does not front-load the critical information about which parameter to use or what the output is, making it more under-specification than effective conciseness.

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

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

Given the tool's simplicity, a complete description should specify the input parameter and return value. The absence of an output schema and the lack of any parameter mapping means an agent cannot correctly call this tool without additional external knowledge. The large, confusing parameter set amplifies the incompleteness.

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 schema coverage is 100% with each parameter described, the descriptions are generic and unrelated to the tool's purpose (e.g., 'Git ref name; discarded after the shape check'). The tool description does not clarify which parameter is the primary input (likely 'json'), so it fails to add meaning beyond the schema and leaves the agent without direction.

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: 'Count keys in a JSON object.' However, the input schema lists 9 string parameters with no indication of which one carries the JSON object (e.g., the 'json' parameter seems relevant but is not explicitly linked). The mismatch between the stated purpose and the schema makes it ambiguous how to invoke the tool, weakening 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 on when to use this tool versus any of the 26 sibling tools, many of which are shape-checking utilities. The description offers no context for selection, leaving the agent to guess based on 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 are provided, so the description carries the full burden. It discloses the transformation (returns origin/host/path, drops query/fragment) which is helpful. However, it does not mention edge cases like invalid URLs, whether the operation is read-only, or any potential side effects, though for a normalization tool this is minor.

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 redundancy. It front-loads the main output and efficiently covers the key behavior. 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?

The schema contains 9 parameters, many seemingly unrelated to URL normalization (city, json, zone, etc.). The description does not clarify that only the 'url' parameter is needed or that the others are ignored. It also does not specify the output format beyond the three components. An agent could be confused about which parameters to supply, making this incomplete for a tool with such a broad 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 description coverage is 100%, so each parameter has a description. The tool description adds no extra meaning beyond the schema, and does not clarify which of the 9 parameters are relevant for the URL normalization (only 'url' seems applicable). The baseline of 3 is appropriate given the high schema coverage, but the description could have clarified the role of the extra parameters.

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

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

The description clearly states the verb ('Return'), the resource ('URL'), and the specific outputs ('origin, host, and path'), while also specifying what is dropped ('Query and fragment'). This precisely distinguishes the tool from siblings like browser-url-ok or web-fetch, which have different purposes.

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

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

The description implies usage: if an agent needs URL components, it should use this tool. However, it does not explicitly mention alternatives or when not to use it. With many sibling tools present, explicit routing would strengthen guidance, but the purpose alone makes the usage context 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only reveals that no browser is launched, but does not describe what check is performed, whether it sends an HTTP request, what the output/response format is, or any side effects or limitations. 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 a single, front-loaded sentence with no filler. It states the core purpose and the key caveat (no browser) efficiently, earning a high score for conciseness.

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

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

The tool has 9 optional parameters and no output schema or annotations. The description gives almost no context on how to use it, what the result looks like, or when to invoke it. This is incomplete for a tool with this complexity, leaving agents to infer behavior from the name and schema 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 100%, so each parameter is individually documented in the schema. The description itself adds no parameter information and even focuses on 'URL' while the schema includes many unrelated fields (city, feed, json, path, etc.). The schema carries the meaning, so baseline 3 applies.

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

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

The description states a specific verb ('Check') and resource ('whether a URL can be opened'), and explicitly distinguishes from browser-launching alternatives by noting 'No browser is launched.' This separates it from sibling tools like browser-url-ok, though it does not elaborate on what 'opened' means (e.g., HTTP status).

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

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

No guidance is provided on when to use this tool versus siblings like fetch-status, browser-url-ok, or normalize-url. The only implicit hint is the 'No browser is launched' clause, which suggests it is lighter than browser-url-ok but does not explicitly state selection criteria or exclusions.

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

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

With no annotations, the description carries the full burden. It discloses that the query is discarded, which is a useful behavioral trait, but it says nothing about how the count is computed (e.g., Unicode code points vs bytes), whether other parameters are ignored or processed, or what the return value looks like. The many parameters in the schema without explanation create ambiguity about the tool's actual 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 two short sentences with no wasted words. It front-loads the core action and then adds the disposal behavior. This is appropriately concise for a simple tool, though it may be too sparse given 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 tool has 9 parameters, no annotations, and no output schema, so the description must compensate. It fails to explain why the other parameters exist, how they relate to the 'search query' focus, or what the tool returns. The description only addresses the 'query' parameter, leaving the rest unexplained. For a tool with this much surface area, the description is incomplete.

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

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

Schema description coverage is 100%, so the baseline is 3. The parameter descriptions in the schema, such as 'query' ('Search text; discarded after the length check'), already explain the relevant semantics. The tool description adds nothing beyond the schema for parameters. It does not clarify the role of the other 8 parameters, but since the schema covers them individually, the description does not need to repeat that information.

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: 'Count characters in a search query.' It identifies the verb (count) and the resource (search query), and mentions that the query is discarded. However, it does not differentiate from sibling count tools like 'memory-key-count' or 'hn-front-count', and the presence of 9 unrelated parameters in the schema muddies the purpose. A clear statement of scope, but without sibling differentiation.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention any conditions or exclusions, nor does it point to other tools that might be more appropriate for different tasks. The agent is left to infer usage from the name alone, which is insufficient given the diverse sibling set.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'catalog' and gives no indication of side effects, return format, network activity, or whether it is read-only. For a tool with nine parameters, this is a severe 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 it is under-specified to the point of being unhelpful. It is not appropriately sized because it omits essential information about the tool's function and parameters.

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

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

With nine parameters, no annotations, and no output schema, the description is grossly incomplete. It fails to explain the tool's purpose in context, what it returns, or how the parameters are used. An agent would have no idea what to do with 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 input schema provides 100% coverage with clear descriptions for each parameter, so the baseline is 3. However, the tool description adds no meaning beyond the schema; it does not explain how parameters like 'city' or 'json' relate to the catalog. The schema is self-sufficient, so the description adds no extra semantic value.

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

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

The description 'Short catalog of common HTTP status codes' is a noun phrase with no verb, so it does not state what action the tool performs. It does not explain how the nine diverse parameters (ref, url, city, feed, host, json, path, zone, query) relate to a catalog of status codes, and it does not distinguish the tool from siblings like fetch-status or browser-url-ok.

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. No mention of scenarios, prerequisites, or exclusions. An agent cannot determine when this tool is appropriate.

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 only says 'Prompt discarded', which is ambiguous and doesn't clarify how parameters are handled or if the tool has 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 concise (one sentence plus a fragment) but poorly structured; the 'Prompt discarded' phrase is unclear and not integrated with the main action.

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

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

For a tool with 9 parameters, no output schema, and no annotations, this description is severely under-specified. It doesn't explain what the parameters are for, what the template contains, or how the tool should be invoked.

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 descriptions cover all 9 parameters, so the baseline is 3. The tool description adds no parameter information beyond what's in the schema, and doesn't explain the relationship between parameters and the template.

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 (return a three-step thinking template) but is vague about the template's content and purpose. It doesn't differentiate from siblings, though none seem directly similar, and the phrase 'Prompt discarded' is confusing.

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 gives no context on scenarios, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Current time' without specifying return format, network dependencies, rate limits, or side effects. It also doesn't clarify that only the 'zone' parameter is relevant, despite the schema containing 8 unrelated parameters.

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, front-loaded sentence with zero wasted words. It states exactly what the tool does in the fewest possible words. 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?

The description is inadequate for a tool with 9 parameters and no output schema. It doesn't specify the return format, whether it includes date or offset, or which parameters actually affect the result. The presence of many unrelated parameters adds confusion. The description should clarify the tool's scope and output but does not.

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 every parameter has a description. The relevant 'zone' parameter is described as 'IANA timezone name', which is clear. However, the description adds no parameter info beyond the schema and doesn't indicate that the other 8 parameters are ignored. Baseline 3 applies due to high 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 states a clear verb+resource: returns current time for a named IANA timezone. It distinguishes itself from siblings like utc-time and iana-zones, though not explicitly. The 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?

No guidance on when to use this tool versus alternatives like utc-time or iana-zones. The description provides no conditions, exclusions, or routing advice. Usage context is left entirely to the agent's inference.

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 only states 'Current UTC timestamp' and gives no information about side effects, parameter handling, return format, or operational constraints. It does not even mention that the tool accepts parameters or that they are discarded. This is a significant gap for a tool with 9 optional 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 extremely concise, using only four words. It is appropriately front-loaded, but it omits any structure or detail that would help an agent understand the tool's interface. The brevity is not harmful, but it fails to earn its place by adding value beyond the name.

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 9 optional parameters, no output schema, and no annotations, the description is grossly incomplete. An agent cannot infer why a UTC time tool accepts parameters like 'city' or 'url', nor what the return value looks like. The description does nothing to resolve the mismatch between the name and the parameter set, making the tool difficult 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?

Schema description coverage is 100%, meaning every parameter already has a description in the schema. The description adds no extra meaning about parameters. Per calibration, baseline is 3 when the schema fully documents parameters. The description could have clarified the role of the optional parameters but does not.

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

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

The description 'Current UTC timestamp' states a clear verb and resource. It is specific about what the tool returns (UTC timestamp) and distinguishes from siblings like 'timezone' and 'iana-zones' by naming the exact output. However, it does not explicitly name alternatives or state what it is not.

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

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

There is no guidance on when to use this tool versus alternatives. The description provides no context about selection criteria, exclusions, or scenarios where another sibling would be more appropriate. The agent is left to infer 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 are provided, so the description carries the full burden. It only says 'The body is discarded', which is a privacy trait, but it does not explain return behavior (e.g., boolean vs error), what happens on invalid JSON, or the purpose of the 8 other parameters. The description is far from transparent for a tool with no annotations.

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

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

Two short sentences with zero fluff. The core action is front-loaded, and there is no irrelevant 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 no output schema and no annotations, yet the description does not explain return values, error behavior, or the presence of 9 parameters when only one seems relevant. It is incomplete for a tool that should clarify its input contract and outcome.

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 each parameter already has a description. The tool description adds no parameter guidance and does not map 'body' to the 'json' parameter, but the schema itself names 'json' as 'JSON text to validate', which is sufficient. Baseline 3 is appropriate.

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

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

The description states a clear action ('Check whether a body is valid JSON') with a specific resource. It is not a tautology and is distinguishable by name from sibling shape-checkers, but it does not explicitly differentiate from them or clarify that the 'body' refers to the 'json' parameter.

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 indication of when to use this tool versus alternatives like 'domain-shape' or 'github-repo-shape'. It does not state any conditions, exclusions, or mention 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?

With no annotations, the description carries the full burden of behavioral disclosure. It claims to return temperature for a city, but the input schema lists nine parameters, most of which are marked as 'discarded' or used for unrelated checks (e.g., ref, url, json, path, query). The description does not disclose that these parameters are ignored or that the tool only uses 'city'. This is misleading and contradicts the schema's implied multi-purpose behavior, warranting the lowest score.

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

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

The description is only one sentence, which is concise, but it is under-specified rather than efficiently structured. It lacks any breakdown of the tool's scope, caveats, or relationship to the extensive parameter list. The brevity does not contribute to clarity; it hides 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?

For a tool with nine parameters, no required fields, no output schema, and no annotations, this description is severely incomplete. It mentions only 'city' while the schema implies a much broader set of checks. An agent cannot determine how to correctly invoke the tool, what to expect in response, or what the other parameters are for. The description fails to provide the necessary context.

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

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

Schema description coverage is 100%, so each parameter has a description in the schema. The tool description itself adds nothing about parameter usage, but the baseline is 3 because the schema already documents parameters. However, the descriptions in the schema are odd (e.g., 'discarded after the shape check') and do not clarify how they relate to the stated weather purpose, which slightly reduces the value added beyond the schema.

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

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

The description states a specific action (current temperature) for a specific resource (a city) via a named service (Open-Meteo). This is clear and distinguishes it from unrelated siblings like validate-json or browser-url-ok, but it does not explicitly name any alternative or contrast with a close sibling (e.g., geo-hint). It is not a tautology and provides a definite 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?

There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites or exclusions. The description simply states what it does without any context about appropriate use cases, input restrictions, or what the tool is not for.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose that the body is discarded and that only status/content type are returned, which is useful. However, it fails to disclose the behavior for the other eight parameters (e.g., city, json, query) which are described in the schema as 'discarded after' checks but are not mentioned in the description at all. No side effects, authentication, or rate limits are mentioned.

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

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

The description is concise (two sentences) and front-loaded with the primary purpose. It wastes no words. However, it is so brief that it omits essential context, which moves it from 'appropriately concise' to 'under-specified.' Still, for conciseness alone it earns a 4, though the lack of structure for a multi-parameter tool is a flaw.

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 annotations, and no output schema, yet the description only addresses one parameter (url). It gives no explanation of how the other parameters are used, what the expected response format is, or what conditions trigger the checks. An agent would be unable to correctly invoke this tool for any parameter other than url, and even for url the behavior is only partially described. This is severely incomplete for a tool of this 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 description coverage is 100%, so each parameter already has a description. The tool description itself adds no parameter semantics—it does not explain how the parameters relate to the tool's purpose. Baseline of 3 is appropriate because the schema covers the parameters, but the description adds no value beyond that and leaves the relationship between parameters and tool behavior 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 clearly states the core function: obtaining HTTP status and content type for a public URL, and notes the body is discarded. This distinguishes it from generic 'fetch' tools and gives a specific verb+resource. However, it does not differentiate from siblings like fetch-status or browser-url-ok, and the presence of unrelated parameters (city, json, zone) introduces ambiguity about the tool's full scope.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any conditions, prerequisites, or exclusions. An agent would have no basis to choose web-fetch over fetch-status or normalize-url, especially given the tool's broad parameter set.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the title is discarded, but since 'title' is not a parameter, this claim is disconnected from the actual inputs. It does not mention side effects, permission requirements, or return behavior.

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

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

The description is a single sentence with no wasted words, but it is severely under-specified and does not front-load actionable information. Conciseness is not a virtue when it omits critical details and misrepresents the tool's functionality.

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 9 parameters, no output schema, and no annotations, the description is utterly insufficient. It does not explain how the parameters map to the stated purpose, what the return value is, or any usage context. An agent would be unable to correctly invoke this tool based on the description 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?

Although the schema has 100% description coverage for each parameter, the tool description does not reference any of them. It mentions a 'title' that is absent from the schema, providing no semantic link between the stated purpose and the actual parameters. The description fails to add meaning beyond the schema and even introduces confusion.

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

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

The description states a specific check ('whether a Wikipedia title exists'), but the input schema exposes nine parameters (ref, url, city, feed, host, json, path, zone, query) with no 'title' field. This creates a direct mismatch between the stated purpose and the actual inputs, making the description misleading for an agent trying to invoke 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?

No guidance is given on when to use this tool versus any of the 27 sibling tools. There is no mention of conditions, exclusions, or alternatives, leaving the agent without context for selection.

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