UUID v1 time-based shape

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

With no annotations, the description must disclose behavior itself. It mentions that some inputs are discarded and that it 'Returns connection methods,' but it does not state whether the operation is read-only, whether it has side effects, or what authentication or rate limits apply. For a discovery tool, this is minimal 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 two sentences with no fluff. The purpose is front-loaded in the first sentence, and the second sentence adds a relevant behavioral note. It is appropriately concise for the amount of information it conveys.

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 insufficient. It does not explain how to select parameters, what form 'connection methods' take, or what the response structure is. An agent would struggle to know what inputs to provide and what to expect in return.

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 clear description. The tool description adds the context that these are hints and that task text is discarded, which slightly extends the schema. However, it does not clarify which parameters are appropriate to provide for a given task, leaving the agent to infer. This meets the baseline for high schema coverage.

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

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

The description states a clear verb ('Find') and resource ('public pay-per-call tool gateway'), with examples of tasks (weather, search, scrape, voice). It distinguishes itself from the sibling tools by being a meta-tool that returns connection methods, though it doesn't explicitly name alternatives. The phrase 'Task text discarded' adds specificity about behavior.

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

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

There is no explicit guidance on when to use this tool versus the many sibling tools (weather-hint, search-query-len, etc.). The description implies it is for finding a gateway, but does not state when to prefer it over a direct tool or what conditions trigger its use. 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?

No annotations are provided, so the description must carry the full burden. It discloses only that no browser is launched, but fails to describe what the tool actually does (e.g., performs a HEAD request, validates URL format, checks DNS). The parameter list includes unrelated fields (city, json, path, zone, query) with no explanation, making behavior ambiguous.

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

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

Two sentences with no waste; the key constraint (no browser) is front-loaded. However, it is so sparse that it borders on under-specification, so a 4 rather than 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?

For a tool with nine optional parameters and no output schema, the description is inadequate. It doesn't explain what the tool does with the parameters (e.g., 'ref', 'city', 'feed', 'json', 'path', 'zone', 'query' are unrelated to URL checking), nor what it returns. An agent would be left guessing about the tool's actual behavior and output.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds no additional semantics about how these parameters interact with the URL check, but the baseline of 3 applies since the schema covers the 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?

States a clear verb-resource pair: 'Check whether a URL can be opened' with the clarifying caveat 'No browser is launched.' This distinguishes it from 'playwright-url-ok' which likely launches a browser. However, it doesn't specify the method (HTTP request, DNS, etc.), so it's a 4 rather than a 5.

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

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

Provides no guidance on when to use this tool versus siblings like 'fetch-status', 'normalize-url', or 'playwright-url-ok'. No alternatives or exclusions are mentioned, leaving the agent to infer from the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Expression discarded' but there is no expression parameter, and it gives no information about side effects, return values, permissions, or error behavior. This is almost completely opaque.

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

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

The description is a single short sentence, which is concise, but it is under-specified to the point of uselessness. It lacks any structural breakdown or additional context that would make the conciseness valuable. This is more under-specification than effective brevity.

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

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

Given the tool's complexity (9 parameters, no required fields, no output schema, no annotations), the description is woefully incomplete. It does not explain what the tool does with the provided parameters, what the expected inputs are, or what the output looks like. An agent cannot correctly invoke this tool based on the description.

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

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

Although the schema has 100% coverage of parameter descriptions, the tool description adds no meaning to any parameter. It does not mention how the nine parameters relate to arithmetic evaluation; in fact, it implies an expression input that does not exist. The description fails to compensate for the parameter ambiguity and actively misleads.

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 nine unrelated parameters (ref, url, city, feed, etc.) with no arithmetic operand. The purpose is not just vague—it is misleading, as no expression parameter exists and the description does not align with the schema. No distinction from siblings is provided.

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

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

There is no guidance on when to use this tool versus any of the 28 sibling tools. The description gives no context about typical use cases, prerequisites, or alternatives.

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

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

The description provides one useful behavioral guarantee: 'Page content is not stored,' and the verb 'Return' implies a read-only operation. However, with no annotations, the description carries the full burden and still omits important details like whether a network request is made, which parameters are actually honored, and how unreachable URLs are handled.

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

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

The description is two short sentences with no filler, and the main behavior is front-loaded. The privacy note is relevant and earns its place, though the extreme brevity contributes to the overall incompleteness.

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

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

With no output schema, no annotations, and nine optional parameters spanning unrelated domains like ref, city, json, zone, and query, this description is not sufficient. It does not specify the response format, which parameters to provide for a normal citation request, or why so many unrelated parameters are accepted.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds minimal parameter meaning beyond restating that 'url' is relevant; it does not clarify the roles of the other eight parameters or how they relate to the citation 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 names a specific action and resource: 'Return host, scheme, and HTTP status for a URL.' This is clear enough to infer the core purpose. However, it does not differentiate from sibling tools like normalize-url or fetch-status, and it leaves the nine-parameter schema unexplained.

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

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

