ISO country PE

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

With no annotations, the description carries the disclosure burden. It clearly states that task text is discarded and labels the gateway as public and pay-per-call, while enumerating the returned artifacts. It does not discuss side effects or access requirements, but the disclosed behaviors are meaningful.

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 crisp sentences with no filler. The core action, return payload, and discard behavior are all front-loaded and every sentence 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 covers the main return artifacts and the discard behavior, which is useful given no output schema. However, it leaves ambiguity about which parameters, if any, should be supplied and how the returned items are structured, making invocation still partially guesswork.

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

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

Schema coverage is 100%, so the schema already documents the six string parameters individually. The description only adds the generic 'Task text discarded' note and does not explain how these parameters relate to finding Monid, so it provides no additional semantic value.

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

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

The description states a specific verb and resource: find the public Monid pay-per-call gateway, and lists four return artifacts. It is reasonably distinct within the sibling set, though it does not explicitly contrast with alternatives like 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 intended use is implied: call this when the agent needs Monid's CLI setup, how-it-works, skill file, or remote MCP hops. There is no mention of alternatives, exclusions, or when not to use it.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose at least one meaningful behavior: no browser is launched. However, it does not explain what 'can be opened' actually entails (URL format check, HTTP request, DNS lookup), whether side effects or network calls occur, or what the return value looks like. The schema parameter descriptions mention discarded inputs, but the tool description itself remains 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 compact and front-loaded: the first sentence states the action, the second clarifies a key behavioral distinction. There is no filler. It could have added a brief note about which parameter to use, but as written it is efficient and easy to parse.

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

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

The tool has 9 optional parameters and no annotations or output schema, yet the description only addresses URL checking. It does not tell the agent which parameter to populate, what the result looks like, or whether a network request is made. The narrow description combined with the broad schema leaves too much to inference, making the definition incomplete for correct invocation.

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

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

The input schema has 100% description coverage, with each parameter individually explained, including which values are discarded. The tool description adds no parameter-level meaning beyond the schema. Since the schema already documents the parameters thoroughly, the baseline score of 3 is appropriate.

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

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

The description gives a clear verb and resource: 'Check whether a URL can be opened.' It also adds a useful differentiator, 'No browser is launched,' which separates it from the sibling playwright-url-ok. However, the schema contains 9 unrelated optional parameters, and the description does not clarify that this tool only cares about the url parameter, slightly muddying the overall scope.

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

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

There is no explicit when-to-use or when-not-to-use guidance. The phrase 'No browser is launched' implies a contrast with playwright-url-ok, but the description does not state conditions for choosing this tool over normalize-url, fetch-status, web-fetch, or other siblings. The usage context is only implicit, not explicit.

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 transparency burden, but it only says 'Expression discarded,' which is fragmentary and does not align with the schema since there is no expression parameter. It does not say whether this is read-only, what side effects occur, whether auth is required, or what is returned. The mismatch between 'Evaluate' and 'discarded' leaves the tool's behavior genuinely unclear.

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

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

The description is short and front-loaded, with little wasted wording. However, 'Expression discarded' is isolated and under-specified, and a one-line description is thin given a nine-parameter schema. It is concise but not effectively structured to support correct invocation.

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 dramatically incomplete. It does not specify which parameter carries the expression, what the output or return format is, or how it relates to sibling functionality. An agent cannot reliably construct a correct call from this 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?

All nine parameters have schema descriptions (100% coverage), so the baseline is 3. The tool description adds no parameter-level meaning and never maps any schema field to the arithmetic expression it claims to evaluate. It neither improves nor degrades the schema's already high parameter coverage, though the mismatch is a concern.

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 an operation ('Evaluate a+b style arithmetic') and so says what the tool does at a high level. But the input schema exposes nine unrelated parameters and no arithmetic-expression field, making the stated purpose disconnected from how the tool is actually invoked. It also does not distinguish calc-eval from the many sibling shape-check/validation 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 when-to-use, when-not-to-use, or alternative sibling tools are mentioned. With many shape-checking siblings such as validate-json, search-query-len, and domain-shape, an agent gets no basis for choosing calc-eval over them. The only implied hint is 'arithmetic', but no selection condition or exclusion is 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 burden of disclosing behavior. It meaningfully states 'Page content is not stored' and lists the exact returned values. However, it does not mention side effects, error behavior, network behavior, or that several accepted parameters 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?

