TE / transfer-encoding token shape

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

With no annotations, the description carries the burden. It discloses that task text and several parameters are discarded, and explicitly notes 'no disk access' for the path parameter. However, it omits details on side effects, rate limits, or the exact nature of 'connection methods,' so transparency is partial.

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

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

The description is two sentences, front-loading the primary purpose and return type. It is concise and free of fluff, though it could benefit from a hint on parameter selection.

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

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

For a tool with 9 parameters and no output schema, the description is insufficiently complete. It does not explain how parameters relate to the requested task, which parameters to supply for a given gateway, or what the connection methods look like. An agent would struggle to invoke it correctly without more guidance.

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 the schema already documents all parameters. The description adds only task examples (weather, search, scrape, voice) without mapping them to specific parameters, providing minimal additional semantic value beyond the schema.

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

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

The description clearly states a specific action (find a gateway) and its purpose (for tasks like weather, search, scrape, voice), and notes the return type (connection methods). However, it does not explicitly differentiate from sibling tools, though its meta-tool nature is implicit.

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 examples of tasks but no guidance on when to use this tool over siblings, nor any conditions or exclusions. There is no mention of alternatives or when not to use it, leaving usage largely 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?

With no annotations, the description carries full responsibility for behavioral disclosure. It states that no browser is launched, but does not describe what the tool actually does instead (e.g., network request, syntax validation, shape checking), nor whether it is read-only, has side effects, or handles errors. This is minimal and insufficient for a tool with such a broad parameter set.

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, front-loaded with the action and then a clarifying caveat. Every word earns its place, and there is no padding. However, the brevity contributes to under-specification in other dimensions, which slightly reduces the effectiveness of this concise structure.

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

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

For a tool with 9 parameters, no annotations, and no output schema, the description is drastically under-specified. It does not explain how the parameters map to the tool's behavior, what the tool returns, or any side effects or prerequisites. This is inadequate for an agent to use the tool correctly.

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

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

Schema coverage is 100%, so each parameter has a description. However, the tool description adds no meaning beyond the schema; it fails to explain why parameters like city, zone, and json are relevant to checking a URL. The baseline of 3 applies because the schema is thorough, but the description does not enrich the parameter understanding or resolve the apparent mismatch.

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

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

The description 'Check whether a URL can be opened' provides a specific verb and resource, and notes that no browser is launched. However, it does not clarify that the tool accepts 9 heterogeneous parameters (city, json, zone, etc.), so the stated purpose is narrower than the schema suggests. It also does not differentiate from sibling tools like playwright-url-ok or other shape-checkers beyond the no-browser note.

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

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

The only hint is 'No browser is launched,' which implies this is a lighter alternative to playwright-url-ok, but it never explicitly says when to use this tool versus others. There is no mention of conditions, exclusions, or alternatives, leaving the agent to infer when this tool is appropriate.

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

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

No annotations are provided, and the description doesn't disclose behavior beyond the vague 'Evaluate' and 'Expression discarded.' It doesn't mention side effects, error handling, performance characteristics, or any constraints on the input (e.g., max length, supported operators). The reader cannot infer what happens on invalid input or if the tool has any side effects.

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

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

The description is concise (two short sentences), but the structure is poor. The first sentence is grammatically awkward ('Evaluate a+b style arithmetic') and the second is unclear. The description uses odd phrasing like 'Expression discarded' which is redundant with parameter descriptions. While not overly verbose, it is not well-structured for 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 the tool has 9 parameters and no output schema, the description is extremely incomplete. It doesn't explain how the parameters relate to the tool's function, what the expected output is, or how this tool fits into the broader context of sibling tools like 'calculate' or 'math-eval'. The lack of clarity on the tool's purpose and parameters makes it nearly impossible for an agent to correctly 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?

Although the schema covers 100% of parameters, the descriptions of the parameters are generic and seem copied from other contexts (e.g., 'Git ref name', 'HTTPS URL', 'City name'). The parameter descriptions do not relate to the stated purpose of evaluating arithmetic. For instance, 'query' says 'Search text; discarded after the length check' which contradicts the arithmetic purpose. The description doesn't explain how these parameters map to the tool's function, so the semantics are confusing and 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 'Evaluate a+b style arithmetic. Expression discarded.' is vague about what the tool actually does. It says 'Evaluate' but doesn't specify the verb clearly (e.g., 'calculate', 'compute'), and the resource is ambiguous. It also doesn't distinguish the tool from siblings like 'validate-json' or 'search-query-len' beyond the arithmetic hint, which is insufficient.

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 doesn't mention scenarios, prerequisites, or exclusions. For example, it doesn't clarify that this tool is for arithmetic expressions only, not for search or validation, and doesn't reference sibling tools like 'validate-json' or 'search-query-len'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose one behavior ('Page content is not stored'), but it completely fails to explain why the schema accepts nine unrelated inputs (city, zone, json, path, query, feed, host, ref) when the stated purpose is a URL check. This internally contradictory surface behavior is left 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?

