Europe/Vatican clock

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It mentions that 'Task text discarded' but does not clarify whether the tool makes external network calls, whether it is read-only, or what side effects might occur. The statement about returning CLI setup and hops suggests some external lookup but leaves the mechanism unclear.

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

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

The description is two sentences long, front-loaded with the primary purpose, and avoids fluff. It efficiently conveys the core action and expected outputs. The note 'Task text discarded' is a small but relevant addition. It is concise without sacrificing essential information.

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

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

For a tool with 9 optional parameters and no output schema, the description is insufficient. It does not explain how the parameters relate to the task, what 'Monid' is, or how an agent should construct a valid call. The returned items are listed but not described in a way that helps an agent use the results. The description leaves too much room for misinterpretation.

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 9 parameters are documented in the schema. The tool description adds no parameter-specific meaning, but the baseline of 3 applies because the schema already covers parameter semantics. The description does not clarify which parameters are relevant for the 'find' operation, but it does not conflict 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 verb ('Find'), a specific resource ('public pay-per-call tool gateway (Monid)'), and lists the returned items. It clearly distinguishes from sibling tools that handle URL checks, validation, or citations. However, the term 'agent-tool-index' is somewhat ambiguous and the description could be clearer about what 'index' implies.

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

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

No guidance is given on when to use this tool versus alternatives. There are no explicit 'use when' conditions, no exclusions, and no mention of which sibling tools might be more appropriate. The description is purely declarative without context for selection.

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

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

With no annotations, the description bears full responsibility for disclosing behavior. It reveals one useful trait ('No browser is launched') but leaves fundamental questions unanswered: what does 'can be opened' actually verify (syntax, DNS, HTTP response)? It does not mention network usage, side effects, or what is discarded versus returned.

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 states the core action and the key non-behavior in just eight words, every one of which earns its place.

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

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

For a tool with 8 parameters, no output schema, and no annotations, this description is inadequate. It fails to clarify which parameters are relevant, what the function returns (e.g., boolean, status), and how this check differs from overlapping siblings like normalize-url or fetch-status. The description alone would not let an agent reliably select and invoke this tool.

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

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

The input schema provides descriptions for all 8 parameters, giving high schema coverage. The description itself adds no parameter-level meaning, but the baseline remains 3 because the schema already documents each field. The description's silence on how parameters like 'city' or 'json' relate to a URL check is a gap, but it does not lower the score below the coverage-based 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 verb ('Check') and resource ('whether a URL can be opened'), and the clause 'No browser is launched' differentiates it from browser-launching tools like playwright-url-ok. It does not explicitly name siblings or clarify the full scope, so it is clear but not maximally distinguishing.

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

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

The description implies the tool is for lightweight URL checks without browser launch, but it provides no explicit when-to-use guidance, no exclusions, and no mention of alternatives among the many sibling tools (normalize-url, fetch-status, web-fetch). Agents would have to infer the appropriate 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 carry all behavioral disclosure. It merely states 'Expression discarded', which is inaccurate since no expression parameter exists. It does not explain that all parameters are validated and discarded, nor what the tool actually does with them. The description is not only unhelpful but actively misleading.

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

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

The description is extremely short (one sentence), but brevity here is under-specification rather than effective conciseness. The content is misleading and does not front-load any useful information about the tool's real purpose or behavior.

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

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

For a tool with 9 parameters, no output schema, and no annotations, the description is completely inadequate. It does not explain the tool's actual function, return value, side effects, or when to use it. An agent would be entirely unable to call it correctly based on the description alone.

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

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

Although the schema has 100% description coverage for each parameter, the tool description adds no meaningful semantic context. It does not reference any of the actual parameters, and the mention of 'a+b style arithmetic' is unrelated to them. The description fails to clarify how parameters relate to the tool's function, instead introducing confusion.

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

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

The description claims the tool evaluates 'a+b style arithmetic', but the input schema contains no arithmetic expression parameter – instead it lists nine unrelated string fields (ref, url, city, feed, host, json, path, zone, query) that are all discarded after validation. The stated purpose directly contradicts the actual tool behavior inferred from the schema, making it misleading.

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

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

No guidance is provided on when to use this tool versus its siblings. There is no mention of contexts, exclusions, or alternatives. An agent would have no idea from the description that this tool is apparently for shape-checking various string formats.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that page content is not stored, which is a useful privacy note, but it does not mention whether network requests are made, whether the operation is read-only, or any side effects. The tool's schema includes many parameters that are 'discarded' after checks, but the description gives no context for these, leaving significant behavioral ambiguity.

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

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

The description is two sentences with no wasted words. The primary function is front-loaded in the first sentence, and the second sentence provides a concise behavioral note. It is appropriately sized and efficiently structured.

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

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

The tool has 9 parameters, no output schema, and no annotations, yet the description only addresses a URL-centric function. It does not explain the purpose of the many other parameters (city, feed, json, path, etc.), nor does it describe the return format or any prerequisites. For a tool with such complexity, this description is incomplete and leaves the agent without sufficient context to use it correctly.

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

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

