Pacific/Pago_Pago clock

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

With no annotations, the description carries the transparency burden. It does reveal an important behavior: 'Task text discarded' and parameter descriptions say values are discarded after shape checks, suggesting no retention. However, it does not state whether the call is read-only, whether it triggers external/paid requests, or what side effects may occur.

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

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

Three short sentences front-load the main purpose and most actionable detail. There is no filler or redundant restating of the tool name or schema.

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

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

There is no output schema or annotations, so the description must explain both outputs and invocation context; it lists return artifacts but does not describe the response format or parameter usage. The discarded-parameter behavior is implied but an agent is not told whether it can call with no arguments or which shape to provide.

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

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

Schema coverage is 100%, so the baseline is 3; each parameter has a description. The tool description adds little beyond the schema, and it does not explain whether any of the six heterogeneous parameters is required or preferred, though the 'discarded' descriptions make them appear non-essential.

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

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

The description uses a specific verb ('Find') and resource ('public pay-per-call tool gateway (Monid)') and lists concrete return artifacts (CLI setup, how-it-works, skill file, remote MCP hops). It is clear about the tool's function, though it does not explicitly name sibling tools or contrast itself with them.

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

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

There is no guidance about when to use this tool instead of alternatives such as web-fetch, normalize-url, or validate-json. The description implies a lookup scenario but gives no exclusions, prerequisites, or conditions that should route an agent to 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does add one meaningful behavior: 'No browser is launched.' However, it does not explain whether the tool makes a network request, what 'can be opened' means, what the return value looks like, or what happens on failure. This leaves important behavioral expectations unstated.

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 with the core purpose front-loaded and no filler. Every word earns its place, and the behavioral note 'No browser is launched' is placed immediately after the purpose. This is appropriately concise for such a small 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?

The tool accepts 8 string parameters with no output schema, yet the description does not explain how those parameters relate to checking a URL, which parameter is required, or what the result means. It also does not position the tool among its many shape-focused siblings. The description is too sparse to fully guide correct invocation given the schema's complexity.

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

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

The input schema has descriptions for all 8 parameters, so schema coverage is 100%. The tool description itself adds no parameter-level meaning, which yields the baseline score of 3. The schema descriptions do clarify that many fields are discarded, but the description does not help an agent understand which parameter to pass for the stated URL check.

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

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

The description names a clear action and resource: 'Check whether a URL can be opened.' It also distinguishes itself from a sibling by adding 'No browser is launched,' which separates it from something like playwright-url-ok. It does not explicitly name any sibling, but the core purpose is understandable.

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 about when to use this tool versus alternatives like playwright-url-ok, normalize-url, or web-fetch. It does not state prerequisites, exclusions, or conditions that would route an agent here. The only usable hint is the negative side-effect 'No browser is launched,' which is not enough to select among 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 exist, so the description carries full responsibility. It only states 'Expression discarded,' which is cryptic and contradicts the schema's parameter semantics (e.g., 'discarded after the shape check'). It does not disclose side effects, permissions, or 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 short but not useful; it under-specifies rather than being concise. The single phrase provides zero actionable information and is poorly structured for agent decision-making.

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

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

For a tool with nine parameters, no annotations, and no output schema, this description is grossly insufficient. An agent cannot determine how to call it correctly, what inputs are valid, or what the tool actually 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?

Although schema coverage is 100%, the description adds no meaning and actually misleads by implying arithmetic operands while the schema parameters are unrelated. The schema's own descriptions are also vague ('discarded after...'), so the description fails to 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 claims the tool 'Evaluate a+b style arithmetic,' but the input schema contains nine parameters about URLs, cities, JSON, timezones, and file paths, none of which relate to arithmetic. This is actively misleading rather than clarifying what the tool does.

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

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

There is no guidance on when to use this tool versus any of the 26 siblings. No context, conditions, or exclusions are provided, leaving the agent to guess entirely.

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

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

With no annotations, the description must carry the full behavioral burden. It adds one useful disclosure ('Page content is not stored') but omits whether the URL is fetched, how redirects or failures are handled, and that most input fields are discarded.

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

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

The text is short and front-loaded with the core output, with no fluff. However, it is under-sized relative to a 9-parameter schema and omits details that other dimensions must penalize.

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

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

Without an output schema or annotations, and with nine optional parameters, the description does not explain the output format, which parameter to supply, or whether unrelated fields are ignored. It is not complete enough for safe 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 points to 'URL' as the key input, but it does not clarify the role of the other eight optional parameters or how they relate to the stated output.

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 ('Return') and resource ('a URL') with explicit outputs: host, scheme, and HTTP status. It does not explicitly distinguish from siblings like fetch-status or normalize-url, which may overlap, 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?