Two sentences with zero wasted words, and the purpose is front-loaded. But the brevity actively hides complexity: a nine-parameter tool with decoy inputs is written as if it only concerns URLs. The conciseness is earned for the stated purpose but misleading given the actual schema surface.

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

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

This is a complex tool (9 optional parameters, no annotations, no output schema) yet the description is only two sentences. It does not explain which parameter drives the result, what happens with the decoy inputs, or how it differs from siblings. For a tool of this complexity the description is substantially undersized.

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

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

Schema description coverage is 100%, so the baseline is 3 even with no parameter detail in the description. The description adds nothing about parameters, and its stated URL purpose actually conflicts with the eight non-URL parameters. The schema's own 'discarded' notes carry the semantic weight, so the description neither helps nor hurts beyond baseline.

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

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

The description states a specific verb and resource: 'Return host, scheme, and HTTP status for a URL.' That is clear and actionable on its own. However, it does not distinguish this tool from the many overlapping URL/status siblings (fetch-status, browser-url-ok, web-fetch, normalize-url), so an agent cannot tell them apart from the description alone.

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 citation versus any of the numerous overlapping siblings (fetch-status, browser-url-ok, domain-shape, normalize-url, web-fetch). There is no when/when-not framing, no named alternative, and no selection condition. An agent has no way to pick this over fetch-status or browser-url-ok.

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

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

With no annotations provided, the description must disclose behavior. It only states 'No identifiers are retained', a privacy note, but does not explain side effects, network access, or return format. It does not clarify whether the tool is read-only, whether it performs remote calls, or what happens to the input data beyond discarding some fields (which is only hinted in the schema). The behavioral transparency is severely lacking.

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 avoids verbosity, but it is too under-specified to be effective. It does not front-load key information (purpose, usage) and instead provides a generic statement. The brevity is not a virtue here because it omits essential details that an agent needs.

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

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

Given the tool's complexity (9 optional parameters, no annotations, no output schema), the description is grossly incomplete. An agent cannot determine what classification categories exist, how to interpret the output, or how to select this tool over siblings. The description provides almost none of the context needed for correct invocation, making it 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?

The schema description coverage is 100%, with each of the 9 parameters having a detailed description (e.g., 'Git ref name; discarded after the shape check'). The description adds no additional parameter semantics, but since the schema already documents each parameter thoroughly, the baseline of 3 is appropriate. The description does not compensate for or enhance 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 'Show how this request is classified' but never defines what 'classified' means, what categories are used, or what the output looks like. It does not distinguish itself from the many sibling tools (e.g., validate-json, normalize-url) that each target a specific input type. The verb 'show' and resource 'how this request is classified' are too vague to guide an agent.

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

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

There is no guidance on when to use this tool versus its siblings. The description does not mention any conditions, alternatives, or exclusions. Given the broad set of input parameters (ref, url, city, feed, etc.), an agent has no way to know if this tool is appropriate for a given request without further 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?

The phrase 'without WHOIS or ownership data' provides a small behavioral constraint, and some parameter descriptions mention 'discarded' or 'no disk access', but the main description does not state side effects, data retention, network use, or return behavior.

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

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

The description is one short sentence and front-loads the action, so it is concise; however, the second clause is vague and the brevity hides the mismatched parameter surface.

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

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

With 9 optional parameters, no output schema, and no annotations, the description is far from complete; it does not explain what the tool returns, how the parameters relate to the domain operation, or what 'shape check' means in each case.

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

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

Although schema coverage is 100%, the parameter descriptions are confusing and inconsistent with the description: e.g., 'Git ref name', 'IANA timezone name', and 'City name for a public weather hint' have no clear relationship to splitting a hostname, and the 'discarded after...' notes do not explain how the values are used.

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

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

The description says 'Split a hostname into labels', which is a clear verb/resource, but the tool accepts 9 unrelated optional parameters (ref, url, city, feed, json, zone, query), so the stated purpose does not match the actual parameter surface and doesn't distinguish from sibling tools like normalize-url or validate-json.

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

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

No conditions or when-to-use guidance are provided; there is no mention of when to choose this tool over the many sibling shape-checking tools, nor any indication of what input types are expected.

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

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

No annotations are provided, so the description carries the full burden. It discloses the HEAD method and that only status is returned, which is useful, but it says nothing about the other parameters' behaviors (e.g., discarding values after shape checks) or about authentication, rate limits, or what happens when multiple parameters are supplied. The schema mentions 'discarded after the shape check' for several params, but this is not in 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?

The description is a single sentence with no wasted words, which is concise. However, it is under-specified for a tool with nine parameters and no annotations, so while the structure is fine, the brevity comes at the cost of essential information.

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

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