There is no guidance about when to use this tool versus alternatives such as fetch-status, browser-url-ok, or normalize-url. No exclusions, prerequisites, or decision rules are provided, so the agent must guess the intended use case.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions that identifiers are not retained, but does not explain whether the tool makes network calls, performs checks, or returns a classification. The privacy note is helpful but far from sufficient for a tool with 9 input 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 only two sentences, which is concise, but it is under-specified. It lacks the essential details needed to understand the tool's purpose and behavior. It is not front-loaded with useful information and reads more like a placeholder than a functional description.

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

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

For a tool with 9 optional parameters, no output schema, and no annotations, the description is grossly inadequate. An agent cannot determine what the tool does, how to call it correctly, what output to expect, or when to use it. The description provides almost no contextual information.

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

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

Schema description coverage is 100%, so each parameter already has a description. The tool description adds no additional meaning beyond the schema. Baseline of 3 is appropriate since the schema handles parameter documentation.

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

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

The description says 'Show how this request is classified' which is extremely vague. It does not state what 'compatibility' means, what classification is performed, or what the output looks like. It fails to distinguish itself from the many sibling tools that also process URLs, files, or queries.

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 conditions, exclusions, or context that would help an agent decide between this and tools like 'domain-shape' or 'url-ok'. The description is silent on usage scenarios.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose that data is discarded, that there is no WHOIS/ownership lookup, that no disk access occurs, or what the tool actually returns. The schema hints at 'shape check' behaviors, but the description omits any behavioral details, leaving the agent in the dark about side effects and output.

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

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

The description is a single sentence, which is concise, but it is under-specified for a tool with 9 parameters. It front-loads only one aspect (hostname splitting) and omits the broader purpose. The brevity is not effective because it fails to convey 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?

Given the tool's complexity (9 parameters, no output schema, no annotations), the description is severely incomplete. It does not explain what the tool does for the other parameter types, what the result looks like, or how to invoke it correctly. An agent cannot reliably use 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%, so each parameter has a description, but the tool description adds nothing beyond the schema. It only mentions 'hostname' while ignoring the other 8 parameters, failing to clarify their roles or how they relate to splitting a hostname. The schema descriptions like 'discarded after the shape check' are ambiguous, and 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 'Split a hostname into labels' which is a specific verb+resource, but the input schema includes 9 unrelated parameters (ref, url, city, feed, json, path, zone, query) that are never mentioned. This creates ambiguity about the tool's actual scope and misleads the agent into thinking it only handles hostnames. It is not a tautology, but it is vague and incomplete for the actual tool surface.

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 siblings like normalize-url, file-path-ok, or jira-key-shape. No conditions for selection, no alternatives mentioned, and no exclusions. The agent has no basis to choose this tool over similar shape-checkers.

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. It does disclose that the operation is a lightweight HEAD request and only returns a status, implying a read-only, non-destructive action. However, it fails to mention that the tool also performs shape checks on multiple non-URL parameters (ref, city, feed, etc.) as evidenced by the schema, making the description misleading about the tool's full scope. It also omits any details about error handling, timeouts, or response format.

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

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

The description is a single, front-loaded sentence with no filler. It is highly concise and directly communicates the primary action. However, its brevity borders on under-specification, omitting critical scope details, which slightly reduces the score.

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

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

Given 9 parameters and no output schema, the description should clarify the overall behavior. It only addresses URL handling, while the schema suggests the tool validates multiple input types. The description does not explain how the other parameters are used, what 'status' means in different contexts, or whether the tool returns a simple HTTP status code or a validation result. This incompleteness would leave an agent uncertain about how to correctly invoke the tool for non-URL inputs.

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

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

Schema description coverage is 100%, with each parameter clearly described (e.g., 'discarded after the shape check' or 'no disk access'). The description adds no additional parameter-level meaning, but the schema already provides sufficient semantics, so the baseline of 3 is appropriate. No credit is needed for repeating schema content.

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: 'HEAD a public URL and return status only.' It specifies a verb (HEAD), a resource (public URL), and the exact output (status only), distinguishing it from sibling tools like web-fetch which likely fetch full content. The phrasing is specific and 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 such as web-fetch, browser-url-ok, or status-catalog. The description gives no context for selection, leaving the agent to infer appropriateness from the name and schema alone.

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

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

With no annotations, the description carries the full burden. It discloses 'Path discarded' which is one behavioral trait, but it ignores the other eight parameters entirely. The description implies the tool only handles Figma URLs while the schema accepts unrelated fields, creating confusion about what actually happens. No side effects, return format, or error behavior are mentioned.

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

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

The description is extremely brief (one sentence), but that brevity comes at the cost of essential information. It is under-specified for a tool with 9 parameters and no annotations. It is not appropriately sized for the tool's complexity.

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

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

For a tool with 9 parameters, no annotations, and no output schema, this description is severely incomplete. It doesn't explain the tool's behavior with the other parameters, what it returns, or any constraints. An agent has almost no information to correctly invoke this tool beyond the schema.

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

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