Two concise sentences with no filler. The purpose is front-loaded, and the second sentence adds a meaningful behavioral guarantee about non-storage.

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 core return values are stated, which is useful since there is no output schema. However, with nine optional parameters, no annotations, and several apparently unrelated fields, the description is too terse to fully orient an agent. The schema partially compensates by describing each parameter, but the tool-level picture remains ambiguous.

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 no parameter-level information and does not clarify which of the many optional parameters are actually relevant to the URL citation behavior. The schema itself provides the discard notes, but the description does not tie them together.

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 and resource: 'Return host, scheme, and HTTP status for a URL.' This is a specific verb and output, and the focus on URLs distinguishes it from non-URL siblings. It doesn't explicitly distinguish itself from fetch-status or web-fetch, so it loses a point.

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 URL-related siblings such as normalize-url, fetch-status, or web-fetch. 'Page content is not stored' hints at a citation use case, but no explicit 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 description contributes one meaningful behavioral fact: 'No identifiers are retained.' Parameter descriptions also mention discarding ref, city, json, and path values. However, with no annotations, the description still fails to disclose whether the tool makes network calls, whether it is read-only, 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 two short sentences with no filler. The primary action is front-loaded, and the second sentence adds a useful privacy guarantee. 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?

With no annotations and no output schema, the description must explain expected results and usage boundaries, but it only gives a vague action and a privacy note. It does not clarify how the heterogeneous parameters relate, what output to expect, or how this tool differs from the many similar sibling tools. This is incomplete 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?

The input schema already provides 100% parameter descriptions, so the tool description itself adds no extra parameter meaning. Statements like 'discarded after the shape check' live in the schema, not in the description. A baseline score of 3 is appropriate because the schema does the heavy lifting.

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

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

The description states a verb and object: 'Show how this request is classified.' However, it never defines what classification means, what categories are returned, or how the output is structured. The tool name 'compatibility' and the large sibling list do not clarify this ambiguity.

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 mention when to use this tool instead of a sibling like domain-shape, validate-json, or fetch-status. There are no alternatives, exclusions, or conditions given, leaving an agent to guess based on the vague phrase 'how this request is classified.'

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 states a transformation and a data limitation, but does not say whether any I/O occurs, what the return value looks like, or how malformed inputs are handled. The schema notes that several fields are discarded, but the overall behavior remains underspecified.

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

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

The description is a single sentence with no filler and front-loads the core operation. Its brevity is a conciseness strength, even though the under-specification hurts 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?

For a tool with 9 optional parameters, no output schema, and no annotations, this description leaves too much implicit: expected output, which parameter applies in which scenario, and error behavior. The schema partially compensates for parameter semantics, but the overall call contract is still incomplete.

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

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

Schema coverage is 100%, with every parameter having its own description, so the baseline is met. The free-text description adds no parameter-level meaning beyond what the schema already provides. Some schema descriptions, like 'discarded after the shape check,' are actually more informative than the main 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?

Description uses a specific verb ('Split') and resource ('hostname'), and adds a useful negative scope ('without WHOIS or ownership data') that distinguishes it from lookup-style tools. However, the 9-field input schema suggests a broader set of inputs, so the stated purpose is clearer than the actual schema implies.

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

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

The only usage guidance is the negative constraint 'without WHOIS or ownership data,' which tells an agent what the tool does not provide. It does not name sibling tools or state when to prefer domain-shape over normalize-url, file-path-ok, or related validity-checking tools. Usage context is implied but not explicit.

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 the HEAD method and status-only output, but the input schema exposes nine optional parameters describing unrelated checks (city, json, query, path, etc.). The description does not explain whether these are alternate uses, ignored, or invalid, nor does it describe response or error behavior. This creates significant ambiguity.

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

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

The description is a single, front-loaded sentence that states method, resource, and expected output with no filler. Every word earns its place, though the overall terse-ness hurts completeness rather than 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?