For a tool with nine optional parameters, no output schema, and no annotations, the description is grossly incomplete. It omits the multi-purpose nature implied by the schema, does not clarify return values or error handling, and provides no context on how the parameters are used. An agent would not know which parameter to pass for the described behavior or whether other parameters trigger different checks.

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

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

Schema coverage is 100%, so each parameter has a description, but the tool description adds no guidance on which parameter is the URL for the HEAD request. The schema describes 'url' as 'HTTPS URL to normalize or cite', which conflicts with the description's implication that a URL is checked for status. The relationship between the described action and the parameters is unclear, and the description does not compensate for this ambiguity.

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

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

The description states a specific action ('HEAD a public URL and return status only'), which is clear for that single case. However, it fails to convey that the tool accepts nine other parameters (ref, city, feed, host, json, path, zone, query) with purposes like validating JSON or checking timezones, making the overall purpose ambiguous and indistinguishable from siblings like browser-url-ok or web-fetch.

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 such as web-fetch, browser-url-ok, or validate-json. The description only implies a use case for URL status checks but does not mention exclusions 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?

With no annotations, the description carries the full burden of behavioral disclosure. It mentions 'Path discarded,' which hints at one behavior, but it does not explain the outcome of the parse, whether it returns a boolean, a normalized URL, or an error. It also fails to disclose that the tool appears to discard most of the provided parameters, as suggested by the schema descriptions.

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 efficiently concise. It lacks structure and fails to front-load essential information about the tool's behavior or use cases.

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

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

For a tool with nine parameters, no output schema, and no annotations, the description is grossly inadequate. It does not explain the return value, the relationship between parameters and purpose, or how to distinguish this tool from siblings. An agent cannot reliably call this tool based on the description alone.

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

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

Although the schema coverage is 100%, the description adds no meaningful clarification about which parameter is actually used or how the parameters relate to the stated purpose. The schema lists parameters like 'city' and 'zone' that are unrelated to a Figma URL, and the description does not reconcile this, leaving the agent without guidance on what to pass.

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

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

The description states a verb and resource: 'Parse a Figma file URL.' This is more than a tautology, but it is vague about what 'shape' means and what the tool actually returns. It does not mention that the tool likely validates or normalizes the URL, and the schema with nine unrelated parameters creates confusion about the tool's true scope.

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

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

There is absolutely no guidance on when to use this tool versus the many sibling URL-related tools (e.g., normalize-url, browser-url-ok, github-repo-shape). The description does not mention any conditions, alternatives, or exclusions.

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

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

The description states 'No disk access' and parameter descriptions say values are 'discarded after the shape check', implying no side effects. However, it does not disclose what the output looks like, what 'safe' means, or that most parameters are accepted and then ignored except for shape validation.

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

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

The description is one short sentence and does not waste words. The 'No disk access' addition is useful and the overall text is compact.

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 many similar siblings, but the description gives no information about expected usage, return format, or which parameter is authoritative. This makes it nearly impossible for an agent to invoke correctly without additional context.

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

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

Although schema descriptions cover every parameter, they are mostly tautological: 'Git ref name; discarded after the shape check' or 'Search text; discarded after the length check'. The criteria for a valid shape are never specified, and the 'path' description omits safety rules.

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?

Description says 'Check whether a path looks safe' but the schema exposes 9 unrelated parameters (url, city, feed, host, json, zone, query, ref) with descriptions like 'discarded after the shape check'. The intended scope is ambiguous: it might be a generic shape-check tool, but the description only mentions path.

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 siblings like normalize-url, domain-shape, or browser-url-ok. The description does not clarify which parameter to provide or how this differs from other shape-checking tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It names the provider but does not explicitly disclose that this triggers an external network call, say nothing of failure modes, rate limits, or which of the 9 parameters actually feeds the lookup. The schema hints that most params are 'discarded,' which is unaddressed by 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?

A single front-loaded sentence with no filler. It is appropriately concise and states the core action immediately, though it pays for that brevity by omitting the context that other dimensions needed.

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 calling an external weather-geocoding API, this is under-specified: there is no output schema, no parameter mapping, no error or availability behavior, and no statement of what is returned. Against a backdrop of 9 generic parameters and no annotations, the single sentence leaves an agent materially uninformed about how to call it correctly.

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

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

Schema coverage is 100%, which normally sets a baseline of 3, but the parameter descriptions are generic boilerplate ('discarded after the shape check', 'no disk access') that appear shared across sibling tools and do not map to a geocoding operation. The description adds no information about which parameter (likely 'city' or 'query') supplies the place, leaving the core input ambiguous.

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 geocoding purpose ('Latitude and longitude for a place via Open-Meteo') with a specific resource and external provider. However, it offers no differentiation from sibling tools like weather-hint, timezone, or iana-zones, and the 9-parameter generic schema (ref, url, feed, host, json) does not obviously align with a lat/long lookup, leaving the agent to guess which tool this actually is.

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 geo-hint versus alternatives such as weather-hint or iana-zones, and there are no exclusions or prerequisites. The description does not even hint at the intended call scenario, so an agent gets no help deciding between this and the adjacent hint-style siblings.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions parsing owner/repo and does not state that the tool is a pure validation/parse with no side effects (though schema hints at 'discarded'), nor does it explain return values or how it handles the other 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 one short sentence, which is concise but severely under-specified. It omits critical information about parameter usage and tool scope, so the brevity works against clarity rather than for it.

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

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