The schema description coverage is 100%, so each parameter is already documented with its own description. The tool description adds no additional parameter semantics beyond what the schema provides. The baseline is 3 given high coverage, and since the description does not elaborate on any parameter, it does not exceed that 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 host, scheme, and HTTP status') and a specific resource (a URL). This is clear, but it does not differentiate the tool from siblings like fetch-status or normalize-url, which could perform overlapping functions. The purpose is unambiguous, yet the lack of any comparison to alternative tools lowers the score from 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?

There is no guidance on when to use this tool versus alternatives. The description does not mention any conditions, exclusions, or scenarios where this tool is preferred. It simply states what it does, leaving the agent to infer usage without support.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'No identifiers are retained' but does not clarify whether the operation is read-only, whether it requires authentication, what side effects exist, or what the output looks like. The safety profile is only partially disclosed via the 'discarded' notes in the schema, not the description itself.

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

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

The description is only one sentence, which is concise, but it is under-specified rather than efficiently informative. It front-loads the main phrase but leaves out essential context. It is not verbose, but the brevity works against clarity, making it minimally acceptable.

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

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

This is a 9-parameter tool with no output schema and no annotations. The description provides almost no context about what the tool does, how it processes these heterogeneous inputs, or what the classification result looks like. An agent cannot reliably invoke it correctly without additional documentation. This is critically incomplete for the tool's complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema already documents each parameter with specifics like 'discarded after the shape check' or 'no disk access'. The description adds no additional meaning beyond the schema, so it does not exceed the 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 'Show how this request is classified' is vague—it never specifies what 'request' refers to, what 'classified' means, or what resource/operation is involved. It does not distinguish itself from sibling tools like 'validate-json' or 'domain-shape', which have clear verbs and resources. It is not a pure tautology but fails to convey a concrete purpose.

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

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

There is no guidance on when to use this tool versus alternatives. The description mentions no conditions, prerequisites, or exclusions. Given the large sibling set (e.g., 'fetch-status', 'validate-json', 'normalize-url'), the absence of routing guidance leaves the agent guessing.

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

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

No annotations are provided, so the description must disclose behavior. It only mentions hostname splitting and ignores the other input types. It does not state that inputs are discarded, that no disk access occurs for paths, or any side effects. The description is silent on nearly all behavioral aspects, making it severely inadequate.

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

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

The description is one short sentence, which is concise, but it is so under-specified that it fails to convey the tool's true scope. While there is no wasted wording, the content is misleading and incomplete, so the efficiency is not helpful.

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

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

With 9 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain how the tool processes the various inputs, what 'shape' means for each type, or what output or behavior to expect. An agent cannot safely invoke this tool based on the given 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?

The schema descriptions cover each parameter fully, so the baseline is 3. However, the tool description actively misleads by implying only hostname is relevant, while the parameters include weather, JSON, paths, etc. This adds negative value and undermines the schema's clarity. It does not explain how the different parameters relate to the stated 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 claims the tool splits a hostname into labels, but the schema accepts 9 different parameter types including city, JSON, path, timezone, and query. This narrow purpose misrepresents the tool's actual scope, so an agent cannot correctly understand what the tool does. It does state a specific verb and resource, but the mismatch with the schema makes it misleading.

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

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

There is no guidance on when to use this tool versus its many siblings (e.g., normalize-url, validate-json, geo-hint). The description offers no conditions or alternatives, leaving an agent without any basis to select it appropriately.

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

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

The description discloses the HTTP method (HEAD) and the limited return value (status only), which is meaningful behavioral context. With no annotations present, it still does not cover edge behaviors such as redirects, timeouts, authentication needs, or how non-URL parameters are treated.

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 names the action, target, and result immediately; every word earns its place.

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

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

Despite being a simple-looking statement, the tool has no annotations, no output schema, and a multi-parameter input schema that conflicts with the URL-only description. An agent cannot confidently determine requiredness or how to treat the extra parameters, so the description is not complete enough 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?

All seven parameters already carry schema-level descriptions, so schema coverage is high and the description does not need to re-document them. The description adds only the 'public URL' framing, but it does not clarify which parameter should be passed for the stated operation or why the other parameters exist, which is a real gap.

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

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

The description uses a specific verb and resource ('HEAD a public URL') and states the output ('status only'), so the core action is recognizable. However, the input schema exposes seven unrelated-looking parameters (ref, city, feed, host, json, path), and the description never reconciles those with the URL-only operation, making the tool's actual purpose harder to trust.

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?

'Status only' implies this is for cases where headers/status are sufficient and content is not needed, but the description never explicitly says when to choose this over siblings like web-fetch, browser-url-ok, or playwright-url-ok. No alternatives or exclusions are named, so usage is only implied.

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

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