Schema coverage is 100%, so each parameter has a description, but the tool description adds minimal value. It doesn't clarify that the other parameters (city, feed, json, etc.) are irrelevant to the primary purpose or how they interact with the URL parsing. The 'Path discarded' note is ambiguous—does it refer to the URL path or the 'path' parameter? This lack of clarity makes the description misleading.

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

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

The description states a specific verb and resource: 'Parse a Figma file URL'. It clearly distinguishes from siblings like normalize-url by targeting Figma URLs specifically. However, it doesn't mention what 'parse' returns or how it relates to the other schema fields, so it's not fully clear.

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

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

No guidance on when to use this tool versus alternatives. It doesn't say 'use for Figma URL validation' or 'for general URLs use normalize-url'. The description is purely functional with no contextual direction.

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

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

No annotations exist, so the description carries the full burden of behavioral disclosure. It provides one useful safety claim ('No disk access') but never explains what 'safe' means, what the return value looks like (no output schema), or whether the result is a boolean. The schema's 'discarded after' notes are behavioral, but they live in the schema, not the description.

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, front-loaded and free of waste — but the brevity is under-specification, not good conciseness. A 9-parameter tool with a description that mentions only one parameter type is hiding a critical mismatch, not earning its brevity.

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

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

Severely incomplete for a tool with 9 optional parameters and no output schema. The description gives no way for an agent to select which parameter to pass, doesn't reconcile the file-path name with the URL/city/timezone parameters, and fails to explain what 'safe' means or what gets returned. An agent cannot call this 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% — every one of the 9 parameters has its own description (e.g., 'File path to check; no disk access', 'City name for a public weather hint'). The description adds nothing about parameters, so the baseline 3 applies; the schema does the heavy lifting.

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

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

The description states a clear verb+resource ('Check whether a path looks safe') but the schema accepts 9 unrelated parameter types (url, city, feed, zone, query, json, ref, host) with only one being a path. The stated purpose is directly contradicted by the interface surface, so an agent cannot trust what the tool actually does.

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

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

No guidance on when to use this tool versus its many siblings (browser-url-ok, domain-shape, validate-json, timezone, geo-hint). Given the schema accepts a URL, city, timezone, and JSON, the description never explains which parameter to pass or when to route to this tool instead of a sibling — leaving selection entirely to inference.

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

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

There are no annotations, so the description carries the full burden of disclosing behavioral traits. It only says 'Latitude and longitude for a place via Open-Meteo', without mentioning whether it makes network calls, whether inputs are discarded (even though parameter descriptions hint at discarding), what side effects occur, or any rate limits. The description does not even acknowledge that most parameters are discarded, which is a significant behavioral gap.

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

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

The description is a single sentence, which is concise, but it is under-specified rather than efficient. It lacks essential details about inputs and outputs. Being short is not valuable if it omits required information; this is an example of under-specification, not conciseness.

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

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

With nine optional parameters, no output schema, and no annotations, the description is drastically incomplete. It does not state which parameter to use for the place, how the result is returned (JSON format, error handling), or any constraints. An agent cannot reliably call this tool based on the provided information.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds no meaning beyond the schema. More importantly, the schema descriptions themselves are inconsistent with the stated purpose: 'City name for a public weather hint; discarded after the call' suggests weather, not geocoding, and other parameters like 'json' or 'ref' have no apparent link to returning coordinates. The description fails to clarify which parameter is the 'place' or how the tool uses the others, so it does not add value beyond the schema and even introduces confusion.

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

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

The description states a clear action (return latitude and longitude) and resource (a place via Open-Meteo), but it does not specify which of the nine parameters identifies that place. The parameters are heterogeneous (ref, url, city, feed, host, json, path, zone, query), and only 'city' seems potentially relevant, yet its schema description says 'discarded after the call' and mentions a 'weather hint', not geocoding. This leaves the agent unsure what input to provide for the geocoding purpose.

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

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

No guidance is given on when to use this tool versus alternatives. Sibling tools like weather-hint, timezone, and various shape-check tools exist, but the description does not contrast geo-hint with them or state any preconditions. An agent has no way to know if this is the right tool for a given task.

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

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

No annotations are provided, so the description carries the full disclosure burden. It claims to 'parse owner and repo' but the schema reveals that 8 of 9 parameters are discarded, implying a validate-and-discard behavior rather than a retrieval that returns owner/repo. The description neither confirms what the tool returns nor that non-GitHub URLs fail, so its implied behavior is misleading relative to the schema.

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

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

A single, tightly front-loaded sentence with zero filler. Every word earns its place and the core purpose is stated immediately.

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

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

The tool is far more complex than the description suggests: it accepts nine parameters, discards eight, and has no output schema to clarify return values. The description explains only the url case and never addresses why the other parameters are accepted, what happens on invalid input, or what the tool returns. For a shape-check tool of this complexity, this is inadequate.

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 the key semantic that the url parameter is the GitHub URL to parse, which is useful. However, it sheds no light on why eight unrelated parameters (city, zone, json, query, etc.) exist on a 'GitHub repo' tool, leaving those 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?

