Africa/Dar_es_Salaam clock

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

With no annotations present, the description carries the full burden. It does add a meaningful behavioral detail by stating 'Task text discarded' and noting that some inputs are discarded, which goes beyond a bare summary. However, it does not disclose possible side effects such as cost (despite the 'pay-per-call' label), authentication needs, or failure behavior, so it is only partially transparent.

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

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

The description is three short, purposeful sentences: purpose, returned outputs, and the key side-effect. It is front-loaded with the most important action and contains no filler or redundant phrasing.

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

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

Despite no output schema, the description does enumerate the return categories. However, with seven loosely related parameters and no explanation of how they select or shape the result, an agent cannot confidently determine what inputs to pass. The 'pay-per-call' aspect is also left ambiguous—whether the tool itself charges money or merely returns information about a paid gateway—which is a significant contextual gap.

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 parameters have schema descriptions, providing 100% coverage, so the baseline is 3. The tool description itself does not add semantic meaning beyond the schema; it does not explain how the ref, url, city, feed, host, or json inputs relate to the gateway lookup. Several schema descriptions are also terse or repetitive ('discarded after'), so the description does not compensate for that.

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

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

The description states a specific action ('Find') and a specific resource ('a public pay-per-call tool gateway (Monid)'), and enumerates the returned artifacts (CLI setup, how-it-works, skill file, remote MCP hops). It is clear, though it does not explicitly contrast itself with sibling tools like lib-docs-hint, so it stops short of full differentiation.

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

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

The description offers no when-to-use or when-not-to-use guidance, and no alternatives are mentioned. The only contextual hint is the resource name, which implies use when someone needs Monid gateway setup, but that is not explicit. There is also no guidance about which inputs to provide for which scenarios.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says no browser launch, which is useful, but it does not say whether it makes network requests, whether it is read-only, or what other side effects may occur. The schema-mandated effects like 'discarded after the shape check' are not surfaced 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 extremely concise: two sentences, each with a clear function. The first states the core action and the second adds the most important behavioral caveat. No wasted 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?

Given 9 optional parameters, no required parameters, no annotations, and no output schema, the agent is left without guidance on which inputs to pass. The description focuses on one behavior but fails to explain the broader shape-checking context or how to select among properties like city, json, path, zone, etc.

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

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

Schema description coverage is 100%, and each parameter has its own description, so the description need not repeat parameter semantics. The description adds no meaning about the nine optional parameters, but it also doesn't need to, since the schema is already rich.

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') and adds a useful negative behavior ('No browser is launched'). This differentiates it somewhat from playwright-url-ok, though it doesn't explicitly describe how it differs 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 explicit guidance about when to use this tool versus alternatives. The 'No browser is launched' phrasing implies a quick or side-effect-free check, but the description gives no alternatives, prerequisites, or a not-to-use 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?

With no annotations provided, the description must carry the full behavioral burden, but it only states 'Expression discarded.' This hints at non-retention but does not disclose what the tool returns, whether it mutates anything, what side effects occur, or what failure modes exist. The behavior is under-specified for an evaluator-style 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 very short, but brevity comes at the expense of necessary information. 'Expression discarded' is an unclear fragment that does not clearly earn its place, and the whole text is closer to under-specification than efficient summarization.

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?

A tool with seven unrelated parameters and no output schema or annotations needs much more contextual explanation. The description does not identify which parameter carries the arithmetic expression, what the output looks like, or when this tool should be used. It is not minimally viable for an agent to invoke 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 description adds no meaning to any of the seven input schema parameters, and it references an 'expression' concept that does not exist in the schema. An agent cannot map 'a+b style arithmetic' to any property like ref, url, city, feed, host, json, or path. This is a direct mismatch between the described API and the actual 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 says 'Evaluate a+b style arithmetic,' which names a verb and subject, but the input schema contains no arithmetic expression parameter—it lists ref, url, city, feed, host, json, and path. The sentence 'Expression discarded' is confusing rather than clarifying, because there is no expression field visible to the agent. This makes the purpose misleading despite the surface-level verb.

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, what kind of input to supply, or how it differs from sibling validation tools like validate-json, normalize-url, or file-path-ok. The description gives no context that would help an agent choose between alternatives. Only the tool name suggests arithmetic, which is not enough.

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

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