For a tool with nine optional parameters, no annotations, and no output schema, one clause is insufficient. The agent cannot tell whether non-URL parameters are alternative modes, ignored inputs, or invalid, nor what 'status' means for each. The schema helps per-parameter, but the description does not unify the tool's behavior.

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 HEAD/status meaning for the url parameter, which the schema itself does not state ('HTTPS URL to normalize or cite'), but it adds nothing for the other eight optional parameters. The baseline of 3 is appropriate.

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

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

The description names a specific operation and resource: 'HEAD a public URL' and clearly states the outcome 'return status only.' This distinguishes it from full-fetch siblings like web-fetch, though it does not explicitly differentiate from URL-checking siblings such as browser-url-ok or playwright-url-ok.

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

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

'Status only' implies a lightweight use case where the caller just needs the HTTP status, and 'public URL' establishes context. However, it never names alternative tools or states when not to use this tool, leaving routing to inference among many sibling tools.

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

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

With no annotations, the description must explain side effects and behavior itself. It only says the path is discarded, which directly conflicts with the schema's 'path' parameter described as 'File path to check'. It also does not disclose whether the operation is read-only, what it returns, or how invalid 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 short and front-loaded, but the fragment 'Path discarded' creates more ambiguity than value. It is concise, but the brevity sacrifices needed clarity.

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

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

For a tool with 9 parameters, no annotations, no output schema, and many sibling tools, this six-word description is insufficient. An agent cannot determine which parameter to pass, what the tool returns, or how to distinguish it from normalize-url and browser-url-ok.

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%, but the description does not clarify which of the nine parameters are relevant for a Figma URL shape check. The 'Path discarded' comment contradicts the schema's path parameter, and the url description ('HTTPS URL to normalize or cite') is not aligned with the stated Figma parsing 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 identifies a specific verb and resource ('Parse a Figma file URL'), which distinguishes it from generic URL tools like normalize-url. However, it never states what the parse produces or whether this is a validation, normalization, or extraction tool, and 'Path discarded' is ambiguous.

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

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

There is no guidance on when to use this tool versus normalize-url, browser-url-ok, or any of the other shape-checking siblings. The only hint is the word 'Figma', with no exclusions, conditions, or comparison to 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It adds one useful fact—'No disk access'—but does not explain what the tool returns, what 'safe' means, or what validation rules are applied.

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 compact and front-loaded, with no filler or repetition. Both sentences earn their place, though the brevity comes at the cost of missing useful behavioral and usage detail.

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

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

For a tool with no output schema and no annotations, the description leaves important gaps: no return value, no explanation of the nine optional parameters' collective role, and no safety criteria. An agent would likely need to probe the tool or consult the schema further before invoking it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description adds no parameter detail. The description does not clarify which of the nine parameters is relevant, but the schema itself documents each field and its discard 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 uses a specific verb and resource: 'Check whether a path looks safe.' It adds a useful boundary with 'No disk access,' distinguishing it from URL- or title-focused validators. However, 'safe' is left vague, and the schema's nine unrelated parameters create some ambiguity about the actual scope.

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

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

No guidance is given about when to use this tool versus sibling validators such as browser-url-ok or wiki-title-ok. The description implies path validation but does not state when to choose it, when to avoid it, or how it relates to alternatives.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only mentions the Open-Meteo dependency and the returned coordinates; it is silent on whether this is a live network call, whether inputs are discarded, error/rate-limit behavior, or response format.

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

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

The one-sentence description is front-loaded and has no filler. It is concise to the point of under-specification for a nine-parameter tool, but the wording itself is economical and clear.

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

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

For a tool with nine optional parameters, no annotations, and no output schema, a single outcome sentence is insufficient. The agent is not told which parameter to populate, what the response structure is, or how geo-hint differs from nearby hint/validation 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?