States a specific verb (parse) and resource (owner and repo from a GitHub URL), which distinguishes it from sibling shape-checkers like figma-url-shape or domain-shape. However, it reads as a pure parsing tool, while the schema's pervasive 'discarded' language implies it is actually a validation/shape-check tool, so the stated purpose slightly undersells its real role.

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

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

Provides no guidance on when to choose this tool over the many sibling URL/shape tools (domain-shape, figma-url-shape, jira-key-shape, browser-url-ok). An agent must infer that this is specifically for GitHub URLs, with no explicit when-to-use or when-not-to-use framing.

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 and discloses only that the result is a live count and titles are excluded. It does not state what output format is returned, whether a network request occurs, or how the nine optional schema parameters relate to the count.

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

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

The description is short and action-first with no fluff. The phrase 'Titles discarded' is cryptic, which keeps it from full marks, but it earns its place as a behavioral qualifier.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, this two-sentence description is insufficient. It fails to explain parameter relevance, invocation behavior, or return shape, so an agent cannot confidently invoke it.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description itself provides no parameter guidance. The schema gives each parameter a meaning, but those meanings are mostly unrelated to the stated tool purpose, and the description does not clarify which parameter(s) to use.

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

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

The description names a specific operation—counting current Hacker News front-page stories—and adds 'Titles discarded' to narrow the output. It is not a tautology, though it does not explicitly differentiate itself from sibling tools like web-fetch or memory-key-count.

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

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

No guidance is given about when to choose this tool over alternatives or when not to use it. 'Titles discarded' hints that title retrieval should be done elsewhere, but no sibling or condition is 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 disclose behavior, but it only offers a noun phrase. It doesn't indicate whether the tool is read-only, whether it accesses external data, whether it has side effects, or what the output format is. The phrase 'for clock calls' hints at a purpose but says nothing about the actual operation.

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. While brevity is valued, here it is under-specification rather than conciseness. There is no structure, and the sentence doesn't front-load any actionable information. It fails to earn its place because it conveys almost no usable 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?

The tool has 9 parameters, no output schema, and no annotations. The description gives no indication of what the tool does, what it returns, or how the parameters are used. It is completely inadequate for an agent to safely and correctly invoke this tool, even for a simple lookup.

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 individual descriptions, so the baseline is 3. However, the tool description adds no context about how the parameters relate to the tool's purpose. For instance, 'ref' is described as discarded, but there's no explanation of why it exists. Since none of the parameters are required and the description doesn't clarify which are relevant, the value added is minimal.

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 provides common IANA timezone names for clock calls, but it doesn't specify what the tool actually does with those names—whether it returns a list, validates a zone, or resolves a timezone from a given input. The verb is missing; 'for clock calls' is ambiguous and doesn't distinguish it from sibling tools like 'timezone' or 'utc-time'.

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

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

No guidance is given for when to use this tool versus alternatives. There is no mention of conditions, prerequisites, or exclusions, and none of the sibling tools are referenced. An agent would have no way to know if this is the right tool for a task.

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 only states that it fetches and returns counts, but does not disclose side effects like network calls, error handling for missing robots.txt, rate limits, or why the nine parameters are present. With no annotations, the description carries the full burden, and it fails to explain the role of parameters like 'city' or 'zone'.

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

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

The description is a single, efficient sentence with no fluff. However, it is so terse that it omits essential context; while concise, it lacks the structure needed to clarify parameter usage.

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

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

The tool has nine parameters but no output schema, and the description explains neither the parameters' relevance nor the expected return format. An agent cannot determine how to supply a robots.txt URL or interpret 'group counts'. The description is wholly 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?

Although schema coverage is 100%, the parameter descriptions are generic and unrelated to fetching robots.txt (e.g., 'city' for a weather hint, 'json' to validate). The tool description does not clarify how any of the nine parameters relate to the stated purpose, making the schema actively misleading.

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 ('Fetch'), a specific resource ('public robots.txt'), and a specific outcome ('return group counts only'). It is concise and clearly distinguishes this tool from siblings like web-fetch or fetch-status by narrowing to robots.txt inspection.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention prerequisites, such as needing a URL, or scenarios where other tools (e.g., web-fetch) would be more appropriate.

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

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

With no annotations, the description carries the full burden, and 'Key discarded' is the only behavioral disclosure. It does not state what shape is validated, whether any input is persisted, what the return value is, or what happens on invalid input; the schema's per-parameter 'discarded' notes are not enough to understand the tool's behavior.

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

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

The two sentences are concise and front-loaded, but they are too sparse for a tool with nine parameters and no annotations. Every sentence earns its place, yet the description sacrifices necessary context for brevity.

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

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

For a tool with nine optional parameters, no required fields, no output schema, and no annotations, this description is far from complete. It fails to explain what input to pass, what output to expect, or how the tool behaves relative to its siblings, making it effectively unusable for correct invocation.

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

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

