Language ur

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

With no annotations, the description must carry the behavioral burden. It does disclose two behaviors: 'Returns connection methods' and 'Task text discarded.' However, it does not mention whether external calls are made, whether the 'pay-per-call' aspect incurs cost, or any side effects. This is partial disclosure, not a full behavioral picture.

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

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

The description is three sentences and front-loads the core purpose and return type. The final sentence ('Task text discarded') is a useful warning. It is efficient, though the second sentence could arguably be merged with the first without losing meaning.

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, no output schema, and no annotations. The description is too thin to guide an agent on which parameter to supply for which task and what the returned 'connection methods' look like. It does not explain relationships among params, discard semantics, or how to structure a valid call. This is a significant completeness gap for a multi-parameter tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter-level guidance beyond the schema; it never maps task examples to specific parameters (e.g., weather to city, search to query). It adds no value beyond the schema's own parameter descriptions.

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

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

The description states a specific verb ('Find'), a clear resource ('public pay-per-call tool gateway'), and examples of task types ('weather, search, scrape, or voice'). It also says what is returned ('connection methods'), making the purpose distinct from the many sibling shape-check and hint tools.

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

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

The description gives examples of when to use the tool ('for a task such as weather, search, scrape, or voice') but does not explicitly contrast it with siblings like weather-hint or search-query-len. It implies a use case but provides no exclusions or alternatives, leaving an agent to infer when the gateway lookup is preferred over a direct hint 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 of behavioral disclosure. It only states that no browser is launched, but does not clarify whether network requests are made, what checks are performed, or what side effects occur. The phrase 'can be opened' is vague, and the behavior regarding the unrelated parameters is entirely unexplained.

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 sentences and not verbose, so it earns points for brevity. However, it is so terse that it omits critical context, and the structure does not lead the reader through logical steps. It is acceptable but not exemplary – the minimal length compromises the clarity it should provide.

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. The description supplies only a minimal purpose statement and one behavioral snippet. It fails to explain how the tool processes its many inputs, what the return value represents, or when to invoke it. For an agent to correctly select and call this tool, the description is severely incomplete.

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

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

Schema description coverage is 100%, so the baseline is 3 even with no parameter information in the description. The schema individually documents each parameter, but the description adds no context on how these parameters relate to the tool's purpose. Since the schema is comprehensive, the baseline is appropriate; however, the lack of relational context limits the score to 3.

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 ('check') and a resource ('URL') but the meaning of 'can be opened' is ambiguous – does it imply network reachability, syntactic correctness, or something else? It fails to differentiate from siblings like normalize-url, fetch-status, or playwright-url-ok. The schema's nine unrelated parameters (ref, city, json, path, etc.) further muddy the core purpose, making it unclear what the tool actually does.

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

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

There is zero guidance on when to use this tool versus the many sibling tools (e.g., playwright-url-ok, fetch-status, normalize-url). No preferred use cases, exclusions, or conditions are mentioned. An agent has no basis to choose this tool over 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?

Annotations are absent, so the description must carry full behavioral disclosure. It only says 'Expression discarded' without explaining what happens with any of the nine parameters, side effects, external interactions, or response behavior. This is far below what is needed.

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 atypically short, but it is not truly concise because it omits essential details and does not front-load the key operation. Two vague sentences waste the opportunity to clarify how to call the tool.

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

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

For a tool with 9 optional parameters, no output schema, and zero annotations, this description is absurdly insufficient. The agent gets no insight into the expected inputs, what operation each input triggers, or what happens to these inputs.

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 every parameter, which is already sufficient, so the baseline of 3 applies. However, the description's mention of an 'expression' that does not exist as any parameter creates confusion rather than adding meaning.

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

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

The description gives a specific verb ('Evaluate') and resource ('arithmetic'), but does not connect to any parameter in the schema – there is no 'expression' parameter, making the tool unusable in practice. It is not a tautology, but it is misleading because the schema contains completely unrelated fields.

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 information about when to use this tool instead of siblings, nor any mention of conditions, alternatives, or exclusions. The single sentence provides no context that would help an agent decide whether 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?

Annotations are absent, so the description must bear the full burden of behavioral disclosure. It reveals only that 'Page content is not stored,' but fails to mention side effects, network behavior, failure modes, or how the HTTP status is acquired; the schema's nine parameters and inconsistent 'discarded after' hints increase the 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?

No more than two sentences: the core purpose is front-loaded, and the caveat about storing page content is important and succinct. Every word earns its place, with no filler or redundancy.

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

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

