Europe/Samara clock

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 disclose that it returns CLI setup, how-it-works, skill file, and remote MCP hops, and that 'Task text discarded.' This gives some transparency about outputs and input handling. However, it doesn't mention side effects, network access, error behavior, or authentication requirements. Given zero annotations, this is partially transparent but not comprehensive.

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

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

Two sentences with zero waste. The primary purpose is front-loaded, and the discard note is secondary. It's appropriately concise and structured.

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

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

With 9 optional parameters, no output schema, no annotations, and 27 siblings, the description is incomplete. It doesn't clarify how the parameters relate to the tool's function, what a successful call returns in detail, or how it differs from similar hint tools. An agent would be uncertain about what parameters to supply and what the tool actually does beyond returning static info.

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

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

Schema coverage is 100%, so all 9 parameters are documented in the schema. The description adds no parameter-specific information; it doesn't explain how parameters map to the tool's function (e.g., which parameter is needed for what). Baseline 3 is appropriate since the schema does the heavy lifting, but the description doesn't enhance 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: 'Find a public pay-per-call tool gateway (Monid)' and lists the outputs (CLI setup, how-it-works, skill file, remote MCP hops). This is a clear verb+resource combination. However, it doesn't differentiate from sibling hint tools like 'lib-docs-hint' or 'weather-hint', and the exact operation (does it fetch remote info?) is ambiguous. Still, the core purpose is identifiable.

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. With 27 sibling tools, many likely handling similar URL/parameter checks, the description doesn't state exclusions or alternatives. It implies usage for finding a Monid gateway but doesn't specify prerequisites or when not to use it.

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

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

With no annotations, the description must disclose behavior fully. It only states that no browser is launched, but omits what 'can be opened' actually entails (e.g., network request vs. syntax check) and does not explain the fate of the nine parameters (many of which are unrelated). The tool's actual behavior remains opaque, especially regarding the discarded parameters mentioned in the schema.

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

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

The description is extremely concise—two short sentences with no fluff. The behavioral note about not launching a browser is front-loaded and useful. However, it is so sparse that it borders on under-specification rather than being efficiently 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?

Given 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain what 'can be opened' means operationally, how the parameters influence the check, or what the tool returns. An agent cannot correctly invoke this tool based on the description alone, especially with the many 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%, so each parameter has a brief description. The tool description adds no additional meaning beyond the schema, but the schema already covers the basics. The description does not clarify why so many unrelated parameters (city, json, path, zone, query) are present, which is a missed opportunity, but the baseline of 3 is appropriate given full schema coverage.

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

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

The description states a clear verb ('Check') and resource ('URL'), and adds a key qualifier ('No browser is launched') that hints at its non-browser nature. However, it does not differentiate from many siblings like fetch-status, web-fetch, or playwright-url-ok, which also deal with URL checking or fetching. The primary action is clear, but the scope is 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?

No guidance is provided on when to use this tool versus its many siblings. The description does not mention alternatives, exclusions, or conditions for selection. An agent would have to guess when to pick this over fetch-status or web-fetch, making the choice ambiguous.

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 disclosure burden. It discloses 'Expression discarded,' but this refers to an arithmetic expression that does not exist in the schema — a phantom behavioral note. It says nothing about what happens to any of the 9 real parameters (e.g., whether they are validated, normalized, or discarded), leaving the tool's actual behavior completely 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 text is brief — two short sentences with no wasted words — but brevity here comes at the cost of correctness. It is under-specification rather than good conciseness: it omits how the tool relates to its actual parameters and states a purpose contradicted by the schema. Front-loading an inaccurate claim does not earn conciseness credit.

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, so the description carries full responsibility. It explains none of the real parameters, introduces a task (arithmetic) not represented in the schema, and gives the agent no way to invoke the tool correctly. This is completely inadequate for a tool of this parameter count.

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%, which normally earns a baseline of 3, but the description actively harms parameter understanding by introducing an 'a+b' arithmetic concept entirely absent from the schema. An agent would be unable to map the described task onto any of the 9 actual parameters. The description adds no meaning to the schema's parameters and instead inserts a phantom one, which is worse than adding nothing.

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 the tool evaluates 'a+b style arithmetic,' which is a clear verb+resource on its face. However, the input schema contains no arithmetic or expression parameter whatsoever — the 9 actual parameters (ref, url, city, feed, host, json, path, zone, query) are about URLs, timezones, JSON validation, and file paths. The description's stated purpose does not match the schema it governs, making it misleading for an agent trying to figure out what the tool actually operates on.

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

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