The description implies a use case (need host/scheme/status of a URL) but gives no conditions, exclusions, or references to alternatives. With 9 optional parameters and many sibling tools, an agent is left to infer when this tool should be chosen.

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 note is 'No identifiers are retained', which hints at privacy but does not clarify whether the tool reads, writes, or has side effects. With no annotations, the description leaves uncertainty about what happens to the input data and what operations are performed.

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 (one sentence) and lacks essential details about the tool's operation, output, or use case. It is concise in word count but not in conveying the necessary information, making it ineffective rather than appropriately brief.

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 usage context, and a vague purpose, the tool description is incomplete. An agent cannot determine what the tool returns, how to interpret results, or how it fits into a larger workflow. The description fails to provide a complete picture.

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

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

While each parameter has a schema description with 100% coverage, the descriptions are isolated and do not connect to a coherent purpose. For example, 'query' is described as 'Search text; discarded after the length check', but it is unclear how that relates to 'compatibility' or classification. The lack of an overarching tool purpose diminishes the meaning of individual 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 'Show how this request is classified' is vague and does not specify what kind of classification is performed or what 'compatibility' refers to. It does not clearly state the tool's function or distinguish it from the many sibling shape/check tools.

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

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

No guidance is provided on when to use this tool versus the numerous sibling tools (e.g., browser-url-ok, file-path-ok, validate-json). There is no mention of prerequisites, typical use cases, or scenarios where this tool is preferred.

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

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

With no annotations present, the description carries the burden. It usefully discloses that the tool performs no WHOIS/ownership lookup, but it does not clarify output structure, error behavior, or that all inputs are ephemeral/discarded. The schema descriptions add discard details, but the tool description itself gives only a thin behavioral picture.

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

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

The description is a single, front-loaded sentence with no filler. It states the core operation and the key limitation without wasting words.

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

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

Despite having eight parameters and no output schema, the description only explains hostname splitting. It fails to explain how the other schema fields relate to the tool, what the return value looks like, or how this tool differs from the many sibling tools with similar URL/hostname purposes.

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

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

The input schema already documents all eight parameters with descriptions, including what is discarded, so schema coverage is high and the baseline is 3. The tool description adds no extra parameter-level meaning, but it also does not need to because the schema carries that weight.

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

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

The description names a specific verb ('split'), a concrete resource ('hostname'), and a clear scope (labels only, no WHOIS/ownership data). It differentiates the tool from ownership/enrichment lookups, though it does not explicitly contrast with sibling tools like normalize-url 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?

The 'without WHOIS or ownership data' clause implies this is a syntactic-only tool, so an agent can infer not to use it for enrichment. However, there is no explicit guidance about when to pick this over sibling URL/hostname tools, nor any exclusions or alternative 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?

With no annotations, the description carries the full burden. It discloses that the request method is HEAD and that only status is returned, but it says nothing about network side effects, redirect/error behavior, or why the schema accepts URL-unrelated inputs like json, city, and time. That is a significant transparency gap.

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

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

The description is a single, front-loaded sentence with no filler. It is concise and easy to parse, though the brevity contributes to the completeness problems scored elsewhere.

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

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

The tool has nine optional parameters, no output schema, and no annotations, yet the description covers only a URL-head operation. An agent cannot infer the output shape of 'status' or the tool's multi-purpose handling of the other parameters, so the definition is not complete enough.

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 discard behavior. The description adds almost nothing beyond 'public URL' and 'status only,' so the baseline 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 names a specific verb ('HEAD'), a resource ('public URL'), and an outcome ('return status only'), so it clearly distinguishes this tool from content-fetching siblings like web-fetch or browser-url-ok. It does not reflect the broader set of inputs in the schema (ref, city, feed, json, time, etc.), which keeps it from being 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 phrase 'return status only' implies a status-check use case, but there is no explicit guidance about when to use this from the many sibling tools (e.g., web-fetch, playwright-url-ok, normalize-url, status-catalog), nor any exclusions for private URLs or content needs.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says the path is discarded; it does not state whether parsing is local or network-backed, what output is returned, whether other parameters are ignored, or whether there are side effects. This is too little for an unannotated 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 extremely concise: two short sentences with no filler. The main purpose is front-loaded, and the clarifying behavior about the path follows immediately. Every word earns its place.

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

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