For a parameter with 9 optional fields, no output schema, and no annotations, the two-sentence description is too sparse. It does not explain what the tool returns and whether the ancillary parameters are ignored, which would leave an agent uncertain in which parameters to provide and what the response means.

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%, which sets the baseline at 3. The tool description adds no extra meaning to the parameters, merely referring to 'a URL' without explaining the role of the other eight fields or clarifying that only one may be relevant; it does not compensate for the contradictory 'discarded' cues 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?

States a specific verb and resource: 'Return host, scheme, and HTTP status for a URL.' This is clear and action-oriented. However, it does not explicitly differentiate itself from siblings like fetch-status or normalize-url, which can produce overlapping information, so it falls short of a 5.

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

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

Provides no guidance on when to use this tool versus alternatives. It does not name sibling tools or give criteria such as 'use this when you need only the host/scheme/status and not raw content'; 'Page content is not stored' is a behavioral note, not a usage guideline.

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

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

The description does disclose a meaningful behavioral trait: 'No identifiers are retained.' With no annotations available, this privacy/disposal cue carries real value, but it does not address side effects, auth, network behavior, or what classified output the caller should expect.

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, front-loaded sentences with no filler, and the privacy sentence adds distinct value. It is concise as written, but the first sentence is too vague for the tool's apparent 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?

With 9 heterogeneous optional parameters, no output schema, and no annotations, the description leaves serious gaps: an agent cannot know whether to provide all inputs, only one, or what the returned classification will look like. The schema gives good per-parameter information, but the overall behavior and input grouping remain undefined.

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?

Every parameter has full schema-level descriptions, so the baseline is 3 even though the free-text description adds no per-parameter meaning. It does not explain how the various optional inputs relate to one classification or which should be used together.

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

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

The description says an action ('show how classified') and a resource ('this request'), which is enough to see that this is some kind of classifier, but it never says what classification is produced or what criteria are used. It is vague about purpose and does not distinguish it from the many shape-checking and normalization siblings.

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

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

There is no guidance on when to use this tool versus a sibling such as validate-json, normalize-url, domain-shape, file-path-ok, or git ref checkers. No when-to-use, when-not-to-use, or alternative-selection hint is provided.

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

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

No annotations are present, so the description carries the burden of disclosing behavior. It does disclose one useful limitation—no WHOIS or ownership lookup—and implies a pure string-splitting operation. However, it does not describe the return format, what happens when multiple inputs are provided, or any side effects such as discarded data.

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

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

The description is one short sentence and is front-loaded with the core use. The qualifier 'without WHOIS or ownership data' earns its place because it prevents someone from expecting lookup features. There is no filler or redundancy.

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

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

The tool exposes 9 optional parameters, has no annotations, and has no output schema. The one-line description gives a clear action for one parameter group but not enough context for the agent to know what output to expect, how to handle non-hostname parameters, or how to construct a valid call for the broader intended behavior.

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

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

The input schema already describes all 9 parameters (100% coverage), so the baseline is 3. The description adds almost no parameter-level meaning beyond the word 'hostname', which aligns with the 'host' property but leaves the remaining eight optional parameters unexplained by the tool description.

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

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

The description uses a specific verb and resource: 'Split a hostname into labels' and adds a clarifying boundary ('without WHOIS or ownership data'). It is understandable, but it does not explicitly separate this tool from sibling shape/validation tools, and the nine optional schema parameters make it unclear why so many non-hostname fields exist.

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

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

There is no guidance about when to use this tool instead of a related tool such as normalize-url, web-fetch, file-path-ok, or other shape-focused tools. The phrase 'without ownership data' hints at a limitation rather than a decision rule. An agent cannot tell whether to prefer this tool over 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, the description carries the full burden of behavioral disclosure. It does reveal that the operation is a HEAD request, that the URL must be public, and that only status is returned. It does not disclose redirect behavior, error handling, or the fact that most input parameters are discarded after a check, but the core behavioral profile is clear.

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

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

The description is a single front-loaded sentence with no filler; it efficiently communicates the core operation. It is concise rather than bloated, though it is terse relative to the complexity of the nine-parameter 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?

Given nine optional parameters, no annotations, and no output schema, the one-sentence description is not enough for an agent to confidently invoke the tool. It does not explain how to select among the parameters, what 'status' means in the response, or why non-URL parameters exist.

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 schema already documents all nine optional parameters. The description adds the notion that the tool targets a public URL, which maps to the 'url' parameter, but it does not clarify the role of the many non-URL parameters or which one to prefer.

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 ('HEAD'), a resource ('a public URL'), and an outcome ('return status only'), which makes the core purpose clear and distinguishes it from content-fetching siblings like web-fetch. However, it does not explicitly name any sibling or address why the schema contains many non-URL parameters, so it stops short of full 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?