The input schema already documents all nine parameters, so the description is not required to repeat them, giving a baseline of 3. However, the description adds no guidance about which parameter identifies the 'place' (likely city), so it contributes nothing 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 output (latitude and longitude) and the service (Open-Meteo), which is enough to distinguish geo-hint from weather-hint or timezone. It lacks an explicit verb and does not resolve which of the many optional inputs counts as the 'place', so it is clear but not maximally precise.

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 when-to-use or when-not-to-use guidance and names no alternatives, despite many overlapping sibling tools such as weather-hint and timezone. The only implied usage is whatever the agent infers from the purpose sentence.

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. 'Parse' implies a read-only operation, but the description does not disclose behavior on invalid or non-GitHub URLs, whether it validates URL structure, what it returns, or that many schema parameters are discarded after a shape check.

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 efficient, though it omits enough contextual guidance that it borders on under-specified.

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, no output schema, and a large input schema with unrelated-looking parameters such as city, feed, json, path, and query. A one-line parse description is insufficient for an agent to know which parameter to pass, what output to expect, or how to handle 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 high, so the baseline is 3. The description adds specific meaning to 'url' (GitHub owner/repo extraction) but conflicts slightly with the schema's generic 'HTTPS URL to normalize or cite' and does not clarify the relevance of the remaining 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 action ('Parse') and a specific resource ('owner and repo from a GitHub URL'), making the core purpose clear. It does not, however, explicitly distinguish this from sibling shape tools or explain what a successful parse returns.

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 like figma-url-shape, jira-key-shape, or normalize-url, nor any exclusions such as handling non-GitHub URLs. An agent must infer context.

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

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

No annotations are present, so the description carries the burden. It discloses that titles are discarded and implies a read-only count of live front-page data, but it does not state what happens with the supplied optional parameters, what exact value is returned, or failure/rate-limit 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?

Two terse sentences with the core verb+object first, followed by the important 'Titles discarded' caveat. No filler words; the structure is ideal for a tool this simple.

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, and the description does not state return type, error behavior, or how to treat the nine optional parameters. An agent could call it with no arguments, but the ambiguity around whether to pass 'feed' or 'url' is unresolved, making the description incomplete for confident invocation.

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

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

Schema coverage is 100% and all 9 parameters are optional with individual descriptions, so the baseline is 3. The description itself does not tie any parameter to the tool's function, which is acceptable because none are required, but it also doesn't clarify whether parameters are ignored.

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 ('Count'), a precise target ('current Hacker News front-page stories'), and an explicit exclusion ('Titles discarded'). This clearly distinguishes it from fetching/display tools like web-fetch and from the various shape-check siblings.

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

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

The wording implies the tool should be used when only a story count is needed, not when titles or story content are required. It does not explicitly name alternatives or give when-not-to-use guidance, so usage guidance 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?

No annotations are provided, so the description carries the full burden of explaining behavior. It does not state whether the tool returns a list, validates timezone names, or ignores the supplied parameters. The schema's 'discarded' notes hint at unusual behavior, but the description itself is silent.

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 the key noun phrase, but it is more of a fragment than a complete sentence. Brevity is achieved at the cost of essential behavioral and usage detail.

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

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

With no output schema, no annotations, and nine optional parameters, a single noun phrase is insufficient for an agent to know how to call the tool correctly. The description does not clarify what parameters to pass, what response to expect, or how the odd 'discarded' behavior works.

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 every parameter already has a schema description explaining its value and whether it is discarded. The tool description adds no parameter-level guidance and does not explain how these unrelated parameters relate to timezone names, so a 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 identifies a resource ('Common IANA timezone names') and a context ('for clock calls'), but it is a noun phrase rather than a statement of what the tool does. It does not clearly distinguish iana-zones from sibling tools like timezone or utc-time beyond the vague 'clock calls' reference.

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 only an implied usage hint ('for clock calls') and no explicit guidance on when to use this tool versus alternatives. There are no exclusions, preconditions, or comparisons with sibling tools, so an agent has to guess when this tool is appropriate.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose that this is a read-only network fetch and that the result is only group counts, which is helpful. However, it omits error behavior for missing robots.txt files, how the target host is determined, and any network or rate-limit caveats.

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 efficiently states both the action and the intentionally limited return value.

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

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

Given nine optional parameters, no output schema, no annotations, and many closely related sibling tools, one sentence is insufficient. The description does not explain which parameter selects the target robots.txt or what 'group counts' means structurally, making correct invocation largely dependent on inference.

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

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

The input schema has 100% description coverage, so the baseline is 3. The tool description adds robots.txt context but does not connect it to any specific parameter such as host or url, leaving the agent to infer which of the nine parameters is actually used.

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

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