No guidance is given on when to use this tool versus any of its 26 siblings. The description doesn't reference alternatives, exclusions, or conditions. Worse, since the stated purpose (arithmetic) contradicts the actual parameters, an agent gets no usable context about when this tool would be the right choice among tools like normalize-url, validate-json, or timezone.

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 notes that page content is not stored, but does not explain behavior for the other parameters, whether the operation is read-only, any side effects, rate limits, or what happens with invalid inputs. The minimal disclosure is insufficient for a tool with nine 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 extremely short (two sentences) with no wasted words, but it omits critical information about the majority of parameters. While concise, the structure fails to front-load essential scope details, making it inadequate for the tool's complexity.

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

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

Given nine parameters, no output schema, and no annotations, the description is far from complete. It only addresses URL-related functionality, leaving the other eight parameters unexplained in terms of their role in the tool. An agent would have to infer usage from parameter names alone, which is risky.

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 provides 100% parameter descriptions, each explaining the parameter's purpose and discard behavior. The tool description adds no additional semantic value beyond the schema, so the baseline of 3 is appropriate.

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

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

The description states a specific action for a URL (return host, scheme, HTTP status), but the tool accepts nine unrelated parameters (city, feed, json, path, zone, query, etc.) with no mention of them. This creates ambiguity about the tool's actual scope, especially given the name 'citation' which suggests broader use.

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 its many siblings (fetch-status, normalize-url, browser-url-ok, etc.). There is no mention of alternatives, prerequisites, or scenarios where this tool is preferred.

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

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

With no annotations, the description must carry the full behavioral burden. It only states that identifiers are not retained, which is a privacy note, but it doesn't disclose whether the operation is read-only, whether it has side effects, or what happens to the input data. It doesn't address error handling, rate limits, or any other behavioral traits.

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 (two sentences), which is concise, but it is under-specified. It lacks essential information, so it's not effectively concise – it's just brief. It does front-load the main statement, but that statement is vague.

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 parameters, no output schema, and no annotations, the description is grossly incomplete. It doesn't explain what the tool does with these parameters, what the classification means, or how an agent should interpret the output. This is inadequate for an agent to decide when and how to call it.

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

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

The input schema covers 100% of parameters with individual descriptions, so the baseline is 3. The description adds no additional parameter semantics beyond what the schema provides – it doesn't clarify relationships, usage patterns, or any meaning that isn't already in the schema.

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

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

The description states a verb ('show') and a resource ('classification'), but it is vague: it doesn't specify what kind of classification, what inputs trigger it, or what the output looks like. It does not differentiate from the many sibling tools that also analyze requests, such as domain-shape or fetch-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 given on when to use this tool versus alternatives. It doesn't mention any conditions, exclusions, or recommended scenarios, 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 must carry the behavioral burden. It discloses that the tool does not fetch WHOIS/ownership data, which is a useful trait. However, it does not mention error handling, return format, or whether the operation is local or network-based. The disclosure is minimal but not misleading.

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

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

The description is a single, efficient sentence with no fluff. It front-loads the core action and includes a relevant exclusion. Every word earns its place.

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

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

Despite a simple purpose, the tool has 9 parameters, no output schema, and no annotations. The description fails to specify which parameter to use for the hostname or what the output looks like. An agent would struggle to call this tool correctly without inspecting the schema and inferring the relevant parameter. The description is too thin for the given 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?

The input schema has 100% description coverage, so each parameter is documented. The description does not add any parameter-level detail, nor does it indicate which parameter (likely 'host') is the primary input. Given high schema coverage, the baseline is 3, and the description does not raise it.

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

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

The description states a specific verb and resource: 'Split a hostname into labels'. It also clarifies a key exclusion ('without WHOIS or ownership data'), which differentiates it from ownership-related sibling tools. This is not a tautology and clearly conveys what the tool does.

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

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

The description implies a lightweight shape operation by excluding WHOIS/ownership data, but it does not explicitly state when to use this tool over alternatives or name any sibling tools. There is no clear 'use this when...' guidance, only an implicit context. The exclusion is useful but not sufficient for routing decisions.

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

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