'Return status only' implies the tool is for lightweight availability/status checks rather than fetching content, giving some usage context. But there is no explicit when-to-use/when-not-to-use guidance or mention of alternatives such as browser-url-ok or web-fetch.

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 behavioral burden. It only says 'Parse a Figma file URL' and 'Path discarded' but does not disclose whether the tool is read-only, whether it validates the URL syntax or fetches it, what it does with the other 8 schema parameters, or what the return value looks like. This is a significant transparency 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 exceptionally concise (two short sentences) and front-loads the core action. There is no fluff. However, it is so short that it borders on incomplete, but for conciseness alone it earns a 4.

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 completely inadequate. It does not explain the purpose of the other parameters, the expected input format, any side effects, or the output shape. Essential information for correct invocation is entirely missing.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds no value beyond the schema. It only mentions 'URL', while the schema lists 9 independent parameters. The description fails to clarify whether the other parameters are used, ignored, or required, creating confusion instead of adding 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 specific action ('Parse a Figma file URL') and resource, which is clear and not a tautology. It also distinguishes from siblings like 'domain-shape' by naming Figma explicitly. However, the meaning of 'shape' and what parsing entails is left vague, and the note 'Path discarded' is ambiguous without further context.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of related tools, prerequisites, or exclusions. The description gives zero 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, the description must disclose all behaviors. It only states 'No disk access' for path, which is a useful safety note, but it fails to mention that other parameters are discarded after checks (as shown in schema descriptions) or what 'safe' means or the return value. The behavior around the other 8 parameters is entirely undisclosed.

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 short sentences with no filler—and front-loads the primary purpose. However, it is too sparse for a tool with 9 parameters and no other explanatory context, sacrificing completeness for brevity. It earns a middle score because it is efficient but 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?

This is a 9-parameter tool with no output schema, no annotations, and only a two-sentence description that addresses one parameter. The agent cannot determine how to invoke it correctly for the other 8 parameters, what results to expect, or how it differs from many similarly named shape-checking siblings. The description is grossly 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 for parameter semantics is 3. However, the tool description incorrectly focuses solely on 'path', while the schema reveals a multi-purpose checker. The description adds no meaning beyond the schema and actually misrepresents the scope by omitting the other parameters' roles, requiring the agent to infer their purpose from schema alone.

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

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

The description states a clear verb and resource ('Check whether a path looks safe'), which distinguishes it from sibling path-related tools. However, the input schema includes 8 additional parameters (ref, url, city, feed, host, json, zone, query) that are not path-related and are not mentioned in the description, making the tool's actual purpose ambiguous 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 other shape-checking siblings like browser-url-ok, domain-shape, or validate-json. The description does not mention alternatives, conditions, or exclusions, leaving the agent to infer usage from the name and schema 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?

With no annotations provided, the description carries the full burden of disclosing behavior. It only states what the tool returns ('latitude and longitude'), but does not explain side effects (e.g., network calls to Open-Meteo), whether any parameters are ignored or discarded, or what happens when multiple parameters are supplied. The parameter descriptions in the schema mention discarding, but the tool description itself adds no behavioral context.

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

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

The description is a single sentence that gets straight to the point. It is efficient and free of fluff, earning high marks for conciseness. However, it is so minimal that it lacks explanatory depth, which slightly detracts from structure but overall still reads cleanly.

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 optional parameters, no output schema, and no annotations, this description is drastically under-specified. It does not explain how the parameters combine, which ones are required for a successful call, what the response format is, or how it relates to sibling tools. The agent would have to guess or rely entirely on the schema, which is not sufficient for correct invocation.

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

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

Schema description coverage is 100%, so each parameter already has a clear description. The tool description does not add any meaning beyond the schema—it does not explain how parameters like 'city' or 'query' map to the place being geocoded. The baseline of 3 applies because the schema is well-documented, but the description fails to synergize with 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 clear goal—returning latitude and longitude for a place via Open-Meteo—but it does not specify which of the nine parameters identifies the place. It is distinct from siblings like weather-hint in that it returns coordinates, but the link between the described purpose and the actual parameters is missing.

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

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

There is no guidance on when to use this tool versus alternatives such as weather-hint or timezone. The description does not mention any context, prerequisites, or exclusions, leaving the agent to infer proper usage from the parameter schema alone, which is 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'parse' but does not explain what happens to the nine optional parameters (e.g., city, zone, json), whether they are ignored, or what the return value is. The broad schema and narrow description leave significant misalignment and uncertainty.

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

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

The description is a single short sentence that is concise and front-loaded, but it lacks the supporting details necessary for a tool with a broad, overloaded schema. The brevity undermines its helpfulness despite the clean phrasing.

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

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