The description states a specific action and resource ('Fetch a public robots.txt') and clarifies the narrow output ('return group counts only'). This distinguishes it from generic fetch tools like web-fetch, though it does not explain how the target is selected.

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 siblings such as web-fetch, fetch-status, or domain-shape. No alternatives, exclusions, or conditions are given, so the agent must infer usage from the 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?

With no annotations, the description carries the disclosure burden. It does reveal that the key is discarded, which is useful privacy-relevant behavior, but it omits any statement about return value, failure behavior, or whether other inputs are ignored.

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 first states the action and the second a relevant side effect. It is front-loaded 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?

The tool has no output schema and no annotations, and the core input parameter is ambiguous. The description does not explain the accepted shape, return format, or which schema field to populate, so an agent cannot reliably invoke the 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 description refers to a Jira issue key, but the input schema exposes parameters such as ref, url, city, feed, host, json, path, and query, none of which is described as a Jira key, and additionalProperties is false. An agent cannot determine which parameter should hold the key, so the description fails to add usable parameter semantics despite 100% schema coverage.

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

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

The description states a specific action and resource: it checks the shape of a Jira issue key. This distinguishes it from sibling shape-check tools such as github-repo-shape or domain-shape, though it does not spell out the expected key format.

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 rather than the many sibling format-checkers, nor any prerequisites or exclusions. Usage is only implied by the tool name and the phrase 'Check a Jira issue key shape.'

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 important behavior—the response body is discarded—so the agent knows not to expect page content. But it is silent on response shape, error behavior, and whether this is a safe 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?

Two short sentences, front-loaded with the core function and a key result constraint, with no filler. It is appropriately brief, even though the missing usage context 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?

The tool has 9 optional parameters, no required parameters, no output schema, and no annotations, but the description only covers one URL-status scenario. It does not explain what to do with the other parameters (city, feed, host, json, path, zone, query) or what exactly is returned, leaving the definition incomplete for correct invocation.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description adds only a slight contextual association between 'public library docs URL' and the url parameter; it does not meaningfully explain the many optional parameters or how they interact.

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 resource ('public library docs URL') and a specific result ('HTTP status'), and adds a scope-limiting trait ('Body discarded'). It is clearly more informative than a tautology, though it doesn't explicitly differentiate from sibling URL-status tools such as fetch-status or browser-url-ok.

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

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

Use is implied: if an agent needs the HTTP status of a public library docs URL, this tool is a candidate. However, the description gives no when-not-to-use guidance or alternatives, and the broad nine-parameter schema makes it unclear when this tool should be chosen over similar URL-check 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?

With no annotations provided, the description carries the full behavioral burden. 'Values discarded' is a useful disclosure, but the description does not say whether the operation mutates anything, what it returns, or how edge cases like empty objects 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?

Two short sentences with no filler. The action is front-loaded, and both sentences earn their place: one defines the operation, the other defines the operational scope.

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

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

Without annotations or an output schema, and with 9 optional parameters, the description is too terse. It does not state how the JSON object is supplied, whether nested keys count, or what the return value looks like.

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 meaning and leaves unclear which schema property carries the JSON object, unless it is meant to refer to the entire set of input arguments.

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

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

The description states a specific action ('Count') and resource ('JSON object'), and adds the clarifying scoping that values are discarded. It does not explicitly distinguish itself from siblings such as validate-json, 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?

There is no when-to-use guidance, no exclusions, and no mention of alternatives among the many sibling tools. 'Values discarded' weakly implies a use case, but it is not enough orientation for selecting this tool over similar ones.

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

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

The description discloses a key transformation: query and fragment are dropped. However, no annotations are provided, and the description does not mention error behavior, whether the tool is purely local, or what happens if the URL is invalid. It provides some transparency but not full coverage.

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 main purpose is front-loaded, and the second sentence adds a meaningful behavioral detail without redundancy.

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

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

With nine optional parameters and no output schema, the description does not clarify that only the 'url' parameter is the real input for normalization, nor does it explain what happens if other parameters are supplied. The gap between the simple description and the large optional schema creates real invocation ambiguity.

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 parameters. The description adds no parameter-level meaning beyond clarifying that the URL's query and fragment are removed, which is a minor semantic contribution.

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

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