Schema description coverage is 100%, which normally warrants a baseline of 3, but the tool-level description introduces a 'Jira issue key' concept that no schema property represents. An agent cannot tell which of the nine optional parameters should be supplied, so the description actively undermines parameter semantics instead of adding value.

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

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

The description names a specific verb and resource ('Check a Jira issue key shape'), but it never maps that key to any of the nine schema properties, and no parameter is named 'key'. The mismatch between the stated purpose and the actual input schema makes the tool's function ambiguous.

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

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

There is no guidance on when to choose this tool over sibling shape-checkers like github-repo-shape, domain-shape, or figma-url-shape. The phrase 'Check a Jira issue key shape' implies a use case, but with no exclusions, prerequisites, or examples the agent is left to infer the 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 carries the full burden. It discloses that the tool returns an HTTP status and discards the body, but it does not explain what happens with the other 8 parameters, whether there are side effects, authentication needs, or rate limits. For a tool with 9 parameters, this is a significant gap.

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

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

The description is a single, short sentence, which is structurally concise. However, it is under-specified to the point of being nearly useless. Conciseness is not a virtue when it omits critical information, so while it is not verbose, it does not earn credit for being 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?

For a tool with 9 parameters, no output schema, and no annotations, this description is completely inadequate. It does not explain the tool's full behavior, when to use it, or what the return value looks like. An agent would be unable to use this tool correctly based solely on 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 coverage is 100% and each parameter has a description, but the tool description does not connect these parameters to its stated purpose. The parameters like city, zone, json, path, and query are unexplained in the context of the tool. The description adds no meaning beyond the schema's generic descriptions, and it fails to clarify how they relate to the 'library docs' focus.

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 'HTTP status for a public library docs URL' but the input schema contains 9 unrelated parameters (city, zone, json, path, query, etc.) that have nothing to do with library docs. This creates confusion about the tool's actual purpose. It is not a tautology, but it is narrow and misleading given the broad schema.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of when it should be preferred over siblings like fetch-status, browser-url-ok, or normalize-url. The description offers no exclusions or alternative 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?

With no annotations, the description must carry the behavioral disclosure burden. It only says 'Count keys in a JSON object. Values discarded.' and omits any side effects, error behavior, output format, or whether the operation is read-only, which is a significant gap for a minimal 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 a single sentence with no fluff, which is structurally concise. However, it is under-specified, but conciseness measures efficiency of expression rather than completeness, so it earns a 4.

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

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

Given the tool has 9 optional parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain how to provide the JSON object, what the output looks like, or any error conditions, making it inadequate 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?

The schema has 9 optional parameters with descriptions that appear recycled from other tools (e.g., 'city' for weather, 'url' for normalization). The tool description does not clarify which parameter holds the JSON object, and the 'json' parameter description mentions 'validate' rather than 'count keys', so the parameter semantics are misleading and add no useful meaning beyond the confusing schema.

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

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

The description states a specific action (count keys in a JSON object) and notes values are discarded, which is clear and distinguishes it from siblings like validate-json. However, it does not specify which input parameter carries the JSON object, and the schema contains many unrelated parameters (city, url, etc.), making the intended invocation ambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of scenarios, prerequisites, or explicit alternatives among the 27 sibling tools, leaving the agent to infer usage solely from the name.

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

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

Annotations are absent, so the description must fully disclose behavior. It states the primary output (origin, host, path) and that query/fragment are dropped, which is useful. However, it fails to explain why the input schema contains nine parameters (e.g., city, feed, json, zone) that appear unrelated to URL normalization, and it gives no indication of side effects, errors, or return format. The description is silent on these critical aspects, leaving significant ambiguity.

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

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

The description is extremely concise, containing two short sentences with no fluff. It front-loads the core behavior (return origin, host, path) and the key constraint (drop query/fragment). This is efficient and well-structured for a simple read operation, though it sacrifices necessary context for brevity.

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

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

Given the tool's complexity (nine parameters, no output schema, no annotations) and the presence of many sibling tools, the description is severely incomplete. It does not explain the purpose of the extra parameters, specify when to use this tool over alternatives, describe the return format, or address error handling. An agent would have to make many assumptions to invoke this tool correctly.

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

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

Schema description coverage is 100%, so all parameters have textual descriptions in the schema itself. The tool description adds no parameter-specific information beyond the schema. While the schema descriptions are present, some are confusing (e.g., 'city' for weather hints), and the tool description does not clarify which parameters are relevant or how they relate to the stated purpose. It neither compensates for gaps nor adds value, so a baseline of 3 is appropriate.

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

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

The description clearly states the action ('Return') and the resource ('origin, host, and path for a URL'), and specifies that query and fragment are dropped. This distinguishes it from sibling tools like browser-url-ok or figma-url-shape, which focus on validation/shape checks. The purpose is unambiguous and directly tied to the tool's name.

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. Sibling tools such as browser-url-ok, figma-url-shape, and github-repo-shape exist, but the description does not mention any conditions or exclusions. Usage context is only implied by the name and description, leaving the agent to infer appropriateness without explicit 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 no browser is launched, which is a useful side-effect note. However, it does not state whether any network request occurs, what exactly is checked, how the result is returned, or which of the many input fields are actually considered. Several parameter notes say 'discarded,' making the real behavior 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 very short and front-loads the core verb, but it is not appropriately sized for the complexity of the input schema. One vague sentence leaves too much unstated; additional concise clarification about the check mechanism, relevant fields, and return behavior would improve it without adding fluff.

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

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