Given a schema with nine optional parameters spanning many domains, no output schema, and no annotations, the description is dramatically insufficient. An agent has no idea whether to pass a city, zone, JSON text, etc., and what the tool actually returns in each case.

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

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

The schema already provides descriptions for all nine parameters, so baseline is 3. The tool description adds slight specificity for the URL parameter (GitHub URL, owner/repo) but provides no additional meaning for the other eight 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 and target: 'Parse owner and repo from a GitHub URL.' This clearly differentiates it from sibling shape tools like figma-url-shape or jira-key-shape by naming the exact resource (GitHub) and the derived output.

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

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

The description implies the tool should be used when a GitHub URL needs owner/repo extraction, but it provides no explicit when-not guidance or alternatives. An agent must infer the correct sibling because the description does not mention exclusions or conditions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals one behavior ('Titles discarded') and implies a read-only count, but it does not state whether live data is fetched, whether a feed URL is required, what happens on failure, or whether any inputs are ignored.

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 the action front-loaded. 'Titles discarded' adds a behavioral detail without wasted words, though the brevity omits important usage and parameter 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?

The tool has 9 optional parameters, no output schema, and no annotations, yet the description does not specify which parameter to provide, what the return value looks like, or when to use the tool. An agent cannot confidently invoke it correctly based solely on 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%, so the baseline is 3. Each parameter has a meaningful description, and 'feed' even mentions 'titles discarded,' which echoes the tool description. However, the tool description itself does not explain which parameter is relevant to the HN count or how the nine optional parameters relate 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 specific verb ('Count') and resource ('current Hacker News front-page stories'), so an agent can tell what the tool does. However, it does not explicitly distinguish this from sibling tools like web-fetch or fetch-status, and 'Titles discarded' is cryptic without additional context.

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

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

There is no guidance on when to use this tool versus alternatives such as web-fetch, fetch-status, or browser-url-ok. No exclusions, prerequisites, or alternative tool names are mentioned, leaving the agent to infer usage from the tool name alone.

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

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

With no annotations, this description carries the full disclosure burden, but it only names the output domain. It does not state that it likely returns a list, whether it takes input parameters seriously, or whether the many 'discarded' schema parameters actually affect the call. The behavioral profile beyond purpose is mostly unknown.

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

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

The description is a single, front-loaded sentence that names the exact purpose with no filler or dead weight. It is appropriately sized for the simple idea being conveyed.

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

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

Despite having 9 parameters and no output schema, the description gives only a one-line purpose. It leaves agents without knowledge of the return shape, what actions the parameters trigger, or how a caller should treat the discarded fields. More is needed for confident invocation.

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

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

Schema coverage is 100% with each parameter already having a clear description, so the baseline is 3. The tool description itself adds no meaning about the parameters, but the schema fully documents them, so no penalty beyond baseline is needed.

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 resource (Common IANA timezone names) and purpose (for clock calls), making the tool's intent understandable. However, it does not explicitly distinguish itself from siblings like 'timezone' or 'utc-time', so it stops short of full 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?

There is no guidance about when to use this tool instead of other timezone-related siblings or alternatives. No context, prerequisites, or exclusions are provided, leaving agents to infer the right invocation scenario.

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 states a read-only network fetch and a restricted output, but it does not disclose which parameter supplies the robots.txt URL, failure modes, rate limits, or what 'group counts' means. It also does not mention that many schema parameters appear to be discarded or unrelated.

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 is concise and readable. However, it is under-specified for a tool with 9 parameters, so it does not earn a 5.

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 optional parameters, no annotations, and no output schema—the description is not complete enough. It fails to identify the relevant input parameter, explain the return format of 'group counts', or clarify behavior when multiple parameters are supplied. An agent would struggle to 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%, which normally sets a baseline of 3, but the schema descriptions describe unrelated operations such as normalizing URLs, weather hints, timezone names, and search-length checks. The description does not map any parameter to the robots.txt URL. With 9 optional parameters and no required ones, 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 uses a specific verb ('Fetch'), a specific resource ('public robots.txt'), and a precise output ('return group counts only'). This clearly distinguishes it from generic fetch tools like web-fetch or fetch-status and from shape-check siblings.

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

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

There is no guidance about when to use this tool versus alternatives such as web-fetch, fetch-status, or domain-shape. No exclusions, conditions, or alternative tool names are mentioned. The only implied usage is 'public robots.txt', but that is not enough to route an agent 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?

The description notes the input is discarded, which is a minimal behavioral disclosure. With no annotations provided, it fails to state what happens on success/failure, whether external access occurs, or any side effects, leaving the agent guessing about the tool's behavior.

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

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