With no annotations, the description must carry behavioral disclosure, but it only reveals that page content is not stored. It does not disclose that the tool accepts and discards many unrelated parameters, nor does it describe side effects, requirements, or error behavior, leaving the agent with an incomplete 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?

Two short sentences with the primary behavior front-loaded and no filler. The page-content privacy note is relevant and 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 parameters, no output schema, and no annotations, a two-sentence description is insufficient. It does not explain why the schema includes city, feed, json, zone, query, and other unrelated-looking fields, nor does it specify the return structure or distinguish the tool from its 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 percent, so the baseline is 3. The description itself only mentions URL, but every parameter already has a meaningful schema description, including notes about values being discarded.

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 verb and resource: return host, scheme, and HTTP status for a URL. This is clear on its own, but it does not differentiate the tool from siblings such as normalize-url or fetch-status, which likely overlap in purpose.

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

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

There is no guidance about when to use this tool versus the many sibling tools. The only added statement, page content is not stored, is a behavioral constraint rather than a usage recommendation.

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

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

The description does disclose a meaningful privacy behavior: "No identifiers are retained." However, without annotations, it carries the full burden of explaining what happens during classification, and it does not state whether the tool is purely local, whether it calls external services, what inputs it accepts, or what side effects might occur.

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

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

The description is very short and readable, with two sentences that are easy to parse. However, the opening sentence is vague enough that it does not fully earn its place; it states a classification action without defining classification outcomes.

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 seven diverse parameters, no annotations, and no output schema, the description needs to explain what classification means and how the tool behaves. It only provides a privacy guarantee and an opaque action, leaving critical context about input selection and return values absent.

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 provides descriptions for all seven parameters, so schema coverage is effectively complete. The tool description itself adds no parameter-level detail, but it also does not need to because the schema already documents each field and its disposal behavior.

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

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

The description says "Show how this request is classified" and the tool is named "compatibility," but it never explains what classification scheme is used, what categories exist, or what "compatibility" refers to. It is vague rather than tautological, but an agent cannot tell what resource is being acted on or what output to expect.

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 any of the many sibling tools such as domain-shape, normalize-url, validate-json, or weather-hint. The description does not give any conditions, exclusions, or alternatives, so an agent has no basis for selecting 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 carries the full burden of disclosing behavior. It does clarify that no WHOIS or ownership data is involved, which is useful, but it doesn't state side effects, return behavior, error cases, or that most parameters are discarded. Given the schema descriptions mention discarded fields, the description itself adds only minimal behavioral context.

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

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

The description is a single concise sentence with no filler. It front-loads the primary action and includes a useful scope qualifier. Its brevity is appropriate, though it sacrifices detail that other dimensions need.

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 schema is complex with seven parameters, several marked as discarded, and there is no output schema or annotation. The description only addresses hostname splitting and provides no guidance on how the other parameters relate, what the tool returns, or how it fits with sibling tools. This is incomplete for an agent to correctly select and invoke it.

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

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

Schema coverage is high: every input parameter has a description, so the baseline is 3. The description adds no meaning beyond what the schema already provides and doesn't even name which parameter corresponds to the hostname it mentions. It adds no value beyond the schema's structured fields.

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: 'Split a hostname into labels.' It also distinguishes itself from WHOIS/ownership lookups, which helps separate it from data-enrichment tools. However, it doesn't explicitly contrast with sibling tools like github-repo-shape or figma-url-shape, so some differentiation is left to context.

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

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

There is no guidance on when to use this tool versus alternatives. The description implies a hostname-parsing use case but never states conditions, exclusions, or sibling alternatives such as normalize-url or wiki-title-ok. With seven parameters and many sibling tools, the lack of usage direction is a significant gap.

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 behavioral disclosure burden. It does disclose that the tool performs a HEAD request and returns status only, implying a read-only network operation, but it does not define what 'status' means or how redirects, errors, or malformed URLs are handled.

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

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

The description is a single front-loaded sentence with no filler or repetition. Every word contributes to conveying the core operation and output constraint.

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 schema is parameter-rich, but the description only explains the URL case while nine optional parameters are exposed and no output schema clarifies the response format. An agent cannot determine whether the other parameters are alternate inputs, whether they are mutually exclusive, or what the returned status looks like, which is a significant completeness gap for such a flexible tool.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description does not add parameter-level meaning beyond 'public URL', so the baseline of 3 for full schema coverage 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 specific operation and resource: issue a HEAD request to a public URL and return only the status. This is clear for the URL-checking use case, but it does not explicitly differentiate from sibling URL tools such as web-fetch, normalize-url, or browser-url-ok, and it leaves the relationship to the other eight schema parameters unexplained.

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

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