With no annotations, no output schema, 9 optional parameters, and many seemingly unrelated parameter names, the description is not complete enough for an agent to use the tool correctly without additional context. It lacks any explanation of the return value, error behavior, or how to choose among the several URL-related sibling tools.

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

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

Every parameter has a schema-level description, so coverage is 100%, but the descriptions are often irrelevant to a URL-checking tool. For example, 'url' is described as 'HTTPS URL to normalize or cite,' and city, feed, json, path, zone, and query appear to belong to other tools. The descriptions do not coherently explain how any parameter contributes to checking whether a URL can be opened.

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 general intent ('Check whether a URL can be opened') but never defines what 'can be opened' means—syntax validation, HTTP reachability, DNS resolution, or something else. The input schema introduces many unrelated fields (city, feed, json, zone, query), which further muddies the tool's actual purpose.

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

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

There is no guidance on when to use this tool instead of closely related siblings like browser-url-ok, fetch-status, or normalize-url. The only behavioral hint is 'No browser is launched,' but it does not explain the intended use case, prerequisites, or when not to use 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 provided, the description carries the full burden of behavioral disclosure. It only says 'Query discarded', implying no persistence, but does not mention the return value, whether the operation is read-only, or that all other parameters are also discarded. It omits any side effects or limitations, leaving significant behavioral ambiguity for a tool with nine parameters.

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

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

The description is extremely short (two sentences), which is concise but under-specified. It front-loads the primary action, but lacks structure such as a clear statement of which parameter to use or what to expect in return. The brevity is not necessarily a virtue because it omits critical operational details.

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

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

For a tool with nine parameters, no output schema, and no annotations, this description is completely inadequate. It fails to explain the purpose of the other parameters, the return format, or when to invoke this tool relative to its many similar siblings. An agent cannot determine correct usage or expected output from the given information.

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

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

Schema description coverage is 100%, and each parameter has a clear description (e.g., 'Search text; discarded after the length check'). The tool description adds no additional meaning beyond the schema, so the baseline of 3 applies. It does not highlight which parameter is essential or how the parameters relate to the core action.

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 ('Count characters') and resource ('search query'), which is distinct from sibling tools like memory-key-count. However, it does not clarify that only the 'query' parameter is used while the other eight parameters are ignored, which could mislead an agent into thinking they are relevant. The phrase 'Query discarded' is also ambiguous about whether the query is discarded after counting or the tool discards it.

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

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

The description provides no guidance on when to use this tool versus alternatives like memory-key-count or other shape-check tools. It does not state prerequisites, when not to use it, or how it relates to siblings. An agent must infer its purpose from the name and schema.

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, but it says nothing about side effects, output format, or how inputs are used. The parameter descriptions in the schema mention 'discarded after' checks, but the tool description is silent on all behavior. This is a severe transparency gap for a tool with 9 parameters and 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 short sentence, which is concise, but it is under-specified rather than appropriately sized. It provides no actionable information beyond the title. The sentence does not 'earn its place' because it adds no functional clarity; it is closer to a tautology than a useful specification.

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

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

The tool has 9 optional parameters, no output schema, and no annotations. The description is completely inadequate to explain what the tool does, what it returns, or how the parameters affect the result. An agent would be unable to correctly invoke this tool based on the description alone.

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

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

The schema provides 100% coverage for each parameter, so the baseline is 3, but the description adds zero value by not connecting these parameters to the tool's stated purpose. The description implies a static catalog, yet the parameters suggest validation of various inputs. This mismatch means the description fails to clarify how parameters relate to the tool, making the semantics confusing despite individual schema descriptions.

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

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

The description 'Short catalog of common HTTP status codes' is a noun phrase, not a verb+resource statement. It fails to say what the tool does with its 9 input parameters (ref, url, city, feed, etc.), which have no obvious connection to a status-code catalog. It does not differentiate from siblings like fetch-status or browser-url-ok, making the purpose ambiguous and effectively a restatement of the title.

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

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

No guidance is provided on when to use this tool versus the many sibling validation tools (e.g., fetch-status, normalize-url, validate-json). There is no mention of typical use cases, prerequisites, or exclusion criteria. An agent has no idea whether to reach for this tool or a sibling.

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

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

No annotations are provided, so the description carries the full burden. 'Prompt discarded' is ambiguous—it could mean user input is ignored, parameters are ignored, or something else. No mention of side effects, auth requirements, rate limits, or what happens to the parameters. This is a serious transparency gap.

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

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

The description is extremely short, but this is under-specification, not conciseness. It lacks structure and front-loading of critical information. The two sentences provide almost no useful content.

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 fails to explain the template's purpose, how parameters influence it, or what the return value looks like. An agent cannot correctly invoke this tool based on this description alone.

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

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