The only disclosed behavior is 'Path discarded,' which is vague and does not map clearly to any specific parameter. With no annotations provided, the description carries the full burden of behavioral disclosure, and it fails to explain side effects, return values, or how the tool handles its nine optional parameters. The minimal disclosure is insufficient for an agent to predict behavior.

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

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

The description is extremely concise and front-loaded with the main purpose, which is good for structure. However, it is too brief for a tool with nine parameters and no output schema. The single sentence omits essential context that would help an agent use the tool correctly, so while it is efficient, it is not appropriately sized for the complexity.

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

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

Given the tool's complexity (9 optional parameters, no annotations, no output schema), the description is severely incomplete. An agent cannot determine what the tool returns, how it handles the various inputs, or when to use it. The description does not even mention the output format or the relationship between the URL and the other parameters, making it inadequate for correct invocation.

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

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

Schema coverage is 100%, so each parameter has a description, but the tool description adds no clarification about the parameters. It does not indicate that only the 'url' parameter is relevant, nor does it explain the purpose of the other eight parameters. The 'Path discarded' comment does not align with the 'path' parameter's description (which is about a file path, not a URL path), leaving the parameter semantics confusing.

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

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

The description states a specific action ('Parse') on a specific resource ('Figma file URL'), which is clear at a basic level. However, it does not differentiate from sibling shape tools like domain-shape or github-repo-shape, and the input schema includes many unrelated parameters (city, feed, json, etc.), creating confusion about the actual scope. The phrase 'Path discarded' adds minor specificity but does not clarify what the tool actually returns or how it relates to its 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 alternatives. It does not mention any conditions, exclusions, or comparisons to sibling tools. An agent has no basis to decide between figma-url-shape and other shape-checking tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses only one behavioral trait: 'No disk access'. It does not describe what 'safe' means, the return format (e.g., boolean, error), or what happens with the other eight parameters in the schema (which are described as 'discarded' in the schema but not in the tool description). This is a significant gap for a tool that accepts nine parameters and has no output schema.

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

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

The description is a single, efficient sentence with zero filler. It front-loads the core action and the key safety property. For its brevity, it is well-structured and easy to parse. There is no redundancy or unnecessary detail.

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

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

The tool has nine parameters but the description only addresses 'a path'. It does not explain the purpose of the other parameters (e.g., ref, url, city, etc.) or whether they are ignored, which is confusing given the tool's name and description. There is no output schema, so the description should describe the return value or result, but it does not. For a tool with this schema complexity, the description is insufficient for an agent to know how to invoke it correctly beyond the 'path' parameter.

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

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

The input schema provides 100% coverage for all nine parameters, each with a clear description. The tool description itself adds almost no parameter-level meaning beyond naming 'a path', which aligns with the 'path' parameter. Since the schema already documents all parameters, the description does not need to repeat them, and the baseline of 3 is appropriate. The description does not clarify which parameter is the primary one for this tool, but the schema makes it obvious.

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 ('Check') and a specific resource ('a path'), and adds a critical safety constraint ('No disk access'). The tool name 'file-path-ok' aligns with this, and the sibling tools like 'browser-url-ok' and 'domain-shape' make the distinction obvious: this is about file paths, not URLs or domains. The purpose is unambiguous.

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

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

The description offers no guidance on when to use this tool versus the many sibling tools that perform similar 'shape' or 'ok' checks (e.g., 'browser-url-ok', 'figma-url-shape'). It does not state conditions for use, exclusions, or mention any alternatives. An agent must infer from the name and schema that it is specifically for file-path safety, but there is no explicit routing.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states that it returns coordinates via Open-Meteo, implying an external API call, but does not disclose side effects, idempotency, error behavior, or what happens with invalid input. The schema descriptions mention 'discarded' for several parameters, which hints at internal checks, but these are not explained in the tool description. This is a significant transparency gap for a tool that likely makes network calls.

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

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

The description is a single short sentence, which is concise and front-loaded with the core purpose. However, it is so brief that it omits necessary detail. It is not verbose, but the minimalism comes at the cost of completeness, so it earns a middle score.

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

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

For a tool with 9 parameters, none required, and no output schema, the description is severely incomplete. It does not explain how to use the tool, which parameter identifies the place, what the expected response format is, or any constraints. The agent is left with no guidance on constructing a valid call. The schema itself is misleading with unrelated parameter descriptions, and the tool description does not resolve 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 each parameter has a description, but these descriptions are unrelated to the tool's stated purpose. For example, 'Git ref name; discarded after the shape check' and 'JSON text to validate; discarded after the check' do not clarify how any of these parameters contribute to returning latitude/longitude. The description adds no meaning beyond the schema and fails to identify which parameter(s) are used to specify the place. It does not compensate for the confusing and seemingly irrelevant parameter set.

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: 'Latitude and longitude for a place via Open-Meteo.' It is specific and unambiguous about the tool's core function. However, it does not differentiate from sibling tools like weather-hint or timezone, which also deal with location-related data, so it loses a point for lack of sibling differentiation.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any prerequisites, exclusions, or conditions for choosing geo-hint. The schema has 9 parameters but none are required, and the description gives no hint about which parameter to provide to specify a place. This leaves the agent without direction on invocation context.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It does not mention what the tool returns, whether it validates or extracts, or how it handles the other schema parameters. The schema indicates that many parameters are discarded, but the description does not clarify that only the url is relevant.

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

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