There is no guidance on when to use this tool versus alternatives like web-fetch or browser-url-ok, and no exclusions such as private URLs or cases where body content is needed. The word 'public' provides only a weak implicit constraint.

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 one behavior—'Path discarded'—but does not say whether the tool validates, returns a normalized URL, extracts an ID, or errors on non-Figma input. The read-only/parse nature is implied, but the observable result is unspecified.

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, front-loaded with the action, and contains no filler. It loses points only because the brevity sacrifices useful context; the structure itself is clean.

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

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

Given 9 parameters, no output schema, and no annotations, a two-clause description is insufficient for an agent to call the tool correctly. The agent must infer which parameter to pass, what result to expect, and how this differs from sibling URL 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 even though the description itself adds no parameter-specific meaning. The description does not identify which of the 9 parameters is the Figma URL to parse, but the 'url' property is self-evident; the generic schema descriptions are not fully aligned with Figma, but the rubric baseline applies.

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 ('Parse') and a specific resource ('a Figma file URL'), and the final clause adds a distinctive behavior ('Path discarded'). This makes it clearly distinct from sibling shape tools like github-repo-shape or domain-shape, though it does not mention the 'shape/validate' aspect suggested by the tool name.

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

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

There is no guidance about when to use this tool versus alternatives such as normalize-url, browser-url-ok, or the other *-shape tools. The phrase 'Parse a Figma file URL' implies a Figma URL context, but there are no exclusions, prerequisites, or fallback 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?

The description discloses one important behavioral trait—'No disk access'—which is meaningful because there are no annotations and it tells the agent the call has no filesystem side effects. However, it does not describe the return value, error behavior, or what 'looks safe' means beyond a syntactic check. Given no annotations, the behavioral burden is only partially met.

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

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

Two short sentences with no filler, and the purpose is front-loaded before the safety note. For the core message it is appropriately concise; omitted guidance is penalized 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?

With 9 optional parameters, no annotations, and no output schema, this minimal description leaves substantial gaps: it does not specify which parameter(s) to provide, what the result looks like, or how this differs from sibling URL/path checkers. The schema provides some field-level help, but the definition as a whole is not complete 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 does not add parameter-level detail beyond the word 'path', but the schema already documents each field, including which are discarded. It does little to resolve why eight unrelated fields exist on a path-checker, but it does not misstate them.

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 ('Check'), a clear resource ('path'), and a qualifier ('looks safe') that identifies a shape-only validation. It is distinguishable from URL/domain/wiki sibling tools by subject matter, though it does not explicitly call out any sibling. The broad input schema with unrelated params slightly muddies the picture, but the stated purpose remains clear.

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

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

No sentence explains when to use this tool versus sibling tools such as normalize-url, browser-url-ok, or wiki-title-ok. 'No disk access' implies a safe read-only check, but there is no explicit when/when-not guidance or named alternatives. The only usage signal is inferable from the tool name and first clause.

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

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

No annotations are present, so the description carries the full behavioral burden. It discloses that the lookup happens via Open-Meteo, but it does not state that this is a read-only operation, what happens when irrelevant parameters are passed, whether network access is required, or how errors are reported.

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, and every word contributes to the basic purpose. However, the brevity borders on under-specification for a tool with many optional parameters and no output schema.

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

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

With 9 optional parameters, no annotations, and no output schema, a one-line description is not enough. The agent is left without critical context: which parameter is necessary, what the response shape looks like, and what happens if multiple or no parameters are supplied.

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 its own explanation. The tool description adds little parameter-level value, though 'for a place' weakly suggests the city parameter. This is a baseline-3 case: the schema handles the parameter documentation, but the description does not clearly map the intended 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 names the output ('latitude and longitude'), the resource ('a place'), and the data source ('Open-Meteo'), which makes the tool's basic purpose clear and distinguishes it from a sibling like weather-hint. It lacks an explicit verb such as 'resolve' or 'return', but the intended meaning is still readable.

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, nor which of the nine optional parameters should be provided. The description only implies that a place is involved, leaving the agent to guess that 'city' is the relevant input.

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

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