Despite having 9 optional parameters, no required parameters, no annotations, and no output schema, the description does not explain what the agent should pass, what the tool returns, or how it relates to the many sibling tools. The schema provides some parameter detail, but the tool-level context is not sufficient 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 little beyond the schema: 'Path discarded' restates the existing path parameter description, and it does not clarify which of the 9 optional parameters is the relevant Figma URL or why unrelated parameters like city, feed, json, and zone are present.

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 also adds a scoping detail, 'Path discarded,' which clarifies what is ignored. The Figma reference clearly distinguishes it from sibling tools like github-repo-shape, domain-shape, and normalize-url.

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

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

There is no explicit guidance about when to use this tool versus alternatives such as normalize-url, browser-url-ok, or other shape-check tools. The intended use is only implied by the tool name and the phrase 'Parse a Figma file URL,' so the agent gets no exclusions or decision rules.

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

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

With no annotations, the description must carry the behavioral burden. It discloses 'No disk access,' a useful safety trait, but says nothing about what 'safe' means (syntax? traversal? existence?), what happens with the other parameters, or whether the tool performs any validation beyond shape. The one behavioral note is not enough to understand side effects or limitations.

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 omits crucial context about the tool's multi-parameter nature and the meaning of 'safe.' It is not tautological, but it is under-specified rather than efficiently structured. Front-loading the purpose is good, but the lack of any elaboration makes it less effective.

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

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

For a tool with nine parameters, no annotations, and no output schema, this description is severely incomplete. It does not explain why parameters like 'city' or 'json' exist, what the tool returns, how the 'safe' check is performed, or any edge cases. An agent cannot reliably decide when to use it or what to expect from the call.

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

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

Schema description coverage is 100%, so every parameter already has a description (e.g., 'Git ref name; discarded after the shape check'). The tool description adds no parameter-specific meaning, so it does not exceed the baseline of 3 for tools with full schema coverage. The mismatch between the description's 'path' focus and the unrelated parameters is not addressed here.

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

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

The description states a clear verb and resource: 'Check whether a path looks safe.' However, 'safe' is vague, and the schema includes nine parameters (ref, url, city, feed, host, json, zone, query) that have no obvious relation to paths, leaving confusion about the tool's actual scope. It does not distinguish itself from siblings like browser-url-ok or domain-shape, which likely perform similar safety checks on different resource types.

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. The description implies it is for checking paths but does not mention exclusions (e.g., URLs should use browser-url-ok) or prerequisites. An agent has to infer applicability from the name and schema, which is insufficient.

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

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

With no annotations, the description must carry the full behavioral burden, but it only mentions the Open-Meteo source and the coordinate output. It does not disclose whether an external network request is made, whether inputs are retained, or what error/rate-limit behavior exists.

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

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

The description is a single short sentence with no filler and front-loads the output type and external service. It is concise, though it leaves out important usage details that are handled in other dimensions.

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 no annotations or output schema, and the input schema has seven optional properties, so a one-line description is insufficient. Missing information includes which parameter supplies the place, output format or precision, failure modes, and whether network access 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 descriptions are detailed across all seven parameters, giving a high baseline of 3, but the tool description never connects 'a place' to a concrete parameter. The agent cannot tell whether to pass city, url, host, or another property, and the city parameter is described as being for a weather hint rather than a geo hint.

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 latitude and longitude for a place via Open-Meteo, so the core function is identifiable. However, it lacks a verb and does not explicitly differentiate geo-hint from sibling tools like weather-hint that may also operate on place names.

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 weather-hint or timezone. The only implied usage context is 'for a place,' but no explicit conditions, exclusions, prerequisites, or sibling comparisons are provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Parse owner and repo', offering no information about return format, error handling, network access, or side effects. The schema hints that many parameters are 'discarded', but the description does not confirm which inputs are actually used, nor what the 'shape check' entails. This is a serious gap for a tool whose schema suggests more complex 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 a single sentence and front-loaded, which is efficient. However, it is so under-specified that conciseness crosses into incompleteness—critical information about the tool's actual input handling and output is missing. The short length is not a virtue when it fails to cover essential context.

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

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

For a tool with 9 parameters, no output schema, and no annotations, the description is woefully inadequate. It does not explain the purpose of the extra parameters, what the tool returns, or how to interpret the 'shape check' concept. An agent would be forced to guess or explore unnecessarily. The description is far from complete for the tool's apparent complexity.

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

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