The description is a single sentence, which is concise, but it lacks any detail about behavior or parameters. It is appropriately short but fails to provide essential context, so it is not well-structured for an agent to understand the tool's scope.

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

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

Given the tool has 9 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what the tool returns, how to use the url parameter, or why there are many unrelated parameters. An agent would be confused about which parameters to provide.

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 covers all 9 parameters with descriptions (100% coverage), and the description adds that the url should be a GitHub URL, which is helpful. However, it does not clarify that the other parameters are irrelevant to this tool's purpose, so parameter semantics are only partially clarified.

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 parses owner and repo from a GitHub URL, which is a specific verb-resource combination and distinguishes it from sibling tools like domain-shape (domain parsing) and figma-url-shape (Figma URL parsing). The purpose is unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives like normalize-url or browser-url-ok. The description only states what it does, not when to choose it, nor any exclusions or prerequisites.

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

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

With no annotations, the description bears full responsibility for disclosing behavior. It only mentions that titles are discarded, implying the output excludes titles, but it doesn't state whether it's a read-only operation, what the response format is, or any rate limits or side effects. This is insufficient for a tool that likely makes network calls.

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

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

The description is brief and to the point, with two sentences that each add value: the first states the purpose, the second clarifies output behavior. It is appropriately sized for a simple operation, though it could include more context without becoming verbose.

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

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

Despite the tool's apparent simplicity, the description is incomplete. There is no explanation of how to use the nine parameters, what the return value looks like, or any example invocation. The schema is broad and confusing, and the description does nothing to resolve this. An agent cannot confidently call this tool correctly.

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

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

The schema has 100% description coverage, so the baseline is 3, but the parameter descriptions are generic and seem unrelated to the tool's purpose (e.g., 'Git ref name', 'City name for a public weather hint'). The tool description adds no clarification on which parameters are relevant or how they affect the count. This makes the parameter semantics confusing and inadequate 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 action ('Count current Hacker News front-page stories') with a specific verb and resource. It is not a tautology and distinguishes the tool's core function. However, it doesn't differentiate it from siblings that also deal with URLs or web content, so it lacks sibling differentiation.

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

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

There is no guidance on when to use this tool versus alternatives. It doesn't mention any context, prerequisites, or exclusions. The description simply states what it does, leaving the agent without direction on selecting it over similar tools like web-fetch or fetch-status.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention what happens on invocation, what is returned, any side effects, or how parameters are used or discarded. The phrase 'for clock calls' is too vague to inform behavior.

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

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

The description is extremely short (a single phrase), but it is under-specified rather than concise. It lacks essential information and does not front-load a clear purpose. The sentence does not earn its place because it is too vague to be useful.

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 grossly inadequate. It fails to explain the tool's function, what inputs are expected, what outputs are produced, or how it relates to the sibling tools. An agent cannot determine correct usage 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 schema documents each parameter individually. However, the tool description adds no additional meaning about parameter roles or relationships; it does not clarify which parameter is central or how they interact. Baseline of 3 is appropriate since the schema handles the heavy lifting, but no extra value is provided.

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 'Common IANA timezone names for clock calls,' which hints at a resource of timezone names but does not specify the operation (lookup, validation, listing, etc.). It does not clearly distinguish from sibling tools like timezone or utc-time, and the diverse parameter set (ref, url, city, feed, host, json, path, query) does not align with a simple zone-name resource, leaving the purpose ambiguous.

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

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

No guidance is given on when to use this tool versus alternatives such as timezone or utc-time. The description does not mention any conditions, prerequisites, or exclusions, leaving the agent without direction on selecting this tool.

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

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

With no annotations, the description must carry behavioral disclosure. It states only that it 'return[s] group counts only,' which hints at output shape, but it does not clarify how the parameters affect behavior or whether it performs network calls, error handling, or discards inputs. The mismatch between description and schema leaves critical behavior opaque.

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

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

The description is a single concise sentence with no wasted words. However, conciseness is not the same as completeness; the extreme brevity omits essential information about parameter usage and the tool's actual scope, making it under-specified rather than efficiently concise.

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

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

Given nine optional parameters, no required parameters, no output schema, and no annotations, the description is woefully incomplete. It fails to explain which parameter triggers robots.txt fetching, what the output looks like beyond 'group counts,' or how to handle the unrelated parameters. An agent cannot reliably invoke this tool, making it effectively unusable without external knowledge.

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

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