The description clearly states the action ('Return') and the exact output ('origin, host, and path') for a URL, so an agent can understand the tool's core function. It does not explicitly distinguish itself from URL-related siblings like browser-url-ok or fetch-status, 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?

There is no guidance about when to use this tool versus alternatives such as browser-url-ok, fetch-status, or citation. The intended usage is only implied by the tool's name and output description, not stated with conditions or exclusions.

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

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

Annotations already establish read-only, non-destructive, idempotent behavior. The description adds an important operational detail—'No browser is launched'—which prevents the agent from assuming Playwright will open a real browser. It does not detail return values or timeout behavior, but the core execution trait is disclosed.

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 main action is front-loaded, and the key caveat ('No browser is launched') 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?

The tool has 7 heterogeneous parameters and no output schema, yet the description only addresses URLs and provides no context for the unrelated-looking parameters. It also does not explain what 'ok' means (reachable, valid, or something else) or what result the agent should expect.

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 individual descriptions for all 7 parameters, so schema coverage is high. The description itself adds no parameter semantics beyond the schema, and it does not explain why parameters like city, json, or ref are relevant to a URL-open 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 states a specific action ('Check whether a URL can be opened') and a key differentiator ('No browser is launched'), which helps distinguish it from siblings like browser-url-ok. However, the input schema contains many non-URL parameters (city, json, ref), creating ambiguity about the tool's true scope, so it is not a full 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 'No browser is launched' implies this is a lightweight alternative to browser-based checking, but the description never explicitly states when to use this tool versus alternatives such as browser-url-ok or web-fetch. Guidance is implied rather than explicit.

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 disclosing side effects, and it does state that the query is discarded. This is a useful transparency signal. However, it does not mention the fate or role of the other eight accepted parameters, nor clarify whether any other processing occurs, leaving the behavioral picture incomplete.

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

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

Two short sentences with the action front-loaded and no filler. 'Query discarded' earns its place because it conveys an important behavioral fact that is not otherwise obvious.

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 core operation and data handling are described, but the tool has nine optional parameters, no required parameters, and no output schema. The description does not state that only 'query' is relevant, what the return value looks like, or how to handle the other accepted fields. It is minimally adequate but leaves functional gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail; the schema's 'query' parameter description ('Search text; discarded after the length check') is what actually clarifies the relevant 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 states a specific action ('Count characters') and resource ('search query'), which clearly distinguishes it from the URL/domain/JSON checkers among siblings. It does not explicitly name sibling tools, but the subject is unambiguous. 'Query discarded' adds behavioral context without obscuring the core 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 purpose implies when to use this tool: when the length of a search query is needed. However, there is no explicit guidance about alternatives, exclusions, or when not to use it, so the agent must infer usage from the name and the query parameter 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?

No annotations are present, so the description carries the full burden. It only says 'short catalog' and does not disclose that most parameters appear to be discarded, whether the operation is read-only, or what output format to expect.

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

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

The description is a single terse sentence with no filler or repetition. It is front-loaded and every word is relevant, though it sacrifices detail for brevity.

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

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

Given 9 optional parameters, no output schema, and no annotations, a one-sentence noun phrase is insufficient. The description does not explain how parameters relate to the tool, whether they affect the catalog, or what the returned catalog looks like.

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

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

Schema description coverage is 100%, with each of the 9 optional parameters having its own description. The tool description adds no parameter meaning, but the schema already documents that most values are discarded, so the baseline of 3 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, 'Short catalog of common HTTP status codes,' clearly identifies the resource and implies the tool returns a reference list. It lacks an explicit verb and does not explicitly distinguish itself from siblings like fetch-status, 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?

There is no guidance on when to use this tool versus alternatives such as fetch-status or other sibling tools. No context, exclusions, or selection criteria 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 burden, and it does disclose one meaningful behavior: the prompt is discarded, implying calls with a prompt are wasteful. It also frames the tool as a pure return/generator with no side-effect language. However, it does not say whether any of the listed parameters are actually consumed or what the returned template contains, leaving some behavioral ambiguity.

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

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