The description is extremely concise (two short sentences), which is structurally clean, but it omits critical information needed to use the tool. It is under-specified rather than appropriately brief, so the conciseness is counterproductive.

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 provides almost no contextual guidance. It does not identify the key parameter, explain return values, or indicate how to construct a valid call, making it grossly inadequate for correct invocation.

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

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

Schema descriptions cover all 9 parameters, but none of them reference a Jira key. The main description adds no mapping between the stated purpose and the actual parameters, so an agent cannot infer which parameter to pass or how the parameters relate to the key shape check.

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

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

The description states a clear purpose: checking the shape of a Jira issue key. However, it does not indicate which of the 9 schema parameters carries the Jira key, making the purpose ambiguous in practice. It also fails to differentiate from sibling shape-checkers like github-repo-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?

No guidance on when to use this tool versus alternatives. The phrase 'Key discarded' hints at a non-persistent check, but does not specify conditions for use or exclusions relative to sibling shape 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 carry the burden of disclosing side effects, permissions, or processing details. The description says nothing about what happens when the tool is called, whether it modifies state, or what the response looks like. It is 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?

While extremely short, this is under-specification rather than efficient conciseness. The single phrase provides no structure, no front-loaded purpose, and no information beyond the tool's name. It fails to earn its place as a useful signal.

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, no annotations, and a cryptic description, the tool is severely under-documented. An agent cannot infer the expected input format, the tool's behavior, or what result to expect. The description is wholly insufficient 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 all nine parameters are individually documented in the schema. The description adds no parameter meaning whatsoever, but per guidelines a baseline of 3 is warranted when the schema covers all parameters. No contradiction or missing param info 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 'ISO 639 language tag ur.' merely restates the tool name and provides no verb or resource. It does not state what operation the tool performs, what it returns, or how it relates to the nine heterogeneous parameters. This is a tautology and fails to distinguish it from any other 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 zero guidance on when to use this tool versus the 27 siblings. No mention of when this tool is appropriate, what problem it solves, or any exclusion criteria. An agent cannot determine why to call this instead of 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, the description must fully disclose behavioral traits. It only states that the tool returns an HTTP status and discards the body, which implies a read-only HEAD-like operation. However, it does not explain side effects (e.g., network access, rate limits, auth requirements), nor the behavior when non-URL parameters like city or json are provided. The description is severely lacking in transparency for a tool that appears to handle diverse input types.

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 clear sentence with no filler, which is concise and front-loaded. However, it is under-specified for a tool with 9 parameters and no other context. While brevity is a virtue, the sentence omits crucial information about the parameters and usage, making it insufficient. It earns a pass for being short, but the structure lacks the 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 tool's complexity (9 parameters, no output schema, no annotations, and 28 siblings), the description is grossly incomplete. It does not explain how the parameters map to the operation, what the return value looks like (only 'HTTP status'), any error behavior, or how this tool integrates with the broader tool ecosystem. An agent cannot reliably select or invoke this tool based on the provided 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?

The schema already covers 100% of parameters with descriptions, so the baseline is 3. However, the tool description does not add meaning beyond the schema; instead, it creates confusion by focusing on a 'public library docs URL' while the parameters include unrelated fields like city, feed, json, and zone. The schema descriptions themselves are terse ('discarded after the shape check'), and the tool description does nothing to clarify how these parameters relate to the stated operation. The description actually weakens the semantic understanding, dropping 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 specific action (return HTTP status) for a specific resource (public library docs URL), which provides some initial clarity. However, the tool name 'lib-docs-hint' and the description do not align with the 9 parameters, many of which are unrelated to a library docs URL (e.g., city, feed, json, zone, query). This makes the actual purpose ambiguous and fails to distinguish the tool from siblings like fetch-status or browser-url-ok, which also handle URLs. The description is too narrow and misleading relative to the parameter set.

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

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

No usage guidance is provided. The description does not mention when to use this tool versus any of its 28 siblings, nor does it specify any conditions or prerequisites. An agent is left to guess when this tool is appropriate and how it differs from tools like fetch-status, normalize-url, or web-fetch.

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 does say that values are discarded, but it does not say whether the operation is read-only, whether data persists, or what the exact output form is beyond a count.

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

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

The description is short, front-loaded, and contains no filler. Every sentence has a clear purpose, though naming the relevant input parameter would improve its 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?

The tool has nine optional parameters, no output schema, and no annotations, but the description is too thin to explain what argument to use or what the return value looks like. An agent cannot reliably know how to invoke this tool from 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 does not clarify which parameter holds the JSON object or how the count should be supplied, adding no parameter-level meaning beyond the schema.

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

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

The description states a specific operation: count keys in a JSON object and discard values. It makes the tool distinct from a validator like validate-json, though it does not identify which of the nine parameters contains the JSON object.

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

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