Although the schema has 100% coverage with per-parameter descriptions, those descriptions are unrelated to the tool's stated purpose. For example, 'url' is described as 'HTTPS URL to normalize or cite,' not as a target for fetching robots.txt. The description adds no parameter meaning, and the schema does not compensate; an agent cannot deduce which parameter (if any) supplies the robots.txt URL. This is a severe gap.

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

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

The description states a specific action ('Fetch a public robots.txt') and resource, but the input schema presents nine unrelated parameters (city, feed, json, path, etc.) that do not align with robots.txt. This creates ambiguity about what the tool actually does—it either performs many unrelated checks or the schema is misaligned. The purpose is clear in isolation but misleading in context, so it only partially clarifies intent.

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 a single-line use case (fetch robots.txt) but no guidance on when to choose this over siblings like 'fetch-status', 'web-fetch', or 'domain-shape'. There is no mention of exclusions or alternatives, so an agent cannot determine when this tool is appropriate versus others.

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

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

With no annotations provided, the description carries the full burden. It discloses that the key is 'discarded', which is a useful side-effect note, but it fails to state what the tool actually returns or whether any input is stored. It does not mention authentication, rate limits, or side effects beyond discarding. This is minimal behavioral disclosure.

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 wasted words, but it is under-specified rather than efficiently informative. It lacks front-loaded context about the tool's purpose or return value. While brevity is good, the structure does not prioritize the most critical information for an agent to decide to call it.

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. The description is far too minimal to be complete. It does not explain what 'shape' means, what the output format is, or how to interpret the result. An agent cannot reliably know what to expect from the tool or how to handle the response, making it inadequate for effective use.

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

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

The input schema has 100% description coverage, with each of the 9 parameters clearly documented (e.g., 'Git ref name; discarded after the shape check'). The tool description itself adds no parameter-specific detail, but since the schema is thorough, the baseline of 3 is appropriate. The description does not compensate for any missing semantic nuance 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 verb and resource ('Check a Jira issue key shape'), which distinguishes it from generic validation tools. However, 'shape' is vague – it doesn't clarify whether it validates format (e.g., PROJECT-123) or something else, and it doesn't mention what the tool returns (e.g., boolean, status). It is not a tautology but lacks precision.

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 many sibling shape-checking tools (e.g., domain-shape, github-repo-shape). The name implies Jira keys, but the description does not explicitly state the intended context or exclusions. An agent must 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, the description must carry the burden of behavioral disclosure, but it only states 'Body discarded.' It does not mention side effects, network behavior, rate limits, authentication, or what happens with the other parameters. The single transparency note is far from sufficient.

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

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

The description is one sentence, which is concise, but it is under-specified for a tool with nine parameters. This is not appropriate conciseness; it omits critical information about scope and behavior.

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

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

Given the tool's complexity (9 optional params, no required ones), no annotations, and no output schema, the description is grossly incomplete. It does not clarify how the parameters are used, what 'hint' means, or what the tool actually returns beyond an HTTP status.

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

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

Schema coverage is 100% and each parameter has a short description, so the baseline is 3. The tool description adds no parameter meaning beyond that, but it does not mislead; it simply omits any connection between the stated purpose and the diverse 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 claims the tool returns an HTTP status for a public library docs URL, but the schema exposes nine unrelated parameters (city, zone, json, feed, etc.) and no required fields, so the actual purpose is ambiguous. It does not distinguish this tool from siblings like fetch-status or browser-url-ok, which also check URL status.

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

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

There is no guidance on when to use this tool versus alternatives. The description gives no context, prerequisites, or exclusions, leaving an agent to guess which of the many URL-checking siblings to call.

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

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

There are no annotations, so the description carries the behavioral disclosure burden. It does reveal that values are discarded, which is meaningful. However, it does not clarify side effects, return format, or how the JSON object is supplied, leaving notable behavioral ambiguity.

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

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

Two short sentences with no filler. The core action is front-loaded and every word earns its place, even though the brevity contributes to gaps in contextual guidance.

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

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

For a tool with nine optional parameters and no output schema, this description is too sparse to guarantee correct invocation. It never states which parameter carries the JSON object, whether the arguments object itself is counted, or whether calling with no arguments is valid.

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 a cross-cutting hint that values are ignored, but it does not explain how the nine heterogeneous optional parameters relate to the 'JSON object' being counted. The schema descriptions themselves compensate partially.

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 ('keys in a JSON object'), and adds the useful behavioral qualifier 'Values discarded.' It is not a tautology and is distinguishable from the sibling validate-json, though it does not explicitly compare itself to any sibling.

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?

Usage is only implied: an agent can infer it should use this tool when a key count of a JSON object is needed. There is no explicit guidance about when to prefer it over alternatives such as validate-json, nor any when-not-to-use direction.

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

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