The schema provides full descriptions for all 9 parameters, but the tool description does not explain how any of them relate to the 'three-step thinking template.' The agent cannot determine which parameters are relevant or how to combine them. The description adds no 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 'Return a three-step thinking template' but gives no indication of what the template is for or how it relates to the 9 parameters. It does not distinguish this tool from siblings like calc-eval or validate-json, which have clearer purposes. The phrase 'Prompt discarded' is cryptic and adds confusion rather than clarity.

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

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

No guidance is provided on when to use this tool versus alternatives. There are no conditions, examples, or exclusions mentioned. An agent has no basis to decide between this and any of the 27 sibling tools.

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

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

With no annotations, the description carries full burden. It only states the core function but does not disclose that only 'zone' is used while other parameters are discarded, nor does it mention behavior on invalid zones or any output format. The description provides minimal transparency beyond the schema.

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

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

The description is a single concise sentence with no waste, which is good for structure. However, it is under-specified for a tool with nine parameters, so it trades completeness for brevity. 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?

Given the tool has nine parameters and no output schema or annotations, the description is incomplete. It does not mention which parameter to use, what happens with other parameters, or error behavior. An agent would not know how to correctly invoke the tool beyond the schema descriptions, which are generic.

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

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

Although schema coverage is 100% and each parameter has a description, the tool description adds no value in clarifying which parameter is relevant. The presence of nine unrelated parameters (ref, url, city, etc.) is not addressed, so the description fails to help the agent select the correct parameter. It does not compensate for the clutter.

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 (current time) and resource (named IANA timezone), which distinguishes it from siblings like iana-zones (list) and utc-time (UTC only). It is specific and 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 gives no guidance on when to use this tool versus alternatives such as utc-time or iana-zones. It does not mention exclusions or conditions, leaving the agent to infer usage from the name and schema.

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 only states the output (UTC timestamp) and says nothing about side effects, parameter handling, or limitations. The schema hints that many parameters are discarded, but this is not surfaced in the description, leaving the agent uninformed about actual behavior.

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

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

The description is extremely brief—only four words—which is concise but under-specified for a tool with 9 parameters and no annotations. It is not front-loaded with useful context, and the minimalism results in a lack of necessary information rather than efficient communication.

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

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

Given the complexity of 9 parameters and the absence of annotations or an output schema, the description is woefully incomplete. It does not explain how parameters affect the result, what the return format is, or when to use the tool. An agent cannot confidently call this tool correctly based on the description alone.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds no parameter-level meaning and does not explain why 9 diverse parameters are relevant to a UTC time tool. Baseline of 3 is appropriate since the schema carries the weight, but the description fails to clarify the purpose of these parameters in context.

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

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

The description 'Current UTC timestamp' clearly states the tool returns the current UTC time, which is a specific resource. However, it does not distinguish itself from sibling tools like 'timezone' or 'iana-zones', and lacks an explicit verb like 'get' or 'return', so it falls short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any context, exclusions, or comparison to sibling tools such as 'timezone' or 'normalize-url'. The agent is left without direction on selection.

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

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

With no annotations provided, the description carries the full burden of explaining behavior, but it does not disclose what happens to the inputs, whether the operation is read-only, or what result is returned. The odd parameter descriptions ('discarded after the shape check') add confusion rather than clarity.

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

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

The description is very short and front-loaded, but it is too terse to be useful. It omits the action and essential context, so brevity comes at the expense of clarity.

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

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

Given nine optional string parameters and no output schema, the description is completely inadequate for an agent to understand how to call the tool correctly, what output to expect, or how the parameters relate to a UUID v1 shape. Essential information is missing.

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

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

Although every parameter has a schema description, those descriptions are thematically unrelated to UUID v1 and mostly serve as decoys (e.g., 'City name for a public weather hint', 'Git ref name', 'Search text'). No parameter is clearly identified as the value whose UUID v1 shape should be checked, so the parameter semantics do not support the tool's supposed 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 'UUID v1 time-based shape' is a noun phrase with no verb, so it does not state what the tool actually does. It fails to indicate whether the tool validates, extracts, or generates UUID v1 shapes, especially given the unrelated input parameters.

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

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

No guidance is provided on when to use this tool instead of sibling validation/shape tools. There is no mention of expected inputs, the validation scenario, or any criteria for selecting this tool over similar options.

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

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

The description discloses that the body is discarded, implying a read-only operation with no side effects, which is valuable given there are no annotations. However, it does not explain behaviors for other parameters (e.g., whether URL, city, or host are validated, normalized, or discarded) and provides no information about error handling, return format, or rate limits. The single behavioral fact is helpful but incomplete for a tool with such a broad 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 concise sentence, which is efficient, but it is under-specified and does not front-load critical information about the tool's full scope. It is not poorly structured, but it lacks the detail needed to be effective. The brevity is a positive, but it sacrifices clarity and completeness.

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

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