No annotations are provided, so the description must carry the burden of behavioral disclosure. It only says 'Parse owner and repo' and does not explain what happens for invalid URLs, whether the input is validated, what output is returned, or how unrelated schema fields like city, feed, host, json, and path behave.

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. It immediately communicates the core action and target resource.

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 seven schema parameters, no annotations, and no output schema, this one-sentence description is insufficient. It lacks return format, validation behavior, parameter selection guidance, and error semantics, leaving significant gaps for an agent deciding 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 schema provides descriptions for all seven parameters, so the baseline is 3 despite no parameter details in the tool description. However, the description does not clarify that 'url' is the key parameter for this tool, and the schema descriptions like 'normalize or cite' do not fully align with the stated purpose of parsing owner and repo.

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 ('Parse') and resource ('owner and repo from a GitHub URL'), which clearly distinguishes this from generic URL tools like normalize-url. However, it does not mention the validation/checking behavior implied by the tool name 'shape', so it is clear but slightly incomplete.

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

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

There is no guidance on when to use this tool versus related siblings such as domain-shape, figma-url-shape, or normalize-url. The description implies it is for GitHub URLs, but it never explicitly says when to prefer this tool or what alternatives exist.

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 does disclose one behavioral trait: 'Titles discarded' tells the caller that titles will not be included in the result. However, it does not state whether the tool performs a live network read, how parameters are treated, or any error/rate behavior, 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 two short sentences, front-loaded with the action and free of filler. 'Titles discarded' is cryptic but compact and communicates a useful output constraint, so it earns a 4 rather than a 5.

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

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

The tool has 9 optional parameters, no output schema, and no annotations, yet the description does not explain how parameters relate to the count or what the response looks like beyond 'count'. An agent cannot confidently tell whether to pass a feed URL, a URL, or no arguments, and there is no mention of network behavior or failure cases.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no parameter-level meaning and does not clarify which of the 9 optional parameters, if any, are relevant to counting Hacker News stories. The 'Titles discarded' phrase only loosely relates to feed/query 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 concrete action ('Count'), a specific resource ('current Hacker News front-page stories'), and hints at the output scope ('Titles discarded'). This is immediately distinguishable from generic siblings like web-fetch and 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?

The description gives no guidance on when to use this tool versus alternatives, no prerequisites, and no conditions where it should not be used. An agent is left to infer the boundary from the tool name and purpose 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 exist, so the description carries the full burden—and it discloses almost nothing. The schema reveals that several parameters are 'discarded,' but the description never explains this surprising behavior, the return format, or whether the tool has side effects. This is a major 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 one short sentence with no filler, so it is concise. However, conciseness crosses into under-specification: it does not convey the action, output, or parameter behavior, so the sentence does not fully 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?

With eight seemingly unrelated parameters, no output schema, and no annotations, a one-sentence description is completely inadequate. The agent cannot determine what to pass, what to expect back, or whether many parameters are stubs meant to be ignored.

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 parameters have schema descriptions, so the baseline is 3. The description adds no parameter-level meaning, and the schema's 'discarded' notes are the only real guidance. That is adequate for shape but puzzling in relation to IANA timezone names.

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 statement, so it is unclear what action the tool performs—whether it lists zones, validates them, or converts them. It names a domain (IANA timezone names) but does not distinguish itself from siblings like timezone or utc-time.

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

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

The phrase 'for clock calls' implies some context, but there is no explicit guidance on when to use this tool versus alternatives. No exclusions or sibling comparisons are provided, leaving the agent to guess its role among many 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?

It states the core behavior and output limitation, and parameter descriptions mention discarding/validation, but it doesn't clarify error behavior or why unrelated params exist.

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

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

Single sentence, front-loaded with action and output constraint; no wasted 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 100% parameter schema coverage, the description is too thin to map purpose to params (e.g., host vs url) and lacks output format/error/usage context, so an agent cannot reliably 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?

Because parameter descriptions in the schema cover 100% of params, the tool description adds no parameter-level meaning; it only restates the abstract purpose.

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

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

The description names a specific action and resource ('Fetch a public robots.txt') and a specific return ('group counts only'), making the tool's purpose reasonably clear despite lacking explicit 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?