Schema description coverage is 100%, and the schema already documents each parameter individually. The description adds no meaning beyond the schema; it does not explain that only 'url' is relevant or how the other parameters interact. Since the schema already provides thorough descriptions, the baseline of 3 applies, but the description fails to leverage that baseline to clarify the core parameter semantics.

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

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

The description states a clear verb ('Parse'), resource ('owner and repo'), and source ('GitHub URL'), which distinguishes it from generic URL tools. However, the input schema exposes 9 unrelated parameters (e.g., city, zone, json) with hints like 'discarded after the shape check', creating ambiguity about whether the tool is actually a multi-purpose validator. The description does not clarify this mismatch, so the agent cannot be certain of 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?

No guidance is provided on when to use this tool versus alternatives like normalize-url, browser-url-ok, or jira-key-shape. The description does not mention any conditions, exclusions, or criteria that would help an agent choose this tool over siblings. The only implicit hint is the word 'GitHub', but it is not elaborated.

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 disclosure burden. It does disclose that the result is a count and that titles are not returned, but it does not explain network dependency, failure modes, or how the optional input parameters relate to the 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?

Two short sentences with no filler. The core purpose is front-loaded in the first sentence, and the second sentence adds a meaningful qualifier about what is excluded from the result.

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 no annotations, no output schema, and nine optional parameters described in confusingly different ways, the description is too sparse. It does not state whether parameters are needed, which one selects or overrides the source, or what the exact return format is.

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 a baseline of 3 applies. However, the description adds no parameter-level meaning: it does not identify which of the nine optional parameters is relevant, and 'Titles discarded' only repeats part of the feed parameter's schema description.

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

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

The description names a specific action and resource: count current Hacker News front-page stories. It also clarifies a key output boundary with 'Titles discarded,' which distinguishes it from tools that would fetch or list story content.

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 prefer this tool over siblings such as web-fetch, fetch-status, or normalize-url. The purpose implies a live-count use case, but there are no explicit alternatives, exclusions, or context cues.

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 should carry the burden of behavioral disclosure. It only hints that a list of names exists; it does not say whether the tool is read-only, what it returns, what it actually does with the parameters, or whether there are 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 one short sentence with no filler, which is concise, but it is under-specified and reads more like a label than an informative definition. It front-loads no action or key behavior that would help an agent decide.

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 annotations, no output schema, and many sibling tools, a one-phrase description is far from sufficient. An agent cannot infer what results to expect, which parameters matter, or how this tool is distinct from the related clock and timezone 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?

Schema description coverage is 100%, so every parameter is individually documented and the baseline can remain 3. However, the description adds almost no parameter-level meaning and does not explain why a timezone-names tool accepts 9 unrelated parameters; it neither clarifies nor contradicts 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 is a noun phrase ('Common IANA timezone names for clock calls') instead of a concrete verb-resource statement; it does not say whether the tool lists, validates, or returns names. It is not a pure tautology because it adds 'common' and 'for clock calls,' but the operation remains vague.

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 'for clock calls' implies some intended context, but there is no guidance on when this tool is preferable to siblings like timezone, utc-time, or other clock-related tools. It offers no alternatives, exclusions, or prerequisites.

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

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

With no annotations, the description carries the full burden. 'Return group counts only' is a useful behavioral limitation, but the description does not disclose safety, side effects, error handling, or what happens with invalid URLs.

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 unnecessary words. It is appropriately concise and immediately states the core action and output.

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 too minimal for a tool with nine parameters and no output schema. It fails to map the core action to any specific parameter and gives no return format beyond 'group counts', leaving the agent to infer which of the many inputs is relevant.

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 describes all nine parameters with reasonable detail, so the description adds no extra meaning. It does not indicate which parameter is the primary input for the robots.txt URL, but the schema's coverage is sufficient to warrant the baseline score.

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

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

The description clearly states a specific verb and resource: fetch a public robots.txt and return group counts only. It is clear about what the tool does, but it does not explicitly differentiate it from siblings like web-fetch 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?

There is no guidance on when to use this tool versus alternatives. The description implies usage through the name and behavior but provides no explicit context, exclusions, or alternative references.

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

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

With no annotations, the description carries the full burden. It only notes 'Key discarded' but does not clarify side effects, permissions, or whether the operation is read-only. The lack of any behavioral detail beyond discarding input is a significant gap for a tool that likely validates input without 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 extremely short (two sentences) and front-loads the purpose, but it is under-specified. It sacrifices necessary detail for brevity, making it inadequate for an agent to act on.

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 grossly incomplete. It does not explain how parameters map to the tool's function, what 'shape' means, expected input format, or any output behavior. An agent cannot reliably 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?