The description discloses that query and fragment are dropped, which is a useful behavioral trait. However, it does not explain the fate of the other 8 parameters, nor does it mention any side effects, permissions, or error behavior. With no annotations, the description carries the burden but falls short.

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

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

The description is concise, two sentences, with the primary purpose front-loaded. It is easy to read and gets to the point quickly. However, it is so terse that it omits essential context about parameter usage, but the conciseness itself is appropriate.

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

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

For a tool with 9 parameters and no output schema, the description is severely incomplete. It does not explain the output format (just 'origin, host, and path' without structure), how to supply the URL, what happens with other parameters, or any prerequisites. The mismatch between the description and the schema leaves an agent guessing.

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

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

The schema provides descriptions for all 9 parameters, so the baseline is 3. The tool description adds no parameter-specific meaning beyond the schema; it does not clarify that 'url' is the only relevant input or how others should be used. It neither helps nor confuses beyond what the schema already offers.

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

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

The description states a specific purpose: return origin, host, and path for a URL, and drop query and fragment. However, the input schema lists 9 unrelated parameters (e.g., city, feed, json) with no explanation of how they relate, creating ambiguity about which parameter is the URL and what the tool actually does with the others.

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 the many sibling tools (e.g., browser-url-ok, fetch-status, web-fetch). It does not specify that it is for normalizing a URL or that only the 'url' parameter matters. No exclusions or alternatives are mentioned.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It adds one useful note ('No browser is launched') but doesn't explain side effects, whether the check is read-only, what it actually does beyond a vague 'opened,' or how results are returned. The single sentence leaves most behavioral traits 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 extremely short and front-loaded, which is positive, but it is under-specified. It does not waste words, yet it lacks essential information, so it's not appropriately sized for a tool with 9 parameters and no output schema. It is concise but not sufficiently 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 annotations and no output schema. The description provides only a one-line purpose and a single behavioral note. It does not explain what 'opened' means, how parameters are used (they seem unrelated), what the return value is, or any constraints. It is severely incomplete for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds nothing about parameters. Moreover, the parameters (ref, city, feed, host, json, path, zone, query) seem unrelated to the stated purpose of checking a URL, and their descriptions (e.g., 'discarded after the shape check') imply they are placeholders. The tool description does not reconcile this mismatch, so it fails to add 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 clear verb and resource: 'Check whether a URL can be opened.' It also adds a behavioral differentiator, 'No browser is launched,' which hints at a distinction from browser-launching tools like browser-url-ok. However, it doesn't explicitly name the sibling or elaborate on what 'opened' means, so it's clear but not fully distinguishing.

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

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

The description offers no guidance on when to use this tool versus alternatives like fetch-status, browser-url-ok, or normalize-url. It only states what it does, not when to choose it, nor any exclusions or prerequisites.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It states that the query is discarded, which is a useful transparency point, but it does not disclose what happens with the other eight parameters, whether the operation is read-only, what the return value is, or any side effects. This is a significant gap for a tool with multiple parameters.

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

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

The description is extremely short ('Count characters in a search query. Query discarded.'), which is front-loaded with the main purpose. However, it is under-specified for a tool with 9 parameters and no output schema. The conciseness is not appropriately sized; it omits critical information about the other parameters and expected behavior.

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

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

Given the tool has 9 parameters, all optional, no output schema, and no annotations, the description is incomplete. It does not explain why the other parameters exist, what the tool does with them, or what the return format is. An agent would struggle to understand the full scope and correct invocation of this tool.

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

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

Schema description coverage is 100%, so the schema already documents all parameters, including the 'query' parameter with its description 'Search text; discarded after the length check'. The tool description adds no additional meaning beyond restating the purpose. According to the rubric, baseline is 3 when coverage is high, and the description does not compensate beyond that.

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

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

The description clearly states the core action: counting characters in a search query. The verb 'count' and resource 'search query' are specific. However, it does not distinguish itself from sibling tools like memory-key-count or hn-front-count, which also involve counting lengths of specific inputs.

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

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

The description provides no guidance on when to use this tool versus alternatives. It only mentions that the query is discarded, which implies a stateless check, but there is no mention of prerequisites, exclusions, or context for choosing it over similar counting 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 full burden of behavioral disclosure. It only says 'short catalog' without describing return format, side effects, or what happens with the inputs. The parameter descriptions mention 'discarded' for several fields, but the tool description itself gives 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 one short sentence, which is concise but under-specified. It lacks essential structure like front-loading a verb or action, and it provides no additional context. This is not effective conciseness; it's minimalism that omits critical information.

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

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

With 9 parameters and no output schema, the description is severely incomplete. It doesn't explain how inputs are used, what the output looks like, or any behavior. An agent cannot reliably decide when or how to call this tool based on the description alone.

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

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