With no annotations provided, the description must disclose all behavioral traits. It states the tool performs a HEAD request and returns status only, but it does not mention that most parameters are ignored or discarded, nor does it describe side effects, authentication needs, or the response format. The description fails to surface the tool's actual behavior for non-URL 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 a single sentence, which is concise, but it is under-specified for a tool with nine parameters. It is not front-loaded with critical scoping information and does not earn its brevity because it omits essential context about the tool's actual scope and parameter handling.

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 (nine parameters, no output schema, no annotations), the description is severely incomplete. It does not explain what the tool does with each parameter, whether they are alternative modes, or what the return value looks like beyond 'status only.' An agent cannot reliably call 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?

Although the input schema provides 100% description coverage for all nine parameters, the description adds no semantic value beyond the schema and actually misleads by implying only the 'url' parameter is used. It does not explain how other parameters (city, zone, query, etc.) relate to the tool's purpose or how they are processed, so the description fails to compensate for the schema's raw field list.

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 'HEAD a public URL and return status only,' which is clear for a URL check, but the input schema includes nine parameters (city, zone, query, json, etc.) that have nothing to do with HEADing a URL. This mismatch makes the purpose ambiguous and potentially misleading, as the description does not account for the tool's broader functionality or distinguish it from siblings like web-fetch 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 its siblings (e.g., web-fetch, normalize-url, browser-url-ok). The description does not mention any conditions, prerequisites, or exclusions, leaving the agent without direction 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 are provided, so the description must carry the full burden. It only reveals that the path is discarded, but omits error handling, required URL format, return value, or any side effects. This is minimal disclosure for a tool with no structured behavioral hints.

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

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

The description is very concise (one sentence), which is good, but it omits essential information. It is under-specified rather than appropriately concise, leaving the agent without necessary 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 no output schema, no annotations, and a terse description, the tool is inadequate for an agent to call correctly. The description doesn't clarify how to use the 9 parameters or what the tool returns, and the parameter set seems inconsistent with the 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?

Schema coverage is 100% so baseline is 3, but the description does not link any parameters to the Figma URL parsing behavior. The parameter set (city, feed, json, etc.) appears unrelated to Figma, and the description provides no clarification on which parameters are relevant or how they map to the parsing task.

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

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

States a specific verb (parse) and resource (Figma file URL) and a key behavior (path discarded). However, it doesn't explain what 'parse' returns or how it differs from sibling URL tools like normalize-url, beyond the Figma specificity.

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

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

No guidance on when to use this tool versus alternatives. Does not mention when not to use it or provide any exclusions or context for selection.

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

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

With no annotations, the description carries the full burden. It does state 'No disk access,' which is a useful safety hint. However, it fails to disclose that the tool also accepts and discards other parameter types (as indicated by schema descriptions like 'discarded after the shape check'), nor does it clarify what 'safe' means or what the output format is. The behavioral scope is under-explained.

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

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

The description is a single sentence, which is concise but under-specified. It front-loads the purpose but omits essential information about the tool's full capabilities. This is not effective conciseness; it is a lack of specification. The description should at least mention that it handles multiple input types.

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

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

For a tool with 9 optional parameters and no output schema, the description is severely incomplete. It only addresses one parameter ('path') and ignores the other 8. It does not explain the overall purpose of a 'shape check,' what constitutes 'safe,' or what the tool returns. An agent cannot confidently call this tool for non-path inputs 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 description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond the schema. It does not explain the relationship between the 'path' parameter and the other parameters, nor does it clarify that they are all optional. The schema already documents each parameter, so the description contributes nothing extra.

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: 'Check whether a path looks safe.' This aligns with the tool name. However, the input schema includes 8 other parameters (ref, url, city, feed, host, json, zone, query) with no mention in the description, making the actual scope ambiguous and potentially misleading. The purpose is clear only for the 'path' parameter, not for the tool as a whole.

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 sibling tools like browser-url-ok, domain-shape, or validate-json. It does not mention alternatives, exclusions, or specific scenarios. The agent is left to infer that this tool is for path safety, but there is no comparative guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the output (lat/long) but gives no details on network calls, data source behavior, side effects, or the fact that most schema parameters are discarded. It does not mention that inputs like 'ref' and 'url' are ignored, which is surprising given the schema.

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

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