Although schema description coverage is 100%, the parameter descriptions are generic and unrelated to Jira key shape (e.g., 'City name', 'Public RSS or Atom URL'). The tool description does not identify which parameter is the Jira key or how the other parameters fit. This creates confusion rather than clarifying usage.

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

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

The description states a specific verb ('Check') and resource ('Jira issue key shape'), clearly distinguishing it from siblings like domain-shape or figma-url-shape. However, it lacks any detail on what constitutes a valid shape, so an agent knows what it checks but not what is being validated.

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 conditions, exclusions, or why one would pick this over other shape-checkers. The intended context is only implied by 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?

With no annotations, the description carries the full burden and does reveal one important behavioral trait: the body is discarded, so only the HTTP status matters. But it does not disclose other behaviors such as redirects, authentication, whether a network request is made for non-URL parameters, or any side effects, leaving a meaningful gap for an 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?

Two short sentences, with the purpose front-loaded and the body-discarded behavior immediately after. There is no filler or redundancy, and every word earns its place.

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

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

For a tool with nine optional parameters, no annotations, no output schema, and many overlapping siblings, this two-sentence description is insufficient. It does not specify which parameter to pass, what the return value looks like beyond 'HTTP status', why the other parameters are accepted, or how to select this tool among the sibling status and fetch 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?

Schema description coverage is 100%, so the baseline is 3. The main description adds little beyond implying the 'url' parameter is the one that matters; it does not clarify why eight other unrelated optional parameters exist or how they relate to the stated purpose. The url parameter's own schema description ('normalize or cite') even conflicts with the HTTP-status purpose, further reducing clarity.

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 operation: retrieve the HTTP status of a public library docs URL, while discarding the response body. This is specific enough to identify the core intent, but it does not explicitly differentiate this tool from siblings like fetch-status or web-fetch, and the nine unrelated optional parameters muddy the resource definition.

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 'for a public library docs URL' and 'Body discarded' imply a use case: check whether a docs URL is reachable without needing content. However, no alternative tools are named, no when-not-to-use guidance is given, and there is no explanation of how this differs from the many sibling status/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?

With no annotations provided, the description carries the behavioral disclosure burden. 'Values discarded' is a useful behavioral detail, indicating that values are not retained or returned. However, it does not disclose return format, error behavior on malformed JSON, or whether nested keys are counted.

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 contains no filler; both sentences provide information. It is front-loaded with the core function and the additional clause adds behavioral context. It could be more informative, but as a structure and conciseness matter, it is efficient.

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

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

Given a 9-parameter schema with no required parameters, no annotations, and no output schema, the description is far too thin. An agent is left without guidance on which parameter to use, what the return value looks like, or how invalid input is handled. This is not complete enough for reliable invocation.

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

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

Although schema description coverage is 100%, the description does not say which parameter contains the JSON object. The json parameter seems like the intended input, but its schema wording says 'JSON text to validate; discarded after the check,' which conflicts with the count-keys purpose. The other eight optional parameters appear unrelated, making parameter selection unreliable.

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 resource: counting keys in a JSON object. The phrase 'Values discarded' further clarifies that it is a counting operation, not a validation or value-returning tool. It does not explicitly differentiate from siblings like validate-json, but the purpose is reasonably clear.

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

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

There is no guidance on when to use this tool versus alternatives such as validate-json or domain-shape. The description does not mention prerequisites, when not to use it, or which sibling tools should be preferred for related tasks.

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 burden of exposing behavior. It does disclose the core transformation (origin/host/path extraction, query/fragment removal), which is useful. However, it does not mention error behavior for malformed URLs, whether other input properties are ignored, or any side effects, and several schema fields suggest 'discarded' behavior not reflected 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 two short sentences with the primary output front-loaded before the dropped components. Every word earns its place and there is no filler.

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

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

For a tool with seven input parameters, no annotations, and no output schema, this description is underequipped. It does not address why parameters such as city, feed, json, and ref exist, which fields are required, or what the response looks like beyond a vague 'origin, host, and path'. An agent browsing siblings would struggle to decide whether this is the right tool.

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

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

Schema coverage is effectively 100%, with every parameter having a description, so a baseline of 3 applies. The description adds minimal parameter-level meaning—only that the URL is transformed—and does not clarify how the many non-URL parameters (city, feed, json, ref) relate to the operation.

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 origin, host, and path') and the resource (a URL), and adds a distinguishing detail: query and fragment are dropped. It is not tautological. It loses a point because the input schema contains many unrelated parameters (city, feed, json, ref) that muddy which resource the tool actually operates on.

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

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