It provides no guidance on when to choose this over web-fetch/fetch-status or how to supply the target (which param is the robots.txt URL), so invocation decisions are unsupported.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It does reveal that the key is discarded, which is a useful privacy-related behavior, but it does not state whether the check is local, whether any network access occurs, or what the tool returns. The disclosure is too thin for a tool with no annotation safety profile.

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

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

The description is short and front-loaded, with no filler or redundant phrasing. The second sentence 'Key discarded.' earns its place as a behavioral hint, though the space could have been better used to name the input parameter.

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 checker with no output schema and no annotations, the description should state the expected key pattern, the input property, and the return/result behavior. The current description only gives a purpose clause and a discard note, leaving important invocation details unspecified. The large generic schema makes this incompleteness more harmful.

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 refers to a 'key', but the input schema exposes no property named 'key' and instead lists seven unrelated strings such as city, feed, host, and json. The only clue is the `ref` parameter description mentioning 'discarded after the shape check', which aligns loosely with 'Key discarded', but the description itself never maps the Jira key to a concrete input. This ambiguity makes correct invocation 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 verb and resource: 'Check a Jira issue key shape.' This clearly distinguishes it from sibling shape-check tools like github-repo-shape, domain-shape, or wiki-title-ok. The disposal note adds a small extra behavioral fact, though it doesn't specify the return value.

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 its use case: validating the shape of a Jira issue key. However, it gives no explicit when-to-use or when-not-to-use guidance, nor names alternatives or edge cases where another tool would be better. The context is implied rather than stated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only discloses that the body is discarded, which is useful, but it does not mention whether this is a network request, what status/error behavior to expect, whether redirects are followed, or whether there are rate limits. For a network-related tool, this is too thin.

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

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

The description is very concise: two short sentences with no wasted words. The 'body discarded' caveat is front-loaded enough and earns its place. It could be more informative, but as written 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?

The tool has 9 optional parameters, no output schema, and no annotations, so the description needs to do more work. It does not explain which parameter to provide in which situation, what the return value actually looks like, or how this tool differs from siblings. The description is not complete enough for reliable agent 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 tool description adds essentially no parameter semantics beyond pointing at a 'public library docs URL,' which loosely suggests the `url` parameter but is disconnected from the other eight accepted parameters. This does not improve on 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 concrete operation: get the HTTP status for a public library docs URL, and adds that the body is discarded. This is clear about what the tool does. However, it does not distinguish this from sibling tools like fetch-status, browser-url-ok, or web-fetch, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus the many sibling status/fetch/URL tools. It does not specify that this is for library docs URLs only, nor does it tell the agent to use fetch-status or web-fetch when the body is needed. The usage context is only implied, not explained.

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. 'Values discarded' is a useful transparency note indicating no retention, but it does not disclose the return format, error behavior, or side effects beyond the count.

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

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

The description is two short sentences with no filler: the core action comes first and the boundary condition ('values discarded') immediately follows. 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 and no output schema or annotations, the description is too thin. It does not explain what the tool returns, which parameter to pass, or how it behaves when the JSON is malformed or the object is empty, so an agent has insufficient context to invoke it 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?

Schema description coverage is 100%, so the schema already documents all nine optional parameters. The tool description adds the notion that a JSON object's keys are counted, but it does not explicitly map 'json' (or any other parameter) to that object, leaving some ambiguity in a schema with no required 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 operation ('count keys') and resource ('JSON object') and notes that values are discarded. It is clear and avoids tautology, but it does not name related siblings such as validate-json or explain how this differs from 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?

No guidance is given for when to use this tool versus the many sibling tools. There is no mention of what kind of JSON input is acceptable, whether the json parameter is the intended input, or when another sibling would be more appropriate.

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

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

The description mentions that query and fragment are dropped, which is a behavioral detail, but it does not disclose any side effects, permissions, or read-only status. There are no annotations to fill this gap. The tool may silently ignore most input parameters, but this is not transparent. The behavioral transparency is insufficient.

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

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

The description is concise: two sentences that clearly state the primary function. It is well-structured and easy to read. However, given the large schema, the description is too brief to cover the necessary details, but conciseness itself is not a flaw. It earns a high score for being succinct.

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 far from complete given the tool's context. It provides no output schema, no information about the return format, and no explanation for the majority of input parameters. The tool's behavior with the extra parameters is completely undocumented. This is a major gap, making the tool unsuitable for an agent 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?