Schema coverage is 100% with each parameter having a description, so the baseline is 3. However, the tool description adds no meaning beyond the schema and fails to connect parameters to the catalog purpose. The parameter descriptions are individually clear but their role in the tool is unexplained, so the description does not compensate.

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 it's a 'Short catalog of common HTTP status codes,' giving a vague noun phrase without a verb or action. It doesn't specify what the tool does with the 9 parameters (ref, url, city, etc.) or how they relate to status codes. It does not differentiate from siblings like fetch-status or browser-url-ok.

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

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

No guidance on when to use this tool versus the many sibling tools. There is no mention of conditions, alternatives, or exclusions, leaving the agent to guess when this catalog applies.

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

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

No annotations are provided, so the description must fully disclose behavior. It states 'Prompt discarded' and per-parameter notes like 'discarded after the shape check,' but it fails to explain that the tool always returns the same template regardless of input, that it has no side effects, or that it performs no real processing. The phrase 'discarded' is vague and does not clarify whether validation occurs or if the tool is a no-op.

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

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

The description is extremely concise, using a single sentence to state the core function and input handling. It is front-loaded with the primary purpose. However, it is so brief that it omits essential context, which slightly reduces the score from a perfect 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?

Despite having no output schema, the description does not describe the returned template's structure or content. It also does not explain why nine optional parameters exist if they are all discarded, leaving an agent uncertain about the tool's actual utility. The tool is simple, but the description fails to fully cover what an agent needs to know to call it correctly.

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

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

Schema coverage is 100%, and each parameter's description already indicates it is discarded or used only for a shape check. The tool description adds no additional meaning beyond the schema. Since the schema already documents the parameters, the baseline of 3 is appropriate; the description does not compensate further.

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

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

The description clearly states the tool's function: 'Return a three-step thinking template.' The additional note 'Prompt discarded' clarifies that input is ignored, distinguishing it from sibling tools that perform specific actions. The verb 'return' and the resource 'three-step thinking template' make the purpose unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any conditions or exclusions, nor does it reference sibling tools. The 'Prompt discarded' hint implies a placeholder role, but there is no explicit instruction for an agent to decide when this tool is appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It simply states 'Current time' without detailing output format, error handling, or the fact that only the 'zone' parameter is used while others are discarded. The schema's parameter descriptions hint at this, but the tool description itself omits it.

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

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

The description is a single, efficient sentence with no filler. However, it under-specifies by not clarifying the key parameter, which could be seen as too terse for a tool with nine 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?

The tool appears simple, but the schema is cluttered with irrelevant parameters that are marked as discarded. The description doesn't clarify that only 'zone' matters, making it incomplete for an agent trying to call the tool correctly. Without an output schema or annotations, the agent has insufficient context.

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

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

Schema description coverage is 100%, so the schema documents all parameters. The description adds no parameter-level information beyond what's in the schema, earning the baseline score of 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 clearly states the tool's function: returning the current time for a given IANA timezone. It is distinct from sibling tools like utc-time and iana-zones, though it doesn't explicitly mention alternatives. However, the schema includes many unrelated parameters that could confuse an agent about the tool's actual input, reducing clarity slightly.

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

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

The description provides no guidance on when to use this tool versus alternatives like utc-time. It doesn't mention any conditions or exclusions, leaving the agent to infer usage from the name and 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?

Annotations are entirely absent, so the description carries the full burden of behavioral disclosure. It states the output but does not mention that all 9 parameters are effectively ignored (per schema descriptions they are 'discarded'), nor does it describe any side effects, return format, or constraints. For a tool that accepts parameters but discards them, this is a notable omission that could lead an agent to mistakenly think parameters affect the result.

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

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

The description is a single, concise sentence with no redundant words, achieving high clarity in a compact form. However, given the tool's 9 parameters, the brevity borders on under-specification, though that issue falls under completeness rather than conciseness. The structure is appropriately front-loaded with the core purpose.

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

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

The tool has 9 optional parameters, no output schema, and no annotations. The description is extremely sparse, providing no information about the parameters being ignored, the return format, or any behavioral nuances. An agent calling this tool would have to rely solely on the schema, which does describe each parameter as discarded, but the description itself fails to convey that the tool effectively ignores all inputs, making it potentially confusing. This is inadequate for a tool with 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 every parameter is documented in the schema (e.g., 'Git ref name; discarded after the shape check'). The tool description adds no additional meaning beyond the schema. Since the schema already explains the parameters clearly, a baseline score of 3 is appropriate; the description neither enhances nor detracts from parameter understanding.

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

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

The description 'Current UTC timestamp' clearly states the tool returns the current UTC time, with a specific verb and resource. It is not a tautology, but it does not differentiate from sibling tools like 'timezone' or 'iana-zones', which might also involve time retrieval. The name 'utc-time' adds specificity, but the description alone does not clarify how it differs from 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?

No guidance is provided on when to use this tool versus its siblings. There is no mention of scenarios, exclusions, or alternatives. The description is a bare statement of functionality, leaving the agent to infer usage from the name alone.

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

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