No when-to-use guidance is provided. The description does not mention alternatives like browser-url-ok or web-fetch, nor does it state conditions for choosing normalize-url over them. The agent must infer usage from the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that no browser is launched, which is useful, but it doesn't say whether a network request occurs, whether any state changes or data is discarded, or what kind of response is returned. The brief description leaves major behavioral unknowns for a URL-checking tool.

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

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

The description is extremely short and front-loaded: 'Check whether a URL can be opened. No browser is launched.' Both sentences are meaningful and there is no filler. However, the brevity comes at the cost of important behavioral and selection context, so it is not fully 'appropriately sized' for a tool with 9 parameters and no annotations.

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 optional parameters, no annotations, and no output schema, the description is too sparse. It doesn't explain what the tool returns, which parameters are relevant to the URL check, or whether the check is a network request. 'No browser is launched' is the only contextual clue, which is insufficient for a no-annotation tool.

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

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

The input schema provides descriptions for all 9 parameters, so the 100% schema coverage sets a baseline of 3. The tool description itself adds no parameter-level meaning and does not explain how the many unrelated-looking parameters relate to 'checking whether a URL can be opened.' Still, the schema already describes each parameter clearly, so this is not a critical gap.

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

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

The description states a specific action and resource: 'Check whether a URL can be opened.' The added sentence 'No browser is launched' clarifies the operation's nature and helps differentiate it from browser-url-ok. However, it doesn't explicitly name an alternative or describe the underlying check mechanism, so it falls short of full sibling differentiation.

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

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

The description gives no explicit guidance about when to use this tool versus siblings like browser-url-ok, fetch-status, or web-fetch. 'No browser is launched' hints that this is not a browser-rendering check, but it does not state selection criteria or mention alternatives. An agent must infer usage context from the tool name and the negative statement.

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

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

With no annotations, the description must carry the behavioral burden. It does disclose that the query is discarded, implying a stateless operation. But it does not describe the output format, error behavior, or how the tool handles the many non-query schema fields, so transparency is only 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 only two short sentences and puts the primary operation first. Every word earns its place and there is no filler, making it exceptionally concise and well-structured.

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

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

For an unannotated tool with no output schema, this is under-specified: it omits how the query is passed, what the count output looks like, and how to treat the seven other parameters. An agent reading it cannot confidently invoke the tool with the correct argument.

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 schema property has a description, but none is labeled as a search query. The tool description refers to a 'search query' that is absent from the schema, which exposes ref, url, city, feed, host, json, and path. This introduces a phantom parameter rather than mapping the intended input.

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

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

The description names a specific action and object: 'Count characters in a search query.' This clearly signals a length-counting utility and distinguishes it from the sibling shape-validation tools. However, the phrase 'search query' does not correspond to any schema property, so the purpose is clear at a high level but not directly invokable.

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 prefer this tool over alternatives, which of the seven schema parameters should be treated as the search query, or what prerequisites or limitations apply. The only additional sentence, 'Query discarded,' is a behavioral note, not usage guidance.

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

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

The description discloses zero behavioral traits. There are no annotations to cover safety or side effects, and the description itself says nothing about what happens to inputs, what the tool returns, or how it behaves. The only behavioral hints ('discarded after the shape check', 'titles discarded') appear in the schema descriptions, not in the tool description, so they do not satisfy this dimension.

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 rather than effective conciseness. It is a phrase without a verb, contains no actionable instruction, and does not front-load any operational detail that would help an agent invoke the tool. Every other element of the definition must compensate, but none do.

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

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

For a tool with 8 parameters, no annotations, and no output schema, a one-sentence noun phrase is completely inadequate. The description leaves all critical context missing: how parameters map to status codes, what the tool returns, whether it is a lookup or a list, and how it relates to sibling tools. An agent cannot correctly select or invoke it based 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?

All 8 parameters have individual schema descriptions, so schema coverage is 100%, which gives a baseline of 3. The tool description, however, adds no meaning beyond the schema and even fails to explain how parameters relate to the stated purpose of an HTTP status catalog. It does not compensate for the apparent mismatch between the description and the parameter set.

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

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

The description is a noun phrase, not a verb+resource: 'Short catalog of common HTTP status codes' states what the tool contains but not what operation it performs or returns. The input schema parameters (ref, url, city, feed, host, json, path) are entirely unrelated to HTTP status codes, creating confusion about actual purpose. It does not distinguish from siblings like fetch-status or normalize-url.

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

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