The description only implicitly references the 'url' parameter, leaving the other 8 parameters completely unexplained. The schema provides generic descriptions for these parameters (e.g., 'Git ref name' for ref, 'City name' for city) that are clearly copied from other tools and do not relate to URL normalization. The description does not clarify which parameters are actually used, making the parameter semantics nearly useless.

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 core purpose is stated clearly: return origin, host, and path for a URL while dropping query and fragment. However, the schema lists 9 parameters, most of which (ref, city, feed, etc.) are unrelated to URL normalization, creating ambiguity about what the tool actually does. The description does not reconcile this mismatch, so the overall purpose is only partially clear.

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

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

No guidance is given on when to use this tool versus sibling tools like browser-url-ok or fetch-status. The description does not explain whether the extra parameters are ignored or relevant, nor does it mention that only the 'url' parameter is required for the stated operation. This leaves the agent without enough instruction on how to call the tool correctly.

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

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

With no annotations provided, the description has the full burden of disclosing behavior. It only discloses that no browser is launched; it does not explain what 'opened' means, whether a network request is made, what side effects or rate limits exist, or what the return value indicates. The schema mentions that several parameters are 'discarded,' but the description itself adds little 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 two short sentences with no wasted words. The main action is front-loaded, and the clarifying no-browser statement 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 tool has no output schema and no annotations, so the description must compensate. It does not explain what the tool returns (e.g., boolean, status, details) or how the URL check is performed. The gap between the URL-focused description and the 9-parameter schema with discarding behavior is left entirely unexplained, making the description insufficient for reliable invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific information, but the schema already documents each parameter's meaning and discard behavior. This is acceptable given the high 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 and resource: 'Check whether a URL can be opened.' The second sentence, 'No browser is launched,' gives a useful distinction from browser-based tools. However, 'can be opened' is slightly ambiguous—it could mean reachable, valid, or renderable—and the description does not account for the many unrelated parameters in the 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?

The description implies a clear use case: checking URL openability without launching a browser. It offers an implicit exclusion of browser-dependent checks, but it never names alternatives such as browser-url-ok or states explicit when-to-use/when-not-to-use conditions.

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

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

No annotations are present, so the description carries the full burden. It does disclose one behavioral trait ('Query discarded'), which is useful, but it does not state what the function returns, how it handles multiple or no parameters, or whether all parameters are treated the same. This is minimal transparency for a tool with no annotation support.

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?

Both sentences earn their place: one states the core function, the other adds a behavioral note. The description is front-loaded and free of fluff. It is short, but the brevity leaves gaps in context; still, as written 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?

The tool has 9 optional parameters, no output schema, and no annotations, so the description must clarify what an agent should pass and what to expect back. It fails to specify which parameter is the 'search query' and does not define the return value. An agent invoking this from scratch would likely be uncertain whether to pass `query`, `ref`, `url`, or another field.

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 input schema already documents all parameters, including their meanings and discard behavior. The description adds almost no parameter-level meaning beyond repeating the 'discarded' idea and directing attention to 'a search query,' which helps identify the `query` parameter but does not explain it more deeply.

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 verb and resource: 'Count characters in a search query.' It is not a tautology and matches the tool name. However, it does not differentiate this tool from siblings like memory-key-count or hn-front-count, which also sound counting-oriented, so it stops short of 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 guidance is given about when to use this tool versus alternatives, and there is no mention of what counts as a 'search query' among the nine optional parameters. The description gives no exclusions, prerequisites, or alternative routing, leaving the agent without usage context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it discloses nothing: no side-effect profile, no read-only guarantee, no mention that inputs are discarded, and no return behavior. The word 'catalog' weakly implies a static reference, but that is not explicit.

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 brevity here comes at the expense of substance. It provides no structure, no front-loaded action, and leaves an 8-parameter tool almost completely unexplained. This is under-specification rather than effective 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?

The tool has eight diverse parameters, no annotations, and no output schema, yet the description only says it is a 'short catalog'. An agent cannot determine what input to provide, how the parameters relate to the catalog, or what the tool will return. This is far from complete.

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 for the eight parameters is essentially 100%, so the baseline is 3 even though the tool description adds no parameter meaning. The schema descriptions such as 'discarded after the shape check' and 'HTTPS URL to normalize or cite' are individually clear, but the description does not connect them to the catalog purpose.

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

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