The description is a single sentence, which is concise and easy to parse. However, it lacks structure: no emphasis on key inputs, no examples, and no logical flow that helps an agent understand how to use the tool. It is brief but not well-organized for usability.

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 severely incomplete. It does not explain what the output looks like, how the parameters interact, or what happens with discarded values. An agent would have little idea how to correctly invoke this tool, making it essentially unusable without additional investigation.

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 descriptions for all 9 parameters (100% coverage), so the baseline is 3. However, the tool description adds no meaning beyond the schema and does not indicate which parameter is the 'place' for which lat/long is returned. The 'city' parameter seems relevant, but the description never references it, leaving the agent uncertain about parameter selection.

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: returning latitude and longitude for a place via Open-Meteo. However, it does not specify which input parameter identifies the place, and the schema contains many unrelated parameters (ref, url, feed, etc.), creating ambiguity. It also fails to distinguish from sibling tools like weather-hint or iana-zones, which also deal with location data.

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

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

There is no guidance on when to use this tool versus alternatives. The description provides no conditions, prerequisites, or context that would help an agent decide between geo-hint and other geo-related tools. It is a bare statement with no usage context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the parsing action and omits critical traits: whether the operation is read-only, what it returns, or how it handles malformed or non-GitHub URLs. The schema's many parameters marked as 'discarded' imply the tool accepts and ignores extras, but the description doesn't state this, leaving agent expectations unclear.

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 filler, front-loading the action and resource. It is efficient and free of redundancy. However, its brevity borders on under-specification, though conciseness itself is not the problem—the lack of context is. The structure is appropriate for the little it says.

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 parameters, no output schema, and no annotations, a one-sentence description is grossly inadequate. An agent cannot determine which parameters to use, what the tool returns, or how it behaves under different inputs. The description fails to provide the minimum context needed for correct invocation, especially since most parameters seem irrelevant to the 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?

Schema description coverage is 100%, but the tool description adds no meaning beyond that. Only 'url' seems relevant to the stated purpose, yet the schema exposes nine parameters with descriptions suggesting they belong to unrelated checks (city, feed, json, etc.). The description fails to indicate that most parameters are ignored, which could mislead an agent into passing irrelevant arguments.

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 'Parse' and the resource 'owner and repo from a GitHub URL', making the primary purpose unambiguous. It also differentiates from sibling shape tools by specifying GitHub-specific extraction. However, it does not describe the output format or error handling, so it's clear but not fully comprehensive.

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 like figma-url-shape, jira-key-shape, and domain-shape exist for other URL types, but the description never mentions them or any selection criteria. An agent has no basis to choose this tool over similar shape-checking tools.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states 'Titles discarded,' which hints at output filtering but says nothing about side effects, network access, authentication, or what happens with the various parameters. For a tool that likely performs external fetching, 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 extremely short, which is concise, but it under-specifies. It is not front-loaded with useful details—it lacks any explanation of inputs or behavior beyond the single action. Conciseness without substance is not effective.

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

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