No guidance is given about when to use this tool rather than a sibling, or what kind of request it is meant for. The description only states what it does, not in what situation it should be selected.

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 the main behavior: returns origin, host, and path, and drops query and fragment. However, it does not explain the fate of the many other schema parameters (which are described in the schema as 'discarded after the shape check'), nor does it address error handling, invalid URLs, or output format. The disclosed behavior is clear but incomplete 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 a single, tight sentence with no fluff. It is front-loaded with the action and outcome. However, it may be too terse given the schema's complexity, but it is not verbose or repetitive. It earns a 4 for efficient 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?

The tool has 9 parameters, no annotations, and no output schema. The description only addresses URL normalization, leaving the other parameters unexplained in context. It does not specify output shape, stepping through the extra params, or any prerequisites. This is insufficient for an agent to use the tool correctly across its full surface area.

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 adds the context that the 'url' parameter is the primary input and that the output focuses on origin, host, and path. It does not clarify how the other parameters are used or whether they are alternative inputs, which could lead to confusion. The description adds minimal value beyond the schema.

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

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

The description clearly states a specific verb ('return') and resource ('URL'), and specifies exactly what is returned (origin, host, path) and what is dropped (query, fragment). It is distinct from the many sibling tools, though it does not explicitly differentiate itself from them. It effectively communicates the core function.

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., browser-url-ok, figma-url-shape, github-repo-shape). No conditions, exclusions, or alternatives are mentioned. An agent would have to infer from the name and description alone, which is insufficient given the crowded toolset.

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 behavioral burden. It discloses one fact, that no browser is launched, but says nothing about whether network/HTTP requests are made, what kind of response is returned, or what side effects could occur. That is not enough transparency for a network-checking tool.

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

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

The description is short and front-loaded: the main verb and object appear in the first sentence, and the second sentence adds a meaningful distinguishing behavior. It is efficiently written, though slightly over-terse for the complexity of the tool 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?

With 9 optional parameters, no output schema, and no annotations, this one-line description is not complete enough. It does not explain what the tool returns, which parameters are needed, whether parameters function independently, or what happens when non-URL inputs such as json, city, or zone are provided.

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 across all 9 parameters, so the baseline is 3 even though the description itself adds no parameter-level meaning. The description does not explain how to choose among the 9 optional params or whether they are alternatives, so no higher score is justified.

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 concrete action ('check') and a concrete resource ('URL'), and the qualifier 'No browser is launched' helps distinguish it from a browser-based check. It does not explicitly name or contrast sibling tools, so it misses a little differentiation, but the core purpose is 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?

There is no explicit when-to-use guidance and no mention of sibling tools such as browser-url-ok, web-fetch, or fetch-status. 'No browser is launched' is more of a behavioral fact than a routing instruction, so the agent is left to guess which tool to choose.

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 query is discarded, which is a minor detail. It does not state whether the tool has side effects, requires permissions, has rate limits, or what it returns. For a tool with 9 parameters, this is a significant gap.

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

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

The description is extremely concise (one sentence), but given the tool's complexity (9 parameters), it is under-specified rather than appropriately concise. It front-loads the primary purpose but lacks any structure or explanation for the non-query inputs, making it 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?

Without an output schema, the description should explain return values, but it doesn't. It also fails to reconcile the mismatch between the narrow description and the broad schema, leaving an agent unsure how to invoke the tool correctly beyond passing a query. The tool seems over-engineered for a simple length check, and the description does not address this.

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, but the description adds no value beyond the schema. It repeats the query discard behavior already in the schema and does not clarify the purpose of the other 8 parameters. An agent cannot determine why url, city, etc., are accepted, or whether they affect the length calculation.

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 – counting characters in a search query – but the input schema lists 9 unrelated optional parameters (url, city, feed, etc.) with no explanation. This makes the tool's actual scope ambiguous; an agent cannot tell if the other fields are ignored, validated, or used for something else. It distinguishes from siblings by focusing on query length, but the schema suggests a broader purpose not reflected in the description.

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 use case (measuring search query length) but provides no explicit guidance on when to use this tool versus alternatives like memory-key-count or hn-front-count, and no exclusions. The context is minimal and leaves selection to 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It only labels the tool as a catalog; it does not state what happens when a parameter is supplied, what is returned, or whether any side effects occur.

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 with no wasted text, but the single sentence is under-specified and gives no actionable structure. It is short, yet does not effectively front-load the information an agent needs.

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

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

The tool has 9 parameters, no output schema, and no annotations, yet the description only states that it is a catalog of HTTP codes. It does not explain how the inputs map to the purpose, what output to expect, or how to issue a correct call.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description itself adds no parameter-related meaning, but each parameter's schema description contains its own semantics, including discard/check behavior.

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 ('Short catalog of common HTTP status codes') rather than an actionable statement with a verb. It gives the resource but not the operation, and is essentially a restatement of the tool's name. The 9 heterogeneous parameters are not connected to this purpose.

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

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