The description is essentially a noun phrase restating the tool name: 'Short catalog of common HTTP status codes' matches 'status-catalog' almost word-for-word. It lacks a specific verb like 'returns' or 'lists', and gives no hint of what the eight input parameters have to do with the catalog.

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

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

There is no guidance on when to use this tool versus siblings like fetch-status, domain-shape, or validate-json. No conditions, exclusions, or alternative tool names are mentioned.

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

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

With no annotations, the description is the only behavioral disclosure. It does state that the prompt is discarded, which is a meaningful non-obvious behavior, but it says nothing else about side effects, input requirements, or response format. The schema's many 'discarded' hints are not part of the tool description, so the agent only gets one fragment of the 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 only two short sentences, which is concise, but not efficiently structured because it omits essential context. It front-loads the 'three-step thinking template' phrase but then introduces 'Prompt discarded' without context. For a tool with a large heterogeneous schema, this brevity is under-specification rather than purposeful 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?

The description does not state what the template looks like, which parameters are required, or what the tool returns. There is no output schema, so the agent has no way to know the response structure. The mismatch between the schema fields and the description makes the tool effectively unusable without external knowledge.

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

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

The input schema lists many parameters with individual descriptions, but the tool description does not explain how any of them relate to the returned template. It even mentions 'Prompt discarded' despite there being no 'prompt' parameter in the schema, creating confusion. The schema parameter descriptions describe unrelated actions (normalize, validate, check) that do not align with the stated purpose, so the description and schema together do not clarify invocation 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 names a concrete deliverable ('three-step thinking template') and a verb ('Return'), so the basic function is perceivable. However, the term 'thinking template' is undefined and the description does not distinguish this from sibling tools like validate-json or fetch-status. It reads as a stub rather than a precise specification.

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 mention of when to use this tool, what problem it solves, or which sibling to prefer instead. The description gives zero routing information, leaving an agent to guess whether it should call think-steps or another tool like search-query-len or web-fetch.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it only offers 'Current time in a named IANA timezone.' It does not state what happens for invalid zone names, whether the result depends on a live network clock, or what the response shape is. This leaves the agent without critical expectations about side effects 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?

A single front-loaded sentence with zero filler. It gets straight to the core function and respects the reader's attention.

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

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

Despite 9 parameters and no output schema or annotations, the description supplies almost no operational context: it does not clarify which parameter is the operative input, what the output format is, or why the many 'discarded' parameters exist. An agent would be unsure whether to pass only 'zone' or all nine fields, a critical gap for a correctly invoked tool.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter info in the description. The description does add meaning to the 'zone' parameter by labeling it as the IANA timezone being reported; it does not clarify why the other eight parameters are present or how they relate to a timezone lookup.

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 pair: it returns the current time for a named IANA timezone. It is distinguishable from siblings like iana-zones (which lists zones) and utc-time (which presumably returns UTC), but it does not explicitly name those alternatives or draw the contrast.

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 utc-time or iana-zones, and no mention of prerequisites (e.g., needing a valid IANA name). The description is purely declarative; the agent must infer usage context entirely from its own knowledge.

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

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

With no annotations, the description carries the full burden, but it only describes the output. It does not disclose whether the tool has side effects, whether all parameters are ignored, or how the 9 unrelated input parameters relate to the tool's behavior.

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

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

The description is a single concise sentence with no filler. It is appropriately front-loaded, though it omits context that might be expected given the large 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?

The tool has 9 optional parameters and no output schema or annotations, yet the description provides no guidance on what to pass or what return format to expect. The mismatch between the simple description and the broad input schema leaves an agent uncertain about correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds no parameter-level meaning, but the high schema coverage establishes the baseline of 3.

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

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

The description 'Current UTC timestamp.' clearly states the tool's output with a specific verb and resource. It is distinct from siblings like timezone or iana-zones, but it does not explicitly call out that 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 implies use when a current UTC timestamp is needed, but it gives no explicit when-to-use or when-not-to-use guidance. It does not mention alternatives such as timezone for localized time or iana-zones for zone names.

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 burden of behavioral disclosure. It does add one meaningful behavioral trait: the body is discarded, implying a stateless, side-effect-free check. But it does not state the result format (boolean vs error), whether only the 'json' parameter is considered, or what happens for malformed JSON beyond 'invalid'.

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 core validation action is front-loaded, and the discard behavior is added in a single follow-up sentence. 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 the apparently simple core action, the tool has seven string parameters with no required markers, no output schema, and no mention of what the caller should expect back. The description also never identifies which schema parameter is 'the body', so an agent cannot confidently know what to pass or what result is returned.

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 provides descriptions for all seven parameters, including 'json' described as 'JSON text to validate', so schema coverage is high and the baseline is 3. The tool description adds no additional parameter meaning and even obscures the mapping by referring to a generic 'body' rather than the 'json' field.

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

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