Two short sentences with no filler; the purpose is front-loaded and 'Prompt discarded' is a high-value behavioral caveat. This is appropriately sized for a very simple tool.

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

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

The description is minimally complete for a no-input generator: an agent can infer that an empty call returns a template. But there is no output schema and no description of the template's structure, and the reason for 9 optional schema parameters is unexplained at the tool level. Given that complexity, this is a clear gap but not a fatal one.

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 every parameter is optional and individually described in the schema, so the baseline of 3 applies. The tool description adds no parameter-specific meaning beyond 'Prompt discarded', which weakly suggests all parameters may be ignored.

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 verb ('Return') and a concrete resource ('a three-step thinking template'), so the core purpose is clear. It adds 'Prompt discarded' to show this is not a prompt-processing or LLM call. It does not explicitly contrast with siblings, but no sibling tool appears to offer a thinking template, so it is adequately distinguishable.

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 invoke this tool versus any alternative, no prerequisites, and no exclusions. The agent must infer usage from the name 'think-steps' and the generic output statement. This is below minimum viable guidance for a 9-parameter 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 transparency burden. It correctly implies a read-only lookup by describing 'current time,' but it does not disclose return format, invalid-timezone behavior, or that unrelated schema parameters are ignored. This is adequate but not richly 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 a single, front-loaded sentence that communicates the core purpose with no filler. Every word earns its place, and the structure is easy to parse.

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

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

The definition is minimally workable: the description states the output and the schema documents all parameters. However, with no output schema, no annotations, and a schema containing many apparently unrelated parameters, the description should clarify that only the 'zone' parameter is relevant and could mention output format or alternative tools. This leaves clear gaps.

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

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

Schema coverage is 100%, so each parameter is already described, including 'zone' with an example. The description adds no parameter detail beyond the phrase 'named IANA timezone,' which is essentially the same as the schema's own description. Baseline 3 is appropriate because the schema carries the parameter documentation.

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

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

The description clearly states the tool's function: returning the current time for a named IANA timezone. It implies the core input and is distinguishable from sibling tools like utc-time and iana-zones, though it does not explicitly name those alternatives.

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

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

Usage is implied rather than stated: an agent would use this when it needs the current time in a specific IANA timezone. There is no explicit guidance about alternatives, exclusions, or when not to use this tool, so the guidance is only moderately helpful.

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 conveys the basic behavior: the tool supplies the current UTC timestamp. However, with no annotations, the description carries the full burden and does not disclose output format, side-effect-free behavior, or that supplied parameters are ignored.

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 fluff, earning high marks for conciseness. It loses one point because it front-loads no useful context such as output format or argument irrelevance, so it is efficient but not structurally informative.

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

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

Given there is no output schema and no annotations, this description is under-specified. An agent cannot tell whether the timestamp is an ISO string or Unix epoch, nor that all input fields are ignored. A complete description for this simple tool would require at least the return format and a note that parameters are optional/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?

The description says nothing about parameters, and the input schema contains seven unrelated properties whose descriptions imply actions like 'normalize or cite', 'validate', or 'check'. The description does not clarify that these parameters are irrelevant or discarded, which can mislead an agent into passing arguments expecting them to affect behavior.

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

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

The description names the exact output: 'Current UTC timestamp.' It is clear that the tool returns the current UTC time and is distinguishable from siblings like timezone by specifying UTC. It lacks an explicit verb like 'returns' or 'gets', so it is not quite a 5, but the purpose is unambiguous.

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

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

No guidance is given about when to use this tool versus alternatives such as timezone or iana-zones. The description does not mislead, but it provides no context about selection or exclusion criteria.

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 does disclose that the body is discarded, which is useful, but it does not explain what is returned for valid versus invalid JSON, whether only syntax is checked, or whether errors are thrown. This is a significant gap for a validator with no output schema.

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

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

Two short sentences with no filler. The purpose is front-loaded, and the side-effect note ('The body is discarded') is concise and relevant.

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, so the description should clarify the result shape and which input is the JSON text. The schema covers the parameters, but the missing return semantics leave the definition incomplete for an agent deciding how to invoke and interpret the 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. The description adds no parameter-level meaning and even uses 'body' where the actual parameter is 'json', but the schema descriptions already clarify the parameter roles. The description neither compensates for nor harms parameter understanding.

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

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