With nine parameters, no output schema, and no annotations, the description is grossly incomplete. An agent cannot determine which parameter to pass, what the tool returns, or how it behaves across different inputs. The mismatch between the description and schema makes it nearly unusable.

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

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

The schema description coverage is 100%, so each parameter has a basic description (e.g., 'discarded after the shape check'). The tool description adds no extra meaning about which parameter is relevant for GitHub parsing or how parameters relate to each other, but the baseline is 3 given full schema coverage.

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

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

The description says 'Parse owner and repo from a GitHub URL,' which states a clear verb and resource. However, the input schema contains nine unrelated parameters (city, feed, json, path, zone, query, etc.) that are not mentioned in the description, making the tool's actual scope ambiguous. It does not distinguish itself from sibling shape-checkers like domain-shape or figma-url-shape.

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

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

There is no guidance on when to use this tool versus its siblings or on which parameter to supply for a GitHub URL. The description offers no conditions, exclusions, or alternative tools, leaving the agent to guess.

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

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

With no annotations, the description must disclose behavior. It only says 'Titles discarded,' which hints at output filtering but does not explain side effects, rate limits, or how inputs are used. The schema hints that parameters are 'discarded after the shape check,' but the description itself adds almost no behavioral context beyond the purpose.

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—two sentences—and front-loads the core action. It is efficient with no wasted words. However, the brevity leaves critical gaps, which is a trade-off, but for conciseness alone it scores well.

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

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

The tool has nine optional parameters, no required ones, and no output schema. The description fails to explain how to invoke the tool correctly, what input is expected, or what the output format is. It is completely inadequate for an agent to use this tool safely or effectively.

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

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

Schema description coverage is 100%, so each parameter already has a description explaining its role and that it is discarded. The tool description adds nothing beyond that—no additional meaning, syntax, or relationships. The baseline of 3 applies because the schema does the heavy lifting.

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

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

The description clearly states the tool counts current Hacker News front-page stories, a specific verb+resource. However, it does not explain how the nine optional parameters relate to this purpose, and it doesn't distinguish this tool from siblings like web-fetch or fetch-status, which could also interact with URLs. The added phrase 'Titles discarded' is ambiguous—discarded from input or output?

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

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

No guidance is provided on when to use this tool versus alternatives. It never mentions alternatives, prerequisites, or typical invocation scenarios. An agent has no basis to choose this tool over similar ones.

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 behavioral information is provided. The description does not state whether the tool is read-only, whether it has side effects, or what it returns. The lack of annotations and any behavioral hints leaves the agent completely in the dark about how the tool behaves.

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

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

The description is concise but lacks structure. It consists of a single phrase that does not clearly explain the tool's function. While brevity is good, the lack of structure and detail makes it minimally useful.

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

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

The description is highly incomplete. It does not explain what the tool outputs, how it relates to 'clock calls', or why the various unrelated parameters exist. There is no indication of the return value or any example usage, leaving the agent without enough context to use it correctly.

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

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

The parameter descriptions are misleading and irrelevant. Nine parameters are present, but only one ('zone') relates to timezone names, while others like 'ref', 'url', 'city', and 'feed' have descriptions that appear copied from other tools and do not make sense in this context. The schema coverage is high but the semantic value is poor.

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

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

The description states 'Common IANA timezone names for clock calls,' which gives a vague hint that the tool provides timezone names, but it lacks a clear verb or action. It does not specify whether it lists, validates, or retrieves timezone data, and it is not clearly distinguished from sibling tools like 'timezone' that might perform related tasks.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention use cases, prerequisites, or situations where this tool is preferred over others like 'timezone' or 'utc-time'.

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 transparency burden. It discloses that it fetches a public resource and returns only counts, but it doesn't mention network behavior, failure modes, rate limits, or data handling beyond the schema's scattered 'discarded' notes.

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 could have been slightly longer to clarify parameter mapping, but as written it is appropriately concise.

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

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

Given a 9-parameter optional schema, no output schema, and no annotations, the description is too sparse to be fully actionable. It doesn't explain how the parameters relate to the robots.txt fetch, what the returned 'group counts' look like, or how errors are reported.

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

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

The schema has 100% description coverage, but the parameter descriptions are largely inconsistent with the stated purpose: 'url' refers to normalizing/citing, and city, zone, json, query, etc. appear unrelated to robots.txt. This leaves unclear which parameter should contain the robots.txt URL, making the mappings misleading despite full coverage.

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

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