The description states a specific action ('Check whether') and a resource ('a body is valid JSON'), which clearly distinguishes it from the other shape/ok validators in the sibling list. However, the term 'body' is not explicitly mapped to the 'json' parameter in the schema, so there is slight ambiguity about which input is the actual JSON payload.

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 any of the many validation-focused siblings such as domain-shape, file-path-ok, or browser-url-ok. There are no explicit when-to-use, when-not-to-use, or alternative tool references, leaving the agent to infer usage solely from the name.

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

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

With no annotations, the description carries full responsibility for behavioral transparency. It mentions the external service Open-Meteo but does not disclose failure modes, network dependence, rate limits, or what happens with invalid input.

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, front-loaded, and contains no unnecessary words or filler. It delivers the core purpose in a single sentence.

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 severely incomplete. It does not explain which parameters matter, the expected output format, error behavior, or how to handle the many irrelevant fields in the schema.

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

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

The schema descriptions are generic and many parameters are unrelated to temperature. Only 'city' and possibly 'zone' are relevant, but the description does not clarify that the other parameters are ignored or unsupported.

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 indicates the tool provides current temperature for a city via Open-Meteo, which distinguishes it from sibling tools. However, it lacks an explicit verb and is slightly terse.

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 the many sibling tools, nor any indication of prerequisites or alternatives.

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

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

With no annotations, the description carries the burden, and the explicit 'Body discarded' is a useful behavioral disclosure. Yet it does not mention network behavior, redirects, failure modes, or rate limits; it only gestures at a lightweight fetch.

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, each carrying information: the operation/result and the body-discard behavior. There is no filler or duplication of schema content.

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

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

Despite the simple description, there are nine heterogeneous optional parameters and no output schema. The description does not reconcile why city, feed, json, path, zone, ref, etc. are accepted, nor does it define the exact output shape or error behavior, leaving an agent uncertain about invocation edge cases.

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

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

Schema description coverage is 100%, so the schema already documents every parameter, and the description adds no extra parameter semantics beyond the URL focus. Baseline 3 is appropriate because the description is not required to repeat schema details, but it also does little to clarify the unexpected non-URL 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 clearly states the tool returns HTTP status and content type for a public URL and discards the body, which is specific enough to understand the core operation. It does not explicitly differentiate from similarly named siblings like fetch-status or browser-url-ok, but the resource and output are 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 intended use is implied: call it when you only need HTTP status and content type for a public URL, not the response body. However, it names no alternatives or explicit when-not-to-use conditions, and siblings with overlapping fetch/status purposes make the choice less clear.

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 already declare readOnlyHint, destructiveHint=false, and idempotenceHint=true, so the safety profile is covered. The description adds the context that the title is discarded after the call, which clarifies lack of statefulness, but it does not mention network behavior, return shape, or failure semantics.

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?

Both sentences earn their place and there is no fluff. The core action is front-loaded and the discard behavior is stated concisely, though the brevity comes at the cost of necessary parameter guidance.

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

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

With seven mostly unrelated generic parameters, no output schema, and no annotation-level detail beyond safety, the description is not complete enough for correct invocation. The missing title parameter and lack of return-value information make this tool effectively unusable from the provided definition.

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

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

The input schema contains seven parameters, each with its own description, but none is named or described as a Wikipedia title. The tool description does not map 'Wikipedia title' to any schema property, leaving an agent unable to determine what to pass; this is a significant semantic mismatch despite high schema description 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 verb ('Check') and resource ('whether a Wikipedia title exists'), which clearly communicates the core function. It is distinguishable from sibling tools like 'validate-json' or 'domain-shape', though it does not name a sibling alternative.

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

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

The description gives no guidance on when to use this tool versus other 'ok'-style sibling tools, and no exclusions or alternative tool names. The only inferred usage is 'when you need to check a Wikipedia title', but this is not explicit.

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