For a tool with 9 optional parameters and no output schema, this description is severely incomplete. It does not state which parameters are required (even though none are required, it doesn't say that), what the output looks like, or how the tool interacts with Hacker News. An agent cannot correctly invoke this tool without additional 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?

The description adds zero meaning to the parameters. The schema has 100% coverage but the parameter descriptions are generic (e.g., 'Git ref name; discarded after the shape check') and unrelated to counting HN stories. The description does not explain how 'ref', 'url', 'city', etc. map to the tool's purpose. An agent cannot determine what to pass.

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: 'Count current Hacker News front-page stories.' This is clear and not a tautology. However, the second sentence 'Titles discarded' adds a behavioral note but does not clarify how the tool actually works or what parameters are relevant. It does not distinguish from siblings, but the core purpose is discernible.

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 context, exclusions, or conditions are provided. The description gives no hint about which of the 9 optional parameters are appropriate or how to select them for a valid call.

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 no behavior: no mention of whether it is read-only, what it returns, side effects, or limitations. The description is a bare fragment with zero operational detail.

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

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

The description is one short sentence, which is concise in length but severely under-specified. It lacks the substance needed for an agent to understand the tool. This is under-specification rather 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?

With 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain the tool's core function, return value, or any operational details. An agent cannot safely or correctly invoke this tool based on the given 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 coverage is 100%, so each parameter has its own description. However, the tool description adds nothing beyond the schema and does not explain how the parameters relate to the supposed purpose. The 9 unrelated parameters (ref, url, city, feed, host, json, path, zone, query) appear arbitrary without context, making the tool confusing.

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

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

The description is a noun phrase, not a clear verb+resource. It says 'Common IANA timezone names for clock calls' but does not state what the tool actually does (e.g., list, validate, return). It fails to distinguish itself from sibling tools like 'timezone' or 'utc-time'.

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

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

There is no guidance on when to use this tool versus alternatives. No mention of prerequisites, contexts, or exclusions. An agent has no clue about the intended use case.

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

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

The description discloses that only group counts are returned, which is useful. However, it does not mention that most of the 9 input parameters are discarded (as stated in the schema) or that the tool makes a network request, nor does it clarify that only the 'url' parameter is actually used. With no annotations, this lack of clarity about the tool's real behavior is a significant gap.

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

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

The description is a single sentence with no fluff, which is concise and front-loaded with the core action. However, it is so terse that it omits critical invocation details, but that is more a completeness issue than a conciseness issue. The structure 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 has 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain the purpose of the many seemingly unrelated parameters, does not indicate which parameter is the robots.txt URL, and does not describe the format of the group counts returned. An agent would struggle to call 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%, so each parameter already has a clear description (e.g., 'Git ref name; discarded after the shape check'). The tool description adds no additional parameter information, which is acceptable given the schema's completeness. Baseline of 3 applies because the schema carries the burden.

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

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

The description states a specific action ('Fetch a public robots.txt') and result ('return group counts only'), which is clear. However, it does not specify which input parameter provides the robots.txt URL, and the parameter list contains many unrelated fields (city, zone, query, etc.) that appear irrelevant to the described purpose, creating ambiguity about how to actually 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?

There is no guidance on when to use this tool versus the numerous sibling tools (e.g., web-fetch, fetch-status, browser-url-ok). No exclusions, alternatives, or prerequisites are mentioned, leaving an agent without context to choose it correctly.

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. The only behavioral disclosure is 'Key discarded,' which hints at non-persistence. It does not explain what 'shape' means, whether validation is syntactic or semantic, what the return value is, or any side effects. This is severely lacking for a tool with zero annotation coverage.

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

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

The description is extremely concise at two sentences, but it is under-specified rather than efficiently concise. It omits essential information such as valid key formats, which parameter to use, and the result format. Conciseness without substance earns a low score.

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

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

Given the tool has 9 parameters, no output schema, and no annotations, the description is wholly inadequate. It does not connect the schema parameters to the Jira key check, does not specify expected input/output behavior, and leaves the agent guessing. This is a major gap 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 the baseline is 3. The description adds no parameter-specific information beyond what the schema already provides, and it does not clarify which of the 9 parameters is the Jira key. The phrase 'Key discarded' applies to many parameters but does not help map them to the tool's purpose.

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

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

The description states a clear purpose: 'Check a Jira issue key shape.' This is a specific verb and resource, and the name reinforces it. However, it does not differentiate from sibling shape-checking tools like domain-shape or github-repo-shape, and it leaves unclear which parameter represents the Jira key.

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 does not mention any conditions, exclusions, or sibling tools. Given many similar shape-checking siblings exist, an agent has no basis to choose this one.

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

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

With no annotations, the description must disclose behavioral traits. It only mentions 'Body discarded' for the URL case, but fails to explain that other parameters (city, json, zone) likely trigger entirely different behaviors. The tool's actual operation is 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 (two clauses), but it is under-specified rather than efficiently concise. It omits essential context about the tool's multi-parameter nature, so the brevity harms usefulness rather than aiding clarity.

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

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

For a tool with 9 parameters, no output schema, and no annotations, the description is critically incomplete. It addresses only one parameter (url) and gives no hint of what happens with the other eight, leaving the agent without enough information to call the tool correctly.

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

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

The input schema provides 100% description coverage for all 9 parameters, so the schema already explains each parameter individually. The description adds no additional semantic meaning beyond the schema, meeting the baseline for schema-covered parameters.

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

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

The description states a specific action ('HTTP status for a public library docs URL') but the tool accepts nine unrelated parameters (city, json, zone, query, etc.), suggesting a multi-purpose checker. It does not clarify that the tool likely performs different checks depending on which parameter is set, making the stated purpose misleading and incomplete.

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

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

No guidance is provided on when to use this tool versus its many siblings (e.g., fetch-status, browser-url-ok, validate-json, timezone). There is no mention of alternatives or exclusions, leaving the agent to guess the tool's scope.

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

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

With no annotations provided, the description carries the full burden. It discloses that values are discarded, which is useful, but says nothing about error behavior on invalid JSON, output format, or side effects. The term 'memory' is unexplained, and the discrepancy between the stated purpose and the schema parameters raises behavioral ambiguity.

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

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

The description is extremely terse (six words), which is not conciseness but under-specification. It omits essential operational details and does not front-load any guidance about inputs or expected behavior.

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 9 parameters with no required fields, no output schema, and no annotations, the description is grossly inadequate. It provides no way to map the intended operation to the schema, nor does it explain what 'memory' implies or how results are returned.

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 description coverage is 100%, the description adds zero information about which parameter is the JSON object. It does not reference any of the 9 parameters, so an agent cannot determine how to construct a valid call. The description fails to bridge the gap between the high-level operation and the concrete inputs.

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

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

The description states a clear verb and resource: 'Count keys in a JSON object. Values discarded.' This distinguishes it from siblings like validate-json or domain-shape. However, it does not indicate which of the 9 schema parameters supplies the JSON object, leaving the agent unable to map the operation to its inputs.

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

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

No guidance on when to use this tool versus alternatives such as validate-json or domain-shape. The description does not mention any context, exclusions, or conditions, 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 only that no browser is launched, but does not describe what the check actually does (e.g., HTTP status, syntax validation, side effects, or permissions). This is insufficient for an agent to predict 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 short (two sentences) but under-specified. It is not a case of effective conciseness; it omits critical details and offers no structure to guide an agent. The 'No browser' note is useful but insufficient.

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

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

For a tool with nine parameters, no annotations, and no output schema, the description is completely inadequate. It fails to explain the tool's actual behavior, return value, or usage context, leaving an agent unable to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. However, the tool description does not explain how the nine parameters—many unrelated to URLs (city, json, zone, query)—relate to the stated purpose of checking a URL. This mismatch can confuse an agent about which parameter to supply for a given task.

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

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

States a verb ('Check') and a resource ('whether a URL can be opened'), but the term 'opened' is ambiguous—does it mean HTTP reachability, syntactic validity, or DNS resolution? It also does not distinguish from siblings like browser-url-ok or normalize-url beyond the 'no browser' note.

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

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

Provides no guidance on when to use this tool versus alternatives. The only hint is 'No browser is launched,' which implies a lightweight check but does not explicitly route an agent to a sibling for cases requiring browser rendering or URL normalization.

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. It only states that the tool is a 'catalog' and does not reveal what it returns, whether it performs checks, discards inputs, or has side effects. The schema hints at 'discarded after the shape check' but the description never explains the operational behavior, leaving the agent entirely in the dark.

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 with no fluff, achieving efficiency. However, it is under-specified: the sentence conveys a noun phrase rather than an actionable instruction, and the brevity works against clarity. It is concise but not effective, so a middle score is appropriate.

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 severely inadequate. The schema hints at multiple distinct checks (URL normalization, JSON validation, path checking, timezone, etc.) but the description does not explain how these combine or what the agent should expect. An agent cannot call this tool correctly without far more context.

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

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

The schema descriptions cover 100% of parameters and provide individual meanings (e.g., 'JSON text to validate; discarded after the check'), so a baseline of 3 is warranted. However, the tool description fails to integrate these into a coherent purpose, and the parameters seem unrelated to 'HTTP status codes.' The description adds no value beyond the schema and does not clarify how to select parameters to get the desired output, lowering 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 the tool is a 'Short catalog of common HTTP status codes,' which names a resource (HTTP status codes) but lacks a verb describing what action the tool performs. It doesn't explain how the nine optional parameters (ref, url, city, feed, etc.) relate to this catalog, leaving the actual purpose ambiguous and failing to distinguish it from siblings like fetch-status or validate-json.

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 gives no context for selecting it over fetch-status, browser-url-ok, or normalize-url, nor does it mention any exclusions or prerequisites. The agent has no basis for choosing this tool.

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

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

With no annotations, the description carries the full burden. It states the prompt is discarded, implying input is ignored, but it does not explicitly say that all parameters are no-ops. It also fails to disclose what the template contains, whether it is static, or any side effects. This is a significant transparency gap 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 sentence, highly concise and front-loaded with the main purpose. There is no wasted wording. However, it omits any explanation of the parameters or usage, making it under-specified relative to the tool's complexity. It is concise but not fully structured for agent understanding.

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

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

Given 9 parameters and no output schema, the description is grossly incomplete. It does not explain why the parameters exist, what the three-step template contains, or how an agent would use this tool effectively. There is no indication of expected behavior, edge cases, or relationship to siblings. An agent cannot determine when or why to call this tool.

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

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

Schema coverage is 100%, and each parameter is individually described as discarded. The tool description adds no parameter-level meaning beyond the schema. It does say 'Prompt discarded,' which loosely indicates that inputs are ignored, but it does not map to specific parameters. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description states a specific action ('Return a three-step thinking template') and identifies the resource. It is clear about what the tool does, but it does not differentiate from siblings. The presence of 9 parameters that are all described as 'discarded' could confuse an agent about the tool's actual scope, but the core 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?

The description provides no guidance on when to use this tool versus the 27 siblings. It does not mention conditions, alternatives, or prerequisites. The only hint is 'Prompt discarded,' which implies a thinking aid, but there is no explicit context for when it should be invoked.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It implies a read-only operation (getting current time) but does not explicitly state side effects, rate limits, or whether the call is stateless. For a simple time lookup, the minimal description is adequate but not rich; it adds no context beyond the obvious action. Given the simplicity, a score of 3 is appropriate.

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

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

The description is a single, concise sentence that is front-loaded with the core action and resource. It contains no filler or redundant wording, making it an example of efficient specification.

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

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

The tool is named 'timezone' yet the schema includes 9 unrelated parameters (ref, url, city, feed, host, json, path, query) that appear to have no connection to timezone functionality. The description does not explain why these parameters exist or whether they are ignored, making the tool's behavior confusing. For a tool with such a broad schema, the description is incomplete and fails to clarify the intended usage context.

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

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

The schema has 100% parameter description coverage, meaning every parameter (ref, url, city, feed, host, json, path, zone, query) has a textual description. The tool description adds no additional parameter semantics beyond mentioning 'IANA timezone' which aligns with the zone parameter. Since the schema already provides full meaning, the description adds little value, so the baseline of 3 applies.

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

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

The description 'Current time in a named IANA timezone' clearly states the action (getting current time), the resource (a timezone), and the specific standard (IANA). It distinguishes itself from siblings like utc-time (which returns UTC) and iana-zones (which lists zones). 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 is given about when to use this tool versus alternatives such as utc-time or iana-zones. The description does not mention any exclusions, prerequisites, or conditions that would direct an agent to select this tool over others. It simply states what it does without situational context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Current UTC timestamp' and reveals nothing about side effects, network requirements, or the fact that the nine parameters are mostly discarded after checks. There is no mention of read-only status, error behavior, or output format. This is severely under-disclosed.

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

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

The description is a single, front-loaded sentence with zero wasted words. It states the core purpose immediately. However, it is so minimal that it omits essential context, but that is a completeness issue, not a conciseness issue. For what it attempts to say, it is efficient and well-structured.

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

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

This tool has 9 optional parameters, no output schema, and no annotations. The description is utterly inadequate for an agent to understand what the tool actually does with those parameters, what the return value looks like, or any behavioral aspects. It fails to explain the purpose of the parameters (even though they are individually documented in the schema) and provides no context about when the tool is useful. This is a severe completeness gap.

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

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

Schema coverage is 100%, meaning each parameter has a description in the schema. The tool description itself adds no information about parameters, but the schema already explains each one. According to the rubric, baseline for high schema coverage is 3. The description does not enhance or clarify parameter usage beyond what the schema provides, so a 3 is appropriate.

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

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

The description states a specific verb and resource: returns the current UTC timestamp. This is clear and distinct from generic 'get time' tools. However, it does not explicitly differentiate from sibling tools like 'timezone', which might also return time-related data. The name itself adds clarity, but the description could be more explicit about scope.

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

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

The description gives no guidance on when to use this tool versus alternatives. It merely states the function without any context about appropriate use cases, exclusions, or alternative tools. An agent would have no basis for selecting this over 'timezone' or other time-related tools.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states the body is discarded, but does not explain what the tool returns, how validation works, or any side effects. The term 'body' is ambiguous and does not clarify the role of the other eight 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 concise sentence with no fluff, front-loading the core action. However, its brevity sacrifices critical detail, so it is not a model of effective structure.

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

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

Given the complexity of 9 parameters, no required fields, and no annotations or output schema, the description is severely incomplete. An agent cannot determine the correct parameter to use, the return value, or any constraints.

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

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

While the schema provides 100% coverage with descriptions for all parameters, the tool description adds no parameter-specific meaning and fails to connect the 'body' to the 'json' parameter. It does not help the agent understand which parameter is the primary input.

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

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

The description states a clear verb ('check') and resource ('body') and indicates the purpose is JSON validation, which matches the tool name. However, it does not specify which input parameter is the 'body', leaving ambiguity given the 9 parameters in the schema.

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 prerequisites, exclusions, or comparison with sibling tools.

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

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

No annotations are provided, so the description must disclose behavior. It only states the output (current temperature) and the data source (Open-Meteo). It does not mention that many parameters are 'discarded after the shape check' (as hinted in the schema), that it may make network calls, have rate limits, or return different shapes depending on input. This is a significant transparency gap 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 sentence, extremely concise, but it is under-specified rather than efficiently concise. It omits critical information about the tool's multi-purpose nature and usage. The one sentence does not earn its place because it leaves out essential details an agent needs to select and invoke the tool correctly.

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 description is completely inadequate. It only covers the weather use case, ignoring the other input types, and provides no information about return values, error handling, or operational behavior. An agent would be unable to understand the full scope of the tool and would likely misuse it.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no extra parameter meaning beyond mentioning 'city' for weather. It does not explain the purpose of the other 8 parameters or how they relate to the tool's behavior, but since the schema already documents them individually, the description does not need to repeat them. It adds minimal value over 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 verb+resource (current temperature for a city via Open-Meteo), which is clear for the weather use case. However, the input schema exposes 9 unrelated parameters (ref, url, feed, json, path, etc.), suggesting the tool handles multiple shapes, yet the description only mentions city. This makes it ambiguous whether the tool is exclusively for weather or a general-purpose checker, and it does not distinguish it from sibling hint tools like geo-hint or lib-docs-hint.

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 any preconditions, when not to use it, or how it compares to other sibling tools. The agent is left to infer that it might be useful for weather queries only, but the schema suggests broader applicability, creating confusion.

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 'Body discarded' but does not explain behaviors for the other parameter types (e.g., no disk access for path, discarded after check for json, etc.). It also omits any details about return format, error behavior, or side effects. The schema descriptions provide some of this, but the description itself is inadequate.

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 under-specified. It front-loads the URL aspect but omits critical information about the tool's other capabilities. This is under-specification rather than appropriate conciseness, as the sentences do not earn their place given the tool's complexity.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, the description is drastically incomplete. It does not explain what the tool returns for different input types, what 'shape check' means, or how the various parameters relate to each other. An agent cannot reliably determine correct usage from this 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?

Schema description coverage is 100% because every parameter has a description, so the baseline is 3. The tool description does not add any meaning beyond the schema; it only mentions URL, leaving the other parameters unexplained in the description. However, since the schema already documents each parameter, the description does not need to compensate heavily.

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 (HTTP status and content type for a URL) but the tool accepts nine distinct parameter types (ref, city, feed, json, path, zone, query, etc.). It fails to describe the tool's actual scope as a multi-purpose shape checker, making the purpose incomplete and misleading for non-URL inputs. It does not distinguish from siblings 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?

There is no guidance on when to use this tool versus alternatives. No mention of exclusions, prerequisites, or alternative sibling tools. The description gives no context for choosing web-fetch over fetch-status, normalize-url, or other related 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 supplied, the description carries the full burden of behavioral disclosure. It only states that the 'title' is discarded after the call, but since no parameter is identified as the title, this is confusing. It does not disclose whether the operation is read-only, whether it makes network calls, or what happens on failure, leaving critical behavior 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 concise at two sentences, but it is under-specified rather than efficiently structured. It front-loads the purpose but immediately introduces an undefined 'title' concept without context. There is no logical flow to guide the agent, and the mention of 'discarded' is premature given the ambiguity.

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

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

This tool has 9 parameters, no output schema, and no annotations, yet the description is only one line of actual instruction. It does not explain which parameter is the title, how existence is determined, what the return value indicates, or any edge cases. An agent cannot reliably invoke this tool correctly with the given information, making it severely incomplete.

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

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

The schema provides 100% description coverage for all 9 parameters, so the baseline is 3. The tool description adds no additional meaning to these parameters—it doesn't explain which parameter represents the Wikipedia title or how the parameters interact. The parameter descriptions themselves are generic and unrelated to Wikipedia, so the tool description fails to bridge the 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 clear verb and resource ('Check whether a Wikipedia title exists'), so the basic purpose is discernible. However, it fails to map that purpose to any of the 9 input parameters—none of which is labeled as a title—making it unclear how the tool is actually invoked. It also doesn't distinguish itself from sibling tools like browser-url-ok or domain-shape, which follow similar check-style patterns.

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, and the sibling list includes many similar 'shape' or 'ok' checks, so an agent has no basis to 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.