The description states a specific action ('Fetch a public robots.txt') and output ('return group counts only'), which makes the core purpose clear. However, it doesn't distinguish this from sibling fetch tools like web-fetch or fetch-status, and the input schema doesn't expose an obvious robots.txt URL parameter.

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

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

There is no explicit guidance on when to use this tool instead of alternatives like web-fetch or fetch-status. The phrase 'return group counts only' implies a narrow use case, but it doesn't state when-not-to-use or explain how the required URL should be supplied.

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

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

The only behavioral disclosure is 'Key discarded', implying the input is not persisted. However, it doesn't describe what the shape check entails, whether it makes network calls, or what the return value looks like. With no annotations, the description carries full burden and fails to disclose enough.

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

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

The description is very short (two sentences), which is concise, but it lacks structure and essential details. It's not front-loaded with actionable guidance; it just states the action and discards the input.

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. An agent cannot determine which parameter to use for the Jira key, how the check behaves, or what success looks like. This is inadequate for correct invocation.

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

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

All 9 parameters have schema descriptions with 100% coverage, so the baseline is 3. The description adds no meaning beyond the schema, and the mapping between parameters and a Jira key is unclear—none are named 'key' or 'issue'. The schema descriptions themselves are the only useful part.

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

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

The description states the tool 'checks a Jira issue key shape', which is a specific action on a specific resource, but it doesn't specify which of the 9 parameters represents the key, nor does it differentiate from sibling shape tools like domain-shape or github-repo-shape. The purpose is ambiguous in practical application.

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

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

No guidance is given on when to use this tool versus the many sibling shape-checking tools. It doesn't state that it's for Jira issue references or provide any exclusions. The usage context is left entirely to inference.

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

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

With no annotations, the description carries the behavioral burden. It does provide one useful behavioral detail: 'Body discarded,' clarifying that the response body is not returned. However, it does not mention network access, error behavior, redirects, rate limits, or which inputs are actually discarded, so the feedback is incomplete.

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, front-loaded with the primary purpose and followed by a useful behavioral limitation. Every sentence earns its place and there is no repetitive or wasted wording.

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

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

This is a 9-parameter tool with no required parameters, no output schema, and no annotations, so the description must carry substantial context. It does not explain the expected return format, whether one field must be supplied, how to select among the many parameter variants, or what 'hint' means in relation to a full fetch. The basic invocation contract is underspecified.

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 per-field descriptions already explain each parameter. The top-level description adds no parameter-specific meaning and is even slightly misaligned by mentioning only 'library docs URL' while the schema includes city, zone, json, and query fields. Since the schema carries the semantics, the baseline of 3 is still warranted.

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

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

The description states a specific action and artifact: it returns an HTTP status for a public library docs URL, and clarifies that the response body is discarded. It is clear enough to convey the core purpose, but it does not explicitly distinguish itself from sibling tools like fetch-status or browser-url-ok, so it stops 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?

No usage guidance is provided: there is no mention of when to use this tool over fetch-status, browser-url-ok, normalize-url, or the other siblings, no prerequisites, and no indication whether one specific parameter among the nine is expected. The agent must infer all routing and invocation context from the 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?

No annotations are present, and the description does not clarify side effects, error behavior, or whether all parameters are ignored except one. The parameter descriptions state values are 'discarded' or 'checked' inconsistently, creating confusion about what the tool actually does with the inputs.

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

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

The description is only one sentence and thus highly concise, but it is structurally inadequate because it fails to mention the required 'json' parameter or how to interpret the other 8 parameters. The brevity works against 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?

With no output schema and 9 parameters, the description provides no context about what counts as a key, what the return format is, or how the tool behaves with invalid JSON. The tool is completely underspecified and cannot be used reliably.

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 descriptions cover 100% of parameters, they are misleading relative to the tool's stated purpose. For example, 'json' says 'validate' not 'count keys', and other parameters like 'city' or 'zone' have no possible relation to counting keys. The schema adds no meaningful semantics that help an agent use the tool correctly.

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 'Count keys in a JSON object' is clear in isolation, but the input schema lists 9 unrelated parameters (ref, url, city, feed, host, path, zone, query) with no indication which one contains the JSON object. This makes the actual purpose ambiguous and fails to distinguish it from siblings like validate-json or search-query-len.

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, which parameter to provide, or how to construct a valid call. The description does not mention any required input or selection criteria, leaving the agent with no usable 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?

Annotations are absent, so the description carries full burden. It does disclose that query and fragment are dropped, which is a useful behavioral trait. However, it does not mention error handling, invalid URL behavior, or the exact return format (e.g., string vs. object), which are typical behavioral details an agent might need. It provides minimal but non-contradictory transparency.

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

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