There is no guidance on when to use this tool versus alternatives. No context, no when/when-not conditions, and no mention of which of the 8 parameters are relevant or how to choose among them. The description gives no hint about the intended use case.

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

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

With no annotations present, the description carries the transparency burden. It explicitly discloses that the prompt is discarded, which is the key behavioral trait. It does not describe the output contents or any edge cases, but the main side-effect-free behavior is clear.

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

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

The description is two short sentences with no filler. The primary action is front-loaded, and the behavioral caveat is stated separately. Every word earns its place.

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

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

The description is too thin for a tool with seven unrelated optional-looking parameters and no output schema. It does not explain whether any parameter is required, what the 'thinking template' contains, or whether output ever varies. An agent cannot confidently decide what arguments to pass or what to expect back.

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

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

All seven parameters already have individual descriptions in the schema, so schema coverage is effectively 100%. The tool-level statement 'Prompt discarded' adds useful context that the parameter values are irrelevant, but it does not deepen the meaning of any specific parameter beyond what the schema says.

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 a three-step thinking template.' The added 'Prompt discarded' clarifies that this is a generic, input-independent tool. It is distinct from all sibling tools, which are content-specific validators and utilities.

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

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

There is no guidance about when to use this tool versus the many sibling validators. 'Prompt discarded' implies the input does not matter, but the description never states a scenario, condition, or alternative.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states the core function and does not mention output format, error behavior for invalid timezone names, network dependencies, or side effects (though 'current time' implies a read-only 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 a single front-loaded sentence with no wasted words. However, it is under-specified and omits crucial information about the input parameter, limiting its usefulness despite being 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 the confusing schema with unrelated parameters and the absence of annotations or output schema, the description is severely incomplete. An agent cannot determine how to invoke the tool correctly or what response to expect, so this definition fails in a real usage context.

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

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

The input schema lists seven parameters (ref, url, city, feed, host, json, path), and none of them is a timezone parameter. The description references 'named IANA timezone' but provides no mapping to any schema field, making it impossible for an agent to know which parameter to populate.

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

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

The description 'Current time in a named IANA timezone' clearly states the tool's action and resource, distinguishing it from sibling tools like utc-time (UTC time) and iana-zones (timezone lists). It lacks an explicit verb like 'return' or 'get', but the meaning is unambiguous.

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

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

The description implies use when a local time for a specific IANA timezone is needed, which differentiates it from utc-time. However, it does not explicitly state when to prefer this tool over alternatives or any exclusions, relying on inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'Current UTC timestamp' and does not disclose whether the tool has side effects, whether parameters are ignored, whether any network or disk access occurs, or what format the timestamp takes. The schema's parameter descriptions hint at discarded values, but the main description adds no behavioral transparency.

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

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

The description is concise and front-loaded with no filler. However, it is under-specified for a tool with 9 optional parameters and no output schema; a single sentence does not adequately structure the agent's understanding of how to invoke the tool correctly.

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

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

Given the complexity of 9 optional parameters, no annotations, and no output schema, the description is incomplete. It does not specify the return format, which parameters are relevant, whether parameters are ignored, or how this tool relates to siblings. The core action is clear, but an agent would struggle to know how to handle the provided parameters.

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

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

Schema description coverage is 100%, so the baseline is 3. However, the description itself adds no meaning to any of the 9 parameters, and the parameters seem largely unrelated to a tool that simply returns the current UTC timestamp. The schema descriptions are individually informative, but the tool description does not explain how or whether these parameters affect the call.

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 returns the current UTC timestamp. It is a specific, actionable statement about the resource and result, though it does not explicitly differentiate itself from sibling tools like 'timezone' or 'iana-zones'.

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

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

The description provides no guidance on when to use this tool versus alternatives such as 'timezone' or 'iana-zones'. There is no mention of context, prerequisites, or exclusions, leaving the agent to infer usage solely from the tool's name and one-line description.

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 transparency burden. It discloses that the body is discarded, which addresses privacy and non-retention. However, it does not state the expected output (e.g., boolean, error message), behavior on malformed JSON, or whether the operation is read-only in a broader sense.

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

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

The description is only two sentences and front-loads the core purpose in the first. Every word earns its place, and it is free of fluff. It is, however, arguably too terse given the eight-parameter schema, which could warrant a bit more orientation.

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 and no output schema, the description must supply full context, but it leaves key gaps: no mention of return format, no mapping to the input schema's many unrelated parameters, and no mention of error behavior. The 'discarded' note is helpful, but the agent still cannot confidently determine how to invoke the tool correctly or interpret the result.

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 lists eight parameters, each with a description, so schema coverage is high; the baseline would normally be 3. But the description does not clarify that only the 'json' parameter is relevant—the other parameters (url, city, feed, host, path) appear unrelated to JSON validation and may confuse an agent. The description's 'body' language also does not explicitly map to the 'json' parameter, adding no 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 states a specific verb and resource: 'Check whether a body is valid JSON.' It is clearly distinct from sibling shape-check tools like domain-shape, browser-url-ok, or wiki-title-ok, which validate URL, domain, or title forms rather than JSON syntax. The tool name reinforces the 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?

The description implies a use case—validating JSON—but gives no explicit guidance on when to choose this tool over alternatives or when not to use it. It does not mention any of the sibling validators or the conditions that would route an agent here instead.

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 does not disclose side effects, external calls beyond mentioning Open-Meteo, error behavior, rate limits, or whether it is read-only. The lack of any behavioral detail leaves the agent guessing about operational implications.

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

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

The description is extremely short and contains no filler words, making it concise. However, it is too brief to provide necessary context, though this is a separate issue from wordiness. Structurally, it front-loads the key 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 schema has 9 parameters and no output schema, the description is grossly incomplete. It fails to explain the role of the extra parameters, what the tool returns, how to interpret results, or any constraints. The agent has insufficient information 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?

While the input schema has descriptions for all 9 parameters, they are entirely unrelated to the stated purpose of a weather hint (e.g., 'Git ref name', 'HTTPS URL to normalize or cite'). The description does not explain how these parameters relate to fetching current temperature, making them misleading and causing confusion for the agent.

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 conveys the core resource and scope but lacks an explicit verb and does not differentiate from sibling tools like geo-hint or timezone. It is clear in a minimal sense, but the mismatch with the extensive input schema undermines 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?

There is no guidance on when to use this tool versus any alternative. The description does not mention any conditions, prerequisites, or typical scenarios, leaving the agent without 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?

With no annotations, the description carries the behavioral transparency burden. It clearly discloses the key behavior that the body is discarded and only HTTP status and content type are returned. This corrects a common assumption about a 'web-fetch' tool, though it does not address redirects, timeouts, or error 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 two short sentences with no filler. The primary purpose is stated first, and the important body-discard caveat is stated second, making it efficient and front-loaded.

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

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

Despite a large sibling list and a nine-parameter schema with no output schema or annotations, the description gives only a one-line overview. It does not explain how the non-URL parameters relate to the tool, what the return structure looks like, or how this tool differs from closely related siblings.

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 tool description itself adds no parameter-level detail. Each of the nine parameters already has a meaningful description in the schema; the description adds nothing more about parameters.

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

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

The description states a specific verb and resource: return HTTP status and content type for a public URL, discarding the body. This is clear at face value, but the input schema exposes nine unrelated parameters such as city, json, zone, and query that the description never mentions or reconciles, making the tool's full scope confusing.

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 about when to use web-fetch versus siblings like fetch-status, normalize-url, browser-url-ok, or inspect-robots. 'Body discarded' implies it is for status/content-type checks rather than content retrieval, but no clear when-to-use or when-not-to-use guidance is provided.

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

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

The only behavioral disclosure is 'Title discarded after the call,' which notes data retention. With no annotations present, the description carries the full burden of explaining side effects, network behavior, and output expectations, but those are missing.

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

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

The text is short and front-loaded, stating the core purpose before the discard note. No words are wasted, though the second sentence introduces a parameter not present in the schema.

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

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

There is no output schema and no annotations, yet the tool has seven input parameters. The description does not explain the expected return value, how to pass the title, or when to invoke this tool, leaving the definition far too incomplete for reliable agent use.

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

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

The description's only parameter-related statement references 'title,' but the schema has no title property. The schema's existing parameter descriptions are placeholder-like and unrelated to a Wikipedia title, so an agent still cannot determine which value actually supplies 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 opening sentence clearly states the action and resource: checking whether a Wikipedia title exists. This is specific and not a tautology. However, the description mentions 'title' while the input schema exposes no title property, which slightly undercuts the 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 usage guidance is provided. The description does not say when to use this tool versus siblings such as web-fetch, citation, or normalize-url, and it gives no context for choosing it over alternatives.

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