No guidance is given on when to use this tool versus alternatives like fetch-status or browser-url-ok. With 9 different input flavors and several sibling tools, an agent has no signal to select between them.

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 states the prompt is discarded and that parameters are 'discarded after' checks, implying no persistent effects, but it doesn't clarify what the tool does with the inputs, whether it makes network calls, or what the output structure looks like.

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, but in this case brevity under-specifies rather than adds value. One sentence leaves the agent without enough information to decide on invocation.

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

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

Given 9 optional parameters and no output schema, the description is far too thin. The agent cannot tell what the 'three-step thinking template' is for, how inputs map to it, or what it returns. The note that the prompt is discarded leaves the tool's actual function nearly opaque.

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 almost nothing about the parameters, but 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 says the tool 'Return a three-step thinking template' and that the prompt is discarded. This makes it unclear whether the tool actually does anything useful or is a stub. 'Return a three-step thinking template' names a deliverable but gives no indication of what the template contains or why an agent would call 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?

No guidance is given on when to use this tool versus the 27 siblings. The description explicitly states the input prompt is discarded, which suggests the tool does not process the prompt, but it doesn't explain when an agent should invoke it or what problem it solves.

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

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

With no annotations, the description carries the full burden, but it only states the simple behavior of returning current time. It does not mention error handling for invalid zone names, output format, or that only the 'zone' parameter is used while others are ignored (though the schema descriptions note discarding).

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 no filler. It is appropriately sized for the tool's simplicity and wastes no words.

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

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

The description is complete for a simple timezone lookup, and the schema fully documents parameters, including noting that irrelevant ones are discarded. However, it does not describe the output format or edge cases, and the abundance of unrelated optional parameters could confuse an agent without the schema's discarding notes. Overall adequate but with minor gaps.

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

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

Schema description coverage is 100%, with each of the 9 parameters having a description, including 'zone' as IANA timezone name. The description itself adds no extra meaning beyond what the schema provides. Baseline of 3 is appropriate since schema handles the semantics, though the description does not highlight that only 'zone' matters.

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' is a clear verb-resource pair that states exactly what the tool does. It distinguishes from siblings like utc-time (which likely returns UTC) and iana-zones (which lists zones), focusing on a specific named timezone lookup.

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

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

No guidance is provided on when to use this tool versus alternatives such as utc-time or iana-zones. There is no mention of when-not, prerequisites, or typical scenarios. An agent must infer usage from the description 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?

With no annotations, the description carries the behavioral burden, but it only states the output. It does not disclose that the nine optional parameters appear to be ignored/discarded, that no arguments are needed, or what output format is returned. It at least implies a read-only operation and is 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?

Single sentence with zero filler and the core purpose front-loaded. For a simple tool it is appropriately concise, though completeness issues are captured elsewhere.

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 9 optional parameters and no output schema, the description does not explain the output format, whether any parameter is ever needed, or how this tool relates to siblings. An agent cannot tell whether passing zone, url, or query changes behavior.

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

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

Schema description coverage is 100%, so the schema already documents every parameter; baseline is 3. The description adds no parameter meaning and does not clarify whether parameters such as zone affect the result.

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

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

The phrase 'Current UTC timestamp' clearly identifies the tool's output as the present UTC time. It is not a tautology, though it lacks an explicit verb like 'returns' and does not differentiate it from sibling tools such as timezone or iana-zones.

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

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

No guidance is provided about when to use this tool versus timezone/iana-zones, or when not to use it. The description gives no alternatives, exclusions, or 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, the description carries the full burden of disclosure. It does state 'The body is discarded,' which is a behavioral note about side effects. However, it does not mention whether the operation is read-only, what happens on success or failure, or how the other parameters behave. The parameter descriptions hint that each is discarded, but the tool description itself gives almost no behavioral context beyond the single sentence.

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, compact sentence that front-loads the primary purpose and includes a note about disposal. It wastes no words and is easy to parse. However, it is arguably too terse given the tool's complexity, potentially sacrificing completeness for brevity, but that is more a completeness issue than a structure issue. The sentence is well-formed and efficient.

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

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

The tool has nine parameters, no required parameters, and no output schema, making it quite complex. The description only addresses JSON validation and ignores the other eight parameters entirely. It does not explain when to pass a URL, a city, a feed, etc., or what the tool does with them. There is no indication of return values or error behavior. This is grossly insufficient for an agent to use the tool correctly beyond a trivial JSON check.

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 in detail. The description does not add extra meaning about parameter usage or relationships; it only refers to 'the body,' which loosely maps to the 'json' parameter. It does not clarify how multiple parameters interact or which parameter should be used for what scenario. Baseline 3 is appropriate because the schema is comprehensive, but the description adds marginal value.

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

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