The description is a single, front-loaded sentence with zero filler. It clearly states the output and the key transformation (dropping query/fragment). This is appropriately concise and well-structured for a simple tool.

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

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

Given the tool has 9 parameters and no output schema, the description is incomplete. It explains only URL normalization but does not address why other parameters exist, how results are returned, or any edge cases. The mismatch between the description and the parameter list suggests a significant gap in completeness. An agent would struggle to know how to invoke this tool correctly with so many unrelated parameters.

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

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

Schema coverage is 100%, so all 9 parameters are documented in the schema itself. The description adds no parameter-specific meaning; it only mentions 'URL' generically. The schema's descriptions for parameters like 'city' and 'feed' seem unrelated to the stated purpose, but the description does not clarify their role. Baseline 3 applies because the schema handles documentation, but the description fails to enrich or reconcile the parameter list.

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

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

The description clearly states the tool's purpose: returning origin, host, and path from a URL while dropping query and fragment. It is specific with a clear verb and resource. However, it does not explicitly differentiate from sibling URL tools like browser-url-ok or playwright-url-ok, which also handle URLs, so it loses a point for lack of sibling distinction.

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

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

There is no guidance on when to use this tool versus alternatives. The description merely states what it does without mentioning use cases, exclusions, or when another tool would be more appropriate. With many sibling URL-related tools, this omission is significant.

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 reveals that no browser is launched and that some parameters are 'discarded.' It does not state what happens to the URL (whether it's fetched, syntactically checked, etc.), what the tool returns, or side effects. The 'discarded' notes are partial and inconsistent (e.g., url, host, path, zone have no such note).

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 main description is concise and front-loaded with the purpose and key constraint (no browser). It avoids unnecessary words. However, it is under-specified overall, which is a completeness issue rather than a conciseness flaw.

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

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

For a tool with 9 optional parameters, no required fields, no output schema, and no annotations, the description is severely incomplete. It does not explain the role of most parameters, what the tool returns, error conditions, or when to use it. An agent would be unable to call it correctly for anything beyond a simple URL check.

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

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

Schema description coverage is 100%, so each parameter is documented in the schema. The description adds a small amount of value by noting which parameters are discarded (ref, city, json, query), but it does not add meaning beyond the schema for the core parameters like url, host, or path. Baseline of 3 is appropriate.

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

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

The description states a clear verb and resource: 'Check whether a URL can be opened.' It also distinguishes from sibling 'browser-url-ok' by noting 'No browser is launched.' However, the presence of many unrelated parameters (city, json, path, zone, etc.) creates ambiguity about the tool's actual scope, so it's not a 5.

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

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

There is no guidance on when to use this tool versus alternatives like browser-url-ok or normalize-url. It does not state conditions, prerequisites, or exclusions. The only hint is 'No browser is launched,' which implies a lightweight check, but this is not explicitly framed as a usage rule.

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

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

The description mentions that the query is discarded, hinting that no persistent storage occurs, but does not explain that other parameters are ignored or what the return value is. With no annotations provided, more behavioral detail would be expected.

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 free of unnecessary words, which fits a simple utility. The two-sentence structure is straightforward, though it omits critical context about 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?

Given the presence of 9 parameters and a single-focused purpose, the description is incomplete. It does not clarify that all parameters except 'query' are irrelevant, nor does it describe the output format or behavior when 'query' is absent. This leaves the agent to figure out the intended usage from the schema alone.

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

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

The schema descriptions cover all 9 parameters, including a clear description for the 'query' parameter as 'Search text; discarded after the length check.' However, the description does not add any extra meaning beyond the schema, such as emphasizing that only 'query' is significant, leaving the purpose of other fields unclear.

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

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

The description clearly states the primary action: counting characters in a search query. The phrase 'Query discarded' is slightly ambiguous but does not obscure the core purpose. The tool name reinforces the intent.

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

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

The description gives no indication of when to use this tool versus any alternative. It does not mention which parameters are relevant or that only 'query' is used, leaving the agent to infer from the 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?

The description discloses no behavioral traits such as read-only, side effects, or data usage; with no annotations, it fails to inform the agent of any safety or action characteristics.

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

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

The description is extremely short, which is concise, but it lacks structured information such as return type or conditions, making it unhelpfully terse.

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

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

Given 9 optional parameters and no output schema, the description provides no context on how the tool behaves, what it returns, or how parameters relate to the purpose.

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

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

The parameters are described with unrelated terms such as 'Git ref name' and 'City name' that have no connection to HTTP status codes, and the tool description does not clarify their meaning for this tool, leaving the schema 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 is a noun phrase 'Short catalog of common HTTP status codes' that lacks a verb or action, and does not explain what the tool does with inputs or outputs. It is distinguishable from siblings only by theme but not by function.

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

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

There is no guidance on when to use this tool versus other tools like fetch-status or web-fetch; the description does not mention alternatives or conditions.

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

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

There are no annotations and the description does not disclose any behavioral aspects. Parameter hints like 'discarded after the shape check' imply read-only validation, but the overall behavior remains opaque.

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

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

The description is excessively terse, consisting of a single cryptic phrase. While concise, it sacrifices necessary clarity and does not effectively communicate the tool's function.

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

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

With 9 optional parameters, no output schema, and no explanation of return values or validation semantics, the description is severely incomplete. An agent cannot understand what the tool does or what to expect from it.

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

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

The schema provides minimal descriptions for each parameter, but they are inconsistent and unclear (e.g., 'HTTPS URL to normalize or cite' for a tool named 'te-ok'). The descriptions hint at validation but do not meaningfully explain the purpose of each parameter.

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 'TE / transfer-encoding token shape' is highly ambiguous and does not state a clear action or resource. It fails to explain what the tool does, unlike sibling tools such as 'validate-json' or 'fetch-status'.

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

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

No guidance is provided on when to use this tool versus alternatives. The description offers no context for selection, leaving an agent without any basis to choose it over related validation or fetch 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?

The description openly states that the prompt is discarded, and the parameter descriptions reinforce that each value is checked and then discarded (e.g., 'discarded after the shape check', 'no disk access'). Since no annotations are provided, this transparency is helpful, though it does not fully specify validation failure behavior.

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

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

The description is very short and front-loaded, with only two sentences and no extraneous detail. The second sentence is slightly confusing because 'Prompt' is not a schema parameter, but the wording is still compact.

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

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

The description leaves the relationship between the 9 input parameters and the returned template unexplained, and it never says that all parameters are optional or that the tool can be called with no arguments. For such a generic template tool, this missing context makes it hard for an agent to know how to invoke it correctly.

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

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

The input schema has 100% description coverage and already tells the agent what each parameter represents and that values are discarded, so the main description does not need to add much. It does not clarify why nine unrelated parameters are accepted, but it does not need to improve on the 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 states that the tool returns a three-step thinking template, giving a clear verb and object. However, the phrase 'Prompt discarded' introduces ambiguity because there is no 'prompt' parameter in the schema, and the nine input parameters are not explained in the main description.

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

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

The description provides no guidance about when to use this tool instead of the many sibling checkers, nor does it mention whether it should be called with no arguments or with one of the listed parameters. No alternatives are named or excluded.

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

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

Without annotations, the description carries the transparency burden, and it only states the basic behavior. It does not mention error handling, output shape, or explicit read-only status, although the nature of the tool implies a read-only lookup.

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

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

The description is a single concise sentence with no redundant wording. It front-loads the core purpose effectively.

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 large set of optional parameters and no output schema, the one-line description is insufficient. It does not explain which parameter to use, why the other parameters exist, or what the tool returns.

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

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

The schema provides descriptions for all parameters, but most are unrelated to timezone lookup and appear to be copied from other tools (e.g., ref, url, json, query). Only 'zone' is semantically relevant, and the description does not clarify the role of the other optional parameters.

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

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

The description 'Current time in a named IANA timezone' clearly identifies the tool's function and resource. It does not explicitly use an imperative verb, but the intent is unambiguous and distinct from sibling tools like 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 usage conditions or comparisons with alternatives are provided. The description states what the tool does but not when to choose it over utc-time or other time-related tools.

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

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

With no annotations and only the phrase 'Current UTC timestamp', the description does not disclose that all input parameters are apparently ignored or discarded (as hinted by property descriptions like 'discarded after the shape check'). It also does not state whether the operation is pure or has side effects, leaving behavioral assumptions to the agent.

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 unnecessary words or repetition. It is well-structured and easy to parse.

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 a complex and confusing schema with nine optional parameters, but the description does not clarify their relevance or indicate that they are ignored. It also does not specify the return format of the timestamp (e.g., ISO 8601, epoch), leaving important context missing for an agent to use it correctly.

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

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

The schema has 100% coverage with each parameter described individually, many noting they are discarded or not used. However, the tool description itself does not explain why these parameters exist for a UTC timestamp tool, so the descriptions do not integrate meaningfully with the intended purpose. The baseline of 3 is appropriate due to high schema coverage.

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

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

The description 'Current UTC timestamp' clearly indicates the primary function, but the input schema includes many unrelated optional parameters (e.g., 'ref', 'url', 'city') that obscure the purpose and suggest the tool may do more. It is not as clear as a simple 'Get the current UTC time' with an empty 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?

There is no explicit guidance on when to use this tool versus sibling tools like 'timezone' or 'iana-zones'. The description implies it is for getting a UTC timestamp, but it does not mention alternatives, exclusions, or when not to use it.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It only states that 'the body is discarded,' which is vague and does not disclose what the tool returns (e.g., boolean, error), side effects, or any constraints. Behavioral transparency is almost entirely absent.

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

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

The description is two sentences long, which is concise. However, the second sentence 'The body is discarded' is redundant and adds confusion rather than clarity. The content is front-loaded with the purpose, but the extra sentence does not earn its place.

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

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

For a tool with 9 optional parameters and no output schema or annotations, the description is severely incomplete. It does not explain which parameter to use, what the tool returns, or how the other parameters relate to validation. The agent cannot correctly invoke this tool without opening the schema and inferring details that are absent from 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?

Schema descriptions cover 100% of parameters, so the schema already explains each one (e.g., 'json' is 'JSON text to validate; discarded after the check'). The description adds no additional meaning beyond the schema. It does not clarify the relationship between the many unrelated parameters (url, city, feed, etc.) and the core JSON validation purpose, which baseline 3 does not require.

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

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

The description states a clear action (check if a body is valid JSON) but refers to an undefined 'body' and never clarifies which input parameter carries the JSON. It is distinct from siblings but only because no other tool is about JSON validation; it does not explain scope or what 'valid' means.

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. With 26 siblings, there is zero differentiation or mention of conditions, exclusions, or related tools. The agent is left to guess based on the name alone.

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

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

The description only states the high-level function. It does not disclose whether the tool performs a network request, whether it is read-only, any side effects, or what inputs are needed. Given no annotations exist, this is insufficient for full transparency.

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

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

The description is a single, concise sentence with no superfluous words. It follows a clear pattern: 'Current temperature for a city via Open-Meteo.'

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 large number of unrelated parameters and no required fields, the description and schema do not provide enough context for an agent to confidently invoke the tool. There is no indication of what a typical call looks like or whether 'city' is required.

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 includes 9 parameters, but only 'city' is plausibly relevant to weather; others like 'url', 'feed', and 'json' appear copied from other tools. The parameter descriptions are generic and some say 'discarded after the call', which is confusing. The description does not clarify which parameters are required or optional.

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

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

The description clearly states the tool's function: 'Current temperature for a city via Open-Meteo.' This is a specific verb-resource pairing that distinguishes it from sibling tools like 'calc-eval' or 'fetch-status'.

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

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

No guidance is provided on when to use this tool versus alternatives. The description simply states the function without mentioning any conditions, alternatives, or exclusions, leaving the agent to guess.

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

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

The description only reveals that the body is discarded, which is a useful behavioral note. However, without annotations, it fails to disclose whether the operation is read-only, whether redirects are followed, or any rate limits—critical for a fetch 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 terse sentence that front-loads the core function. It is concise without fluff, though it could benefit from a bit more detail without harming conciseness.

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

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

With 9 optional parameters and no annotations or output schema, the description is woefully incomplete. It doesn't explain the varied parameters (city, feed, host, etc.) or when to use them, leaving the agent without enough context to invoke the tool correctly.

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

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

Schema coverage is 100% and each parameter has a descriptive comment, so the schema handles parameter semantics. The description adds no extra parameter guidance, but the baseline of 3 is met since no conflicts exist.

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: fetching a public URL and returning HTTP status and content type, with the body discarded. It distinguishes from body-returning fetches, though it doesn't explicitly contrast with siblings like fetch-status or browser-url-ok.

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

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

No guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, exclusions, or conditions that would select this tool over similar siblings, leaving the agent to infer use cases.

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 to disclose side effects, permissions, or data retention. The only behavior mentioned is 'Title discarded after the call,' which is vague and not aligned with the actual parameters (no 'title' parameter exists in the schema). It fails to clarify whether the tool performs network requests, reads local data, or has any side effects, leaving the agent blind to potential impacts.

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, making it concise and front-loaded with the main purpose. It avoids verbose explanations and gets to the point quickly. However, it is perhaps too sparse to be fully effective, but for the purpose of conciseness alone, it performs well.

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 and no output schema, yet the description provides almost no context on how these parameters relate to the action. It does not explain what constitutes a valid title, whether the check is case-sensitive, or what the return value indicates. The description is severely incomplete for an agent to use the tool correctly.

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

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

Although the schema provides descriptions for all 9 parameters, those descriptions are generic and clearly copied from other domains (e.g., 'Git ref name' for 'ref', 'HTTPS URL to normalize or cite' for 'url'). They do not relate to checking Wikipedia titles and likely mislead the agent. The coverage is technically 100%, but the semantic quality is almost nonexistent, offering no meaningful insight into how each parameter should be used.

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

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

The description clearly states the tool's function: 'Check whether a Wikipedia title exists.' It specifies a verb (check) and a resource (Wikipedia title), making the primary purpose unambiguous. However, it does not differentiate from sibling tools like browser-url-ok or file-path-ok, which also perform existence checks, so it misses the top score.

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

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

No usage guidance is provided beyond the one-line description. The description does not indicate when to prefer this tool over alternatives, nor does it give context about typical use cases (e.g., verifying a link before citation). There is no mention of prerequisites or conditions for use, leaving the agent without direction on when to invoke this tool.

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