The description states a specific verb ('Check'), a clear resource ('whether a body is valid JSON'), and is distinct from sibling validators like domain-shape or file-path-ok. The tool name and description together unambiguously identify JSON validation as 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?

Usage is implied rather than explicit: the agent can infer to use this when JSON validity needs to be checked. However, it does not mention alternatives, exclusions, or any prerequisites, so the guidance is only minimally adequate.

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 behavioral burden. It mentions Open-Meteo, suggesting an external API call, and 'current' implies a read-only operation, but it does not disclose that the other eight optional parameters appear irrelevant, whether there are side effects, rate limits, or what the response contains beyond temperature.

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, scannable sentence with no wasted words. It is concise and front-loaded, though slightly too terse to carry the additional context needed for a tool with many optional parameters.

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

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

The tool has nine optional parameters, no annotations, and no output schema, so the description needs to explain which parameter matters and what behavior to expect. It does not mention that city is the operative parameter, what happens with the other fields, or what the tool actually returns, leaving the definition incomplete.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the tool description adds no parameter-level detail. The description only reinforces 'city' but does not help the agent choose among the nine unrelated optional parameters or clarify that most are likely ignored.

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

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

The description states the core purpose clearly: returning the current temperature for a city via Open-Meteo. It is specific enough to identify the domain, but it lacks an explicit verb and does not differentiate this hint tool from sibling tools like geo-hint.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The one-line purpose implies weather lookups, but an agent must infer usage from the tool name and description without any explicit routing or comparison to sibling tools.

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

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

The description adds one meaningful behavioral fact beyond the purpose: 'Body discarded.' This is useful context and is echoed in several schema parameter descriptions. However, with no annotations available, it does not disclose redirects, timeout behavior, authentication needs, error responses, or how content type is 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 very concise and front-loaded with the core purpose followed by a valuable caveat. There is no filler, but given the seven-parameter schema and many similar sibling tools, the terseness leaves important information out.

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 several URL-related sibling tools, the description is not complete enough. It does not specify which input parameter to use, what the returned status/content type format looks like, or when to prefer this tool over fetch-status, normalize-url, browser-url-ok, or playwright-url-ok.

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 schema coverage is high and the baseline is 3. The description adds 'public URL' which maps most directly to the url parameter, but it does not clarify the role of feed, host, ref, city, json, or path, nor explain whether they are ignored alternate inputs.

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 concrete verb and resource: it fetches HTTP status and content type for a public URL, and it adds the useful caveat that the body is discarded. However, it does not distinguish web-fetch from sibling tools like fetch-status or normalize-url, 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?

There is no guidance about when to use this tool versus alternatives. The phrase 'public URL' implies some boundary, but the description never names sibling tools or conditions such as 'use fetch-status for plain status checks' or 'use browser-url-ok for rendered page checks.'

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 disclosing side effects; it only states that the title is discarded after the call. It neither confirms read-only behavior nor explains what the tool returns (e.g., a boolean), so the behavioral picture is incomplete.

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

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

The single sentence is compact, but it is underspecified rather than deliberately concise: it omits the key parameter and result semantics. The brevity earns no credit because it sacrifices the information needed to call the tool.

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

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

Given the schema's seven unrelated parameters, absent annotations, and no output schema, a two-sentence description is wholly inadequate. The agent is left with no way to select the correct parameter, know the return value, or understand the tool's intended workflow.

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 tool description does not map any schema property to the 'title' it claims to check. Although every schema parameter has a description, those descriptions reference unrelated domains (Git refs, URLs, cities, feeds), so they do not clarify how to supply the required title.

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

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

The description states a recognizable purpose—checking whether a Wikipedia title exists—which goes beyond the tool name and is distinct from most siblings. However, the input schema exposes no 'title' parameter and instead lists unrelated fields (ref, url, city, feed, host, json, path), so an agent cannot tell what input actually supplies the title.

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

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

There is no when-to-use guidance, no alternatives, and no exclusions. Worse, the schema fields (git ref, weather city, RSS feed) are unrelated to title checking, making the tool actively misleading about how to invoke it.

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