With nine parameters and no output schema, the description is severely incomplete. It only addresses the JSON validation case, leaving the purpose and usage of the other eight parameters unexplained. An agent would struggle to know what to pass for 'url', 'city', or 'zone', or whether these are validated similarly. The description does not adequately cover the tool's actual capabilities, making it inadequate 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?

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning beyond what the schema already provides. It mentions 'body' but no parameter is named 'body'; the closest is 'json', whose schema description already says 'JSON text to validate; discarded after the check'. The description does not clarify the roles of the other eight parameters, so it does not enhance understanding 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 whether a body is valid JSON') but the input schema contains 9 parameters with a wide range of purposes (URL, city, feed, host, path, zone, query) that are not mentioned. The name 'validate-json' reinforces the JSON focus, but the broad schema suggests the tool is more general, so the purpose is ambiguous and does not clearly distinguish it from sibling validators like 'domain-shape' or 'file-path-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 is provided on when to use this tool versus alternatives such as 'domain-shape', 'file-path-ok', or 'fetch-status'. The description does not mention any exclusions or conditions. An agent must infer usage solely from the name, which is insufficient for a tool with nine parameters that likely cover multiple validation scenarios.

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, but it only mentions retrieving temperature. It does not disclose that parameters are discarded, that network calls are involved, or any other side effects. The schema hints at discarding but the description adds no behavioral context.

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

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

The description is a single sentence with no wasted words, making it highly concise. However, its brevity borders on under-specification, though for conciseness it earns a high 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, no output schema, and no annotations, the description is severely incomplete. It fails to explain the purpose of the other parameters, the return format, or when to use it, leaving an agent with almost no guidance beyond the schema.

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

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

Schema description coverage is 100%, so each parameter is individually described. The tool description adds no additional meaning beyond the schema's per-parameter explanations, which already cover the semantics. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description states 'Current temperature for a city via Open-Meteo', which is a clear verb+resource, but the input schema includes 9 unrelated parameters (ref, url, json, path, zone, query, etc.) that suggest a broader generic hint tool. This mismatch makes the purpose ambiguous and fails to distinguish from siblings like geo-hint or lib-docs-hint.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any preconditions, exclusions, or sibling tools, leaving an agent without any contextual basis for selection.

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

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

With no annotations, the description is the only behavior source, and it does disclose two meaningful traits: the body is discarded and only public URLs are in scope. It does not mention network side effects, error behavior, redirects, or the fact that non-url parameters are ignored. This is adequate but leaves several operational gaps.

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, and both sentences carry useful information: what is returned and what is not. The key constraint, 'Body discarded', is front-loaded in the second sentence. Nothing extraneous is present.

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

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

Despite 9 optional parameters, no required parameters, no output schema, and no annotations, the description only covers URL status/content-type checks. An agent cannot tell whether the other eight parameters are alternate invocation modes or distractors, nor what the response/error format looks like. This is not complete enough for reliable invocation in ambiguous cases.

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

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

Schema description coverage is 100%, so the schema already documents each parameter's meaning and even notes discarded values, establishing the baseline of 3. The description adds no parameter-level information beyond the notion of a public URL. It also does not tell the agent which of the nine optional parameters is the relevant one for 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 states a concrete result: HTTP status and content type for a public URL, and adds that the body is discarded, which gives the agent a clear sense of the operation. It does not explicitly contrast siblings like fetch-status or browser-url-ok, but the 'body discarded' qualifier differentiates it from content-returning fetches. The presence of nine unrelated optional parameters in the schema is not reflected in the description, so this is clear but not fully complete.

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 phrase 'public URL' and 'Body discarded' imply when the tool is appropriate and when it is not: it is for lightweight URL checks, not for retrieving page content or private URLs. However, the description gives no explicit alternatives or conditions, even though siblings such as fetch-status and browser-url-ok exist. The guidance is mostly implied rather than stated.

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

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

No annotations are present, so the description must disclose behavior. It only notes 'Title discarded after the call,' which is unhelpful, and it fails to mention the return type, side effects, or error conditions. This is insufficient for a tool with nine optional parameters.

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

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

The description is a single concise sentence, but it is under-specified and lacks essential details. It is not appropriately sized for a tool with nine parameters and no other documentation.

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 and no output schema, the description is grossly incomplete. It does not explain what the tool returns, how to select the title parameter, or any constraints on inputs, making correct invocation impossible.

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

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

The schema has 100% coverage, so each parameter has a description, but the tool description does not explain how any parameter relates to the Wikipedia title check. The schema descriptions (e.g., 'Git ref name', 'City name for a public weather hint') appear unrelated, and the description does not clarify which parameter is the title.

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

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

The description states a clear verb and resource ('Check whether a Wikipedia title exists'), but it does not identify which of the nine input parameters provides the title, making the purpose ambiguous. It also does not distinguish this tool from siblings like browser-url-ok or file-path-ok.

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

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

There is no guidance on when to use this tool versus alternatives. No prerequisites, exclusions, or comparisons are provided, leaving the agent without any selection criteria.

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