The description states a clear verb and resource: 'Check whether a body is valid JSON.' That is specific and unambiguous for the JSON use case. However, the input schema exposes nine unrelated optional parameters (url, city, feed, host, path, zone, query) each with its own validation purpose, which strongly implies the tool may validate more than JSON. The description does not acknowledge this broader role, so it partially undermines clarity about what the tool actually does beyond 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?

The description provides no guidance on when to use this tool versus the many sibling validators (e.g., browser-url-ok, normalize-url, weather-hint). It does not state that this tool is for JSON only, nor does it mention that other parameters are alternative validation modes. An agent cannot infer when to select validate-json over a sibling based on this description 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 of disclosing behavior. It mentions Open-Meteo but does not describe network calls, side effects, error behavior, or what happens when the city is unknown. There is no contradiction, but behavior is largely undisclosed.

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 and clearly communicates the core function. It is well-structured and easy to parse, though the parameter schema is much larger than the description implies.

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

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

There is no output schema, no required parameters, and no description of return format, units, or failure modes. An agent would not know what to pass or what to expect, making the tool incomplete for reliable invocation.

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

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

Although every parameter has a description, the schema contains nine optional parameters, many of which are irrelevant to weather (ref, url, feed, host, json, path, zone, query). The city parameter is described as 'discarded after the call,' which is confusing and undermines its role as the apparent input for the tool.

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

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

The description clearly states the tool's purpose: returning current temperature for a city using Open-Meteo. It is distinguishable from sibling tools like timezone, geo-hint, and web-fetch, even though it does not explicitly name those alternatives.

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 weather-hint versus other tools, nor any context about required inputs or expected call patterns. The single sentence is informative about what it does but not about how or when to invoke it.

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

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

No annotations are provided, so the description bears the full burden. It does disclose the core fetch behavior — returns HTTP status and content type, discards the body — which is genuinely useful. But it hides that the tool accepts 8 other input types (ref, city, zone, json, path, query, feed, host), each described in the schema as checked and discarded, revealing a far broader shape-validation role than the description implies.

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 no filler, front-loaded around the primary outcome. Textually efficient, though the brevity purchases clarity for the URL case at the expense of five-sixths of the 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?

For a tool with 9 parameters, no annotations, and no output schema, a single line about URL status is grossly insufficient. It omits the behavior for the eight non-URL parameters, return format beyond 'status and content type,' and error semantics. An agent cannot infer how to exercise the city, zone, json, or path inputs from this description.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds mild value by clarifying expected output for a URL input (status and content type, body discarded), but it never explains how the other eight parameters relate to the tool or what they return. The schema descriptions carry the real semantic weight.

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 output verb+resource — HTTP status and content type for a public URL, body discarded — which is clear on its face. However, it describes only one of nine schema parameters; the schema covers git refs, cities, timezones, JSON, file paths, and query text, implying the tool actually validates many input shapes. It also doesn't distinguish itself from overlapping URL 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?

No guidance on when to use this tool versus alternatives. Overlapping siblings (fetch-status, browser-url-ok, playwright-url-ok) are never referenced. The only implicit signal is 'Body discarded,' hinting it suits status/content-type checks rather than content extraction, but this is left entirely to 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?

The line 'Title discarded after the call' is an attempt at data-handling transparency, but with no annotations the description must carry more weight. It never says what the result is, whether a network lookup occurs, or what failure/absence means, so the behavior is under-described.

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, with no wasted words, so it is concise. However, the second sentence says only 'Title discarded after the call' and does not earn the deiconstrued in strictly useful meaning; it introduces a term not present in the 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?

With nine optional parameters, no output schema, and no annotations, the description is far too thin for an agent to invoke the tool correctly. It does not say which blob should contain the Wikipedia title, how success is returned, or what 'discarded' does in about what the tool returns.

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 contains nine optional string fields but no 'title' property. The description refers to a 'Wikipedia title' and says it is discarded, but gives no mapping from that concept to any schema property, leaving the agent without a correct parameter to populate. This is misleading when paired with 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 operation ('Check whether a Wikipedia title exists') and names a distinct resource ('Wikipedia title'), which makes the tool's intent clear. It does not explicitly contrast with sibling validators, but the resource is enough to separate it from file/URL/domain checks.

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

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

There is no guidance about when to use this tool versus the many sibling shape/check tools, and no explicit 'when not to use'. The description only implies its use for testing title existence, without saying how that differs from URL validation or generic lookup tools.

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