Without annotations, the description must carry behavioral disclosure; it only says the body is discarded, which covers one side effect. It does not disclose the return value on success/failure, whether an invalid body raises an error, or any other consequences of calling the tool.

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

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

The description is terse and front-loaded with the core purpose, earning it a pass for concision. However, one short sentence leaves ambiguity around what 'body' refers to and what the tool returns, so it is under-specified rather than efficiently complete.

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 validation tool with no output schema, the description should explain what response the caller receives (e.g., a boolean, error message, or empty result). It also omits usage conditions, so an agent has to guess at behavior beyond the simple 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?

The schema already describes every parameter, so the description adds little beyond naming the 'body' concept. It does not explicitly map 'body' to the json parameter or explain why the unrelated fields (ref, url, city, etc.) are present, but the schema itself provides coverage.

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

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

The description states a specific action ('check whether a body is valid JSON') and the tool name reinforces the resource. It doesn't name sibling tools, but the function is distinct enough among the shape-checking siblings to be identifiable.

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

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

No guidance is given for when to choose this tool over alternatives, nor are any excluded use cases or prerequisites mentioned. The only hint is the tool name and the generic verb 'check', leaving the agent to infer scope.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the purpose and does not explain what happens to the other parameters (e.g., ref, url, json are marked 'discarded' in the schema but not mentioned in the description). It also fails to disclose any side effects, requirements, or return format. This is a significant gap for a tool with 9 parameters.

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

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

The description is extremely concise (one sentence), which is positive, but it is under-specified. It lacks necessary context and does not front-load critical usage information. Conciseness alone does not compensate for the lack of substance.

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. The description only covers the 'city' aspect and provides no information about the other parameters, expected behavior, or use cases. An agent cannot correctly determine how to call this tool or what to do with the other parameters. This is severely incomplete.

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

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

The schema has 100% description coverage, so each parameter is documented, but the description adds no value beyond that. It does not explain why unrelated parameters (e.g., json, path, zone) exist or how they relate to the stated purpose of temperature lookup. The description fails to reconcile the mismatch between its narrow purpose and the broad schema.

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

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

The description states a specific verb and resource: 'Current temperature for a city via Open-Meteo.' It clearly indicates the primary function. However, it does not differentiate from siblings like geo-hint or timezone, and the input schema includes 9 unrelated parameters, creating confusion about the actual scope.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of conditions, exclusions, or sibling tools. The agent is left to infer usage from the name and description alone, which is insufficient given the broad parameter set.

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

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

The description explicitly states that the body is discarded, which is a useful behavioral disclosure beyond the tool name. With no annotations available, it carries most of the behavioral burden, but it does not mention error behavior, redirect handling, timeouts, or rate limits.

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

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

The description is two short clauses with no filler: it front-loads the main deliverable and adds one important behavioral caveat. Every word earns its place.

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

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

For a tool with seven parameters, no annotations, and no output schema, this one-sentence description is too thin. It does not specify the output shape, how non-URL parameters are handled, or error semantics, so an agent may be left uncertain beyond the simplest URL-to-status 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?

All seven parameters already have descriptive schema entries, so schema description coverage is high. The tool description adds little parameter-level meaning beyond 'public URL,' and does not clarify how the unrelated parameters such as ref, city, or json relate to the actual HTTP fetch 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 states a precise deliverable — HTTP status and content type — for a public URL, and adds a non-obvious detail that the body is discarded. It is clear about the verb and resource, though it does not explicitly distinguish itself from similar siblings like fetch-status or normalize-url.

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

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

The description implies when this should be used: when an agent needs HTTP status and content type for a public URL. However, it provides no when-not-to-use guidance and names no alternative tools, so it does not help an agent decide between web-fetch and a sibling like fetch-status.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the title is discarded after the call, but it does not clarify whether the tool is read-only, what it returns, or any side effects. The parameter descriptions in the schema mention 'discarded after the call' for several fields, but that is in the schema, not the description. The description adds minimal behavioral transparency.

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

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

The description is very concise (two sentences), but it is not structured to be helpful. It lacks essential information and does not front-load usage guidance. The brevity is not a virtue here because it omits critical context.

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

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

Given 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. An agent has no idea how to invoke the tool correctly, which parameter to use for the title, or what to expect as a result. The tool definition is inadequate for its complexity.

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

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

The input schema has 9 parameters, all with descriptions and 100% coverage. However, the description does not link any parameter to the Wikipedia title check. It adds no meaning beyond the schema. The schema parameters (ref, url, city, etc.) seem unrelated to the tool's stated purpose, and the description does not clarify how to specify the title. This is a significant gap.

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

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

The description states a specific action: 'Check whether a Wikipedia title exists.' This is clear and distinct from sibling tools. However, it does not indicate which parameter carries the title, and the input schema has no obvious title parameter, which could confuse an agent. Still, the purpose is stated distinctly from 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 alternatives. No mention of when not to use it or what conditions apply. The description provides no context about prerequisites or intended use cases.

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