Language fo

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

The description discloses that 'Task text discarded' and mentions 'Returns connection methods' but lacks detail on side effects, authentication, rate limits, or the meaning of 'connection methods'. No annotations are present, so the description carries the full burden but fails to provide sufficient transparency.

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

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

The description is concise with two sentences, but it is too terse and omits critical details. The structure is adequate, yet the lack of elaboration on key concepts like 'connection methods' and 'task text discarded' makes it less effective.

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

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

Given the tool's apparent meta-nature (finding a gateway for various task types), the description is incomplete. It does not explain how parameters map to tasks, what the output looks like, or why this tool should be chosen over sibling tools. The absence of an output schema and annotations heightens the need for contextual detail, which is missing.

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

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

Although schema coverage is 100%, the individual parameter descriptions are vague and inconsistent with the tool's stated purpose (e.g., 'Git ref name', 'City name for a public weather hint'). They mention 'discarded after the shape check' uniformly, which does not clarify how each parameter contributes to finding a gateway. The descriptions seem copied from generic validation tools and do not meaningfully explain parameter roles.

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 ('Find') and a clear resource ('public pay-per-call tool gateway') with some task examples, distinguishing it from sibling tools that likely provide direct data or checks. However, the mention of 'Task text discarded' introduces ambiguity about the actual operation.

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

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

There is no explicit guidance on when to use this tool versus alternatives like weather-hint, normalize-url, or validate-json. The description implies it covers multiple task types, but does not clarify selection criteria or parameter usage, leaving the agent to infer.

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

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

The only behavioral disclosure is 'No browser is launched,' which is a limitation but not a full picture. It does not state whether the tool makes network requests, what side effects might occur (e.g., redirects, cookie handling), or any permissions/rate limits. Since annotations are absent, this sparse disclosure 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 a single, concise sentence, which is easy to read. However, it lacks structure (e.g., examples, parameter groupings, return-value hints) and is too terse to be fully helpful, especially given the complex 9-parameter 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 description is minimal and does not cover the tool's full context: no return value/output schema, no error conditions, no mention of how the extra parameters should be treated, and no relation to sibling tools. For a tool with 9 parameters and no annotations, this is severely 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?

While every parameter has a description, several are explicitly marked as discarded (e.g., 'ref' says 'discarded after the shape check', 'query' says 'discarded after the length check'), implying they are irrelevant placeholders. This confuses rather than clarifies. The 'url' description ('HTTPS URL to normalize or cite') contradicts the tool's stated purpose of checking openability. No guidance on which parameters are required 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 states a specific action ('Check whether a URL can be opened') and resource (URL), but the meaning of 'can be opened' is ambiguous—does it involve an HTTP request, DNS resolution, or something else? It does not distinguish itself from sibling tools like 'fetch-status' 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?

There is no guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or relationships to sibling tools, leaving the agent to guess which tool fits a given scenario.

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

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

No annotations are present, and the description only vaguely mentions 'Expression discarded' without clarifying side effects, output behavior, or error handling. The statement is inconsistent with the provided parameters, so it does not meaningfully disclose 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 brief but not effectively front-loaded; it introduces an arithmetic purpose that is contradicted by the schema. Every word should add clarity, but here the phrase 'Expression discarded' adds confusion rather than 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?

With nine parameters and no output schema, the description is grossly incomplete. It neither explains what the function returns, how parameters are used, nor why they are diverse. The tool's behavior cannot be inferred from the description alone.

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

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

Each parameter in the schema has a description, but the tool description does not explain how any of these parameters relate to arithmetic evaluation. The descriptions cover individual parameters but fail to connect them to the tool's stated purpose, leaving the parameter roles unclear.

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

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

Description states 'Evaluate a+b style arithmetic' clearly, but the input schema contains parameters like url, city, feed, and zone that are unrelated to arithmetic. This mismatch makes the actual purpose ambiguous and confusing.

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

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

No guidance is provided on when to use this tool versus any of the sibling tools. There is no mention of alternatives, context, or prerequisites.

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

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

The description discloses that page content is not stored, which is a positive transparency note. However, it does not mention whether a network request is made, potential failures, or side effects beyond that. Without annotations, this 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 a single sentence, concise and to the point, with no unnecessary words. It fully conveys the core function in a compact form.

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 incomplete given the schema has 9 optional parameters and no required fields. It does not explain how parameters like 'city', 'feed', or 'zone' relate to the stated URL purpose, nor does it specify the output format. This creates ambiguity for an agent deciding to call 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 does not add meaning beyond the schema's own parameter descriptions. Since schema coverage is 100%, the description provides no extra context for parameters like 'city' or 'ref', which are unrelated to the stated URL purpose.

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

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

The description states a specific action and resource: 'Return host, scheme, and HTTP status for a URL.' This is clear and distinguishes it from siblings like normalize-url or fetch-status, though it doesn't name 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?

It implies a use case (obtaining host/scheme/status without full content) but does not explicitly state when to use this over alternatives. The 'Page content is not stored' hint provides some guidance but lacks explicit comparisons.

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 mentions that identifiers are not retained, which is useful, but it does not clarify whether the tool performs network calls, reads files, or has other side effects. Parameter hints like 'no disk access' and 'discarded after' are inconsistent and incomplete.

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

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

The description is short and front-loaded, but the brevity sacrifices necessary clarity. It provides only two vague sentences and does not effectively structure the tool's purpose or behavior.

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, seemingly unrelated parameters and no output schema, the description is far too incomplete. It does not explain what 'compatibility' means, how the parameters are used, what the result looks like, or what the agent should do with the classification.

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 covers all 9 parameters with descriptions, so the baseline is 3. Some descriptions add useful detail (e.g., 'discarded after the length check'), but many parameters seem unrelated to the tool's stated purpose, and their role in the tool's behavior remains unclear.

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

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

The description 'Show how this request is classified' is vague and does not specify what 'compatibility' means, what kind of request is being classified, or what output to expect. It does not sufficiently distinguish this tool from the many sibling 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?

There is no guidance on when to use this tool versus alternatives. It does not mention related tools, conditions that favor this tool, or any decision criteria, leaving the agent without direction.

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

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

With no annotations, the description carries the full burden of explaining behavior. It mentions splitting a hostname and that WHOIS/ownership data is not involved, but does not clarify side effects, output format, or error behavior; several parameter descriptions mention 'discarded' but the overall behavior remains opaque.

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

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

The description is a single concise sentence with no fluff or repetition. It is efficiently structured, though it could benefit from additional key details without becoming verbose.

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

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

The tool has a complex schema with nine optional parameters and no output schema, yet the description provides minimal context. It does not explain expected input selection, return value, or examples, leaving the agent under-informed 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 schema descriptions cover all parameters, but many are unrelated to the stated purpose of splitting a hostname. The tool description adds no clarification about which parameters are relevant, and the contradictory breadth (URL, city, JSON, timezone, etc.) makes parameter semantics confusing.

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

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

The description states a clear operation, 'Split a hostname into labels', which identifies the core action and resource. However, it does not clearly distinguish this from sibling tools, and the broad optional schema with unrelated parameters weakens the clarity.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention use cases, exclusions, or relationships to sibling tools like normalize-url or browser-url-ok.

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

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

With no annotations, the description carries the full burden, but it only says a HEAD request is made and status is returned. It does not disclose network side effects, redirects, timeouts, error behavior, or whether all supplied parameters are ignored; the schema's many 'discarded' fields make behavior even less 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 itself is one concise sentence and is front-loaded with the main verb. However, the overall tool definition is not concise because the input schema contains many unrelated optional parameters, which obscures the intended single-purpose behavior.

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 lacks an output schema and does not explain response format, error cases, or why nine unrelated parameters are accepted. An agent cannot confidently know which parameters to supply or what to expect beyond a vague 'status only'.

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

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

Although every parameter has a description, most are irrelevant or misleading for a URL HEAD status tool. The only relevant parameter, 'url', is described as 'HTTPS URL to normalize or cite' rather than as the URL whose status is being checked, and the remaining eight parameters appear to describe unrelated tools.

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

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

The description states a clear action ('HEAD'), target ('public URL'), and result ('return status only'), which is specific enough to differentiate from many siblings. However, it does not explicitly name alternative tools such as web-fetch or browser-url-ok.

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

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

No guidance is given about when to choose this tool over related tools (e.g., web-fetch, browser-url-ok, inspect-robots) or what distinguishes a HEAD status check from those alternatives. The phrase 'status only' implies a lightweight check, but that is left to inference.

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

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

With no annotations, the description must carry the full behavioral burden. It only states 'Path discarded,' which hints at one behavior, but it does not describe the return value, side effects, or how the other parameters are handled. The description is not misleading but is severely incomplete.

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

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

The description is very short, which is good for conciseness, but it is under-specified for a tool with nine parameters and no output schema. Important information is missing, so the brevity is not effective.

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

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

Given the tool's complexity (9 parameters, no output schema, no annotations), the description is wholly inadequate. It only covers one aspect (Figma URL) while the schema spans many unrelated fields, and it does not explain the overall purpose or expected results.

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 extra meaning beyond what the schema already provides for each parameter; it merely references the Figma URL without elaborating on the parameter details.

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

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

The description names a specific verb and resource ('Parse a Figma file URL'), but it does not distinguish this tool from siblings like normalize-url or browser-url-ok, and it fails to mention the other eight parameters, making the true scope ambiguous.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of when not to use it, no exclusions, and no context about the other parameters or their 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 does disclose 'No disk access,' which is a useful side-effect guarantee, but it says nothing about return values, errors, or whether anything else is mutated. Since no annotations are provided, this partial transparency leaves major behavioral questions unanswered.

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

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

The description is extremely short and free of filler, but it omits necessary context and does not effectively front-load the important constraints. The mismatch between the description and the large parameter list makes the brevity a liability rather than a strength.

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, no required parameters, no examples, and no explanation of how the unrelated fields are used. An agent cannot confidently predict what arguments to provide or what result to 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?

Only the 'path' parameter aligns with the stated purpose; the other eight parameters have descriptions like 'discarded after the shape check' or 'discarded after the length check' without explaining why they exist or how they relate to path safety. The schema coverage is 100%, but the semantic coverage is very poor.

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

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

The description says only 'Check whether a path looks safe. No disk access.' but the input schema exposes nine unrelated optional parameters (ref, url, city, feed, host, json, zone, query), so it is not clear what the tool actually does with them or what 'safe' means. The tool name suggests path validation, but the schema undermines that 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 instead of sibling tools such as browser-url-ok, normalize-url, or validate-json. The description gives no context 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?

The description discloses no behavioral aspects such as read-only nature, side effects, permissions, or potential failures. Since no annotations are provided, the description alone carries no transparency about these traits.

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, clear sentence with no unnecessary words. It is well-structured and immediately understandable.

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 incomplete for practical use: it does not indicate which of the 9 optional parameters contains the place name, nor does it mention output format or any example. This leaves significant ambiguity for an agent trying to invoke the tool correctly.

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

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

The schema description covers 100% of the parameters, so the baseline is 3. The tool description adds no additional meaning about which parameter to use for the place or how the parameters relate to the geocoding function.

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 latitude and longitude for a place via Open-Meteo, which gives a specific verb and resource. However, it does not specify which parameter should be used for the place, and it does not differentiate from similar sibling tools like weather-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?

The description provides no guidance on when to use this tool versus alternative tools, such as weather-hint or search-query-len. No conditions or scenarios are mentioned.

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

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

No annotations are provided, so the description carries the burden. The description does not disclose side effects or the fact that most schema parameters are 'discarded' and only the URL is relevant. However, it is a simple parse operation, and the schema descriptions already hint at discarding. The description adds no behavioral context beyond the basic function.

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, clear sentence with no waste. It front-loads the purpose and is appropriately sized for the core function.

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

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

The tool has 9 parameters, but the description implies only one (url) is relevant. It does not explain why the schema includes unrelated parameters (city, feed, host, etc.) or that they are discarded. There is no output schema, and the description does not specify the return format for owner and repo. This ambiguity leaves an agent uncertain about expected inputs and outputs, making the description incomplete for a tool with such a broad schema.

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

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

Schema description coverage is 100%, so every parameter is documented in the schema. The description does not add meaning beyond the schema; it merely restates the URL source without detailing the url parameter or clarifying that other parameters are ignored. Baseline 3 is appropriate given full schema coverage.

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

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

The description clearly states the verb 'parse' and the resource 'owner and repo' from a 'GitHub URL', which is specific and distinct from sibling tools like figma-url-shape or jira-key-shape. An agent can immediately identify the tool's role.

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

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

The description implies the tool should be used when a GitHub URL is available and owner/repo are needed, but it does not explicitly state when not to use it or mention alternative tools. No exclusion 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?

No annotations exist, so the description must carry the full burden. It only says 'Titles discarded,' which is cryptic and unexplained. It does not disclose return format, error behavior, or side effects, leaving critical behavioral traits unaddressed.

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 under-specified, not appropriately concise. It omits essential information about the parameters and usage, so brevity does not earn its place; it sacrifices necessary 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 9 parameters, no annotations, no output schema, and no guidance, the description is grossly inadequate. An agent cannot determine what inputs to provide, what the tool returns, or how to use it correctly, making the tool effectively unusable.

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

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

While schema description coverage is 100%, the description adds no meaning beyond the schema. Worse, the parameter descriptions (e.g., 'Git ref name; discarded after the shape check') seem entirely unrelated to counting HN stories, actively confusing rather than clarifying how the tool operates. The 'Titles discarded' hint does not explain which parameters are meaningful.

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

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

The description clearly states the tool counts current Hacker News front-page stories, a specific verb-resource pair. However, it does not differentiate from sibling tools, and the nine-parameter schema with unrelated fields (city, timezone, path, etc.) contradicts the apparent narrow scope, creating ambiguity about what the tool actually does.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as web-fetch or fetch-status. It neither states context nor exclusions, leaving the agent to guess why 9 optional parameters are relevant to counting HN stories.

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

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

No annotations are provided, and the description does not disclose any behavioral aspects such as read-only status, side effects, output behavior, or how inputs are handled. The user is left completely uninformed about what happens when the tool is invoked.

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 brief and contains no fluff, which is good for conciseness. However, it is so skeletal that it fails to provide even a basic verb or operational context, making it less than 'appropriately sized' for a useful tool description.

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

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

Given the tool's odd schema with many seemingly unrelated parameters and no output schema, the description is far from complete. It does not explain what the tool returns, why the various parameters exist, how they relate to IANA timezone names, or any important context needed to use it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. However, the tool description itself adds no meaning to the nine parameters, and the schema's own parameter descriptions are mostly generic or confusing (e.g., 'discarded after the shape check'), leaving the actual role of each parameter unclear.

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

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

The description is a noun phrase rather than a clear action statement, so it does not explicitly state what the tool does (e.g., returns, validates, or lists IANA timezone names). It offers only a vague hint that the names are 'for clock calls' and does not clearly distinguish the tool from related 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?

There is no guidance about when to use this tool versus alternatives such as timezone, utc-time, or other sibling tools. The description does not mention any conditions, prerequisites, or scenarios where iana-zones would be the appropriate choice.

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 indicates the operation is a read-only fetch of a public resource and limits the return to group counts, but it does not disclose potential network side effects, error behavior, or rate-limit expectations. With no annotations, some behavioral context is still missing.

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

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

The description is a single, focused sentence with no filler or 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 no output schema and a generic nine-parameter input schema, the description does not fully explain what 'group counts' means, which parameter to supply, or how failures are handled, leaving 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?

Although the schema covers every parameter, the parameter descriptions do not align with the tool's purpose: 'url' is described as 'HTTPS URL to normalize or cite' rather than as a robots.txt URL, and many other parameters are unrelated or marked as discarded. The description does not map the intended target to a 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 a specific action ('Fetch'), a specific resource ('public robots.txt'), and a specific output ('group counts only'). It does not explicitly differentiate from sibling fetching tools, but the robots.txt scope makes the intent 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 provided about when to choose this tool over sibling tools such as web-fetch or fetch-status, nor about prerequisites or intended input selection.

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

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

No annotations are present, so the description carries the full burden. It only states that the key is discarded, but it does not disclose what the tool returns for valid/invalid shapes, whether any side effects occur, or how errors are surfaced.

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 front-loaded sentence with no filler. However, it is so terse that it omits essential input and output information, making the conciseness more under-specified than effective.

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

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

With nine parameters and no output schema, the description and parameter descriptions do not explain what shape is expected, which parameter carries the key, what the return value looks like, or what happens on failure. An agent cannot confidently invoke this tool from the provided 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 schema has nine unrelated optional string parameters with generic descriptions such as 'Git ref name', 'HTTPS URL to normalize or cite', and 'City name for a public weather hint'. None of them clearly represents the Jira issue key that the description refers to, so the descriptions do not help an agent choose the correct input.

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

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

The description names a specific action and object: checking the shape of a Jira issue key, and the 'Key discarded' note clarifies it is validation-only. This is distinct from nearby sibling tools like normalize-url or validate-json, so an agent can identify the tool's purpose.

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

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

No guidance is given about when to use this tool versus alternatives such as github-repo-shape, domain-shape, or wiki-title-ok. There is no mention of prerequisites, expected input source, or when not to use it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description reveals nothing about side effects, return values, or what happens with the inputs (though the schema says many are 'discarded' after checks, the tool's core behavior remains undisclosed). It does not even confirm whether this is a read-only operation.

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

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

The description is extremely short, but this is under-specification rather than conciseness. It does not earn its place; it provides no actionable information. The single sentence could be removed without losing any 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?

For a tool with 9 parameters, no output schema, and no annotations, the description is grossly incomplete. An agent cannot determine what inputs to provide, what the tool returns, or how it relates to sibling tools. This is a failure of contextual completeness.

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 individual parameter descriptions exist in the schema. However, the tool description adds no meaning to the parameters; it does not explain why these nine disparate inputs are relevant to a 'language tag' tool. The agent cannot infer the tool's behavior from the description, so the parameter semantics remain opaque despite 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 'ISO 639 language tag fo.' is a noun phrase, not a verb phrase. It does not state what the tool does (e.g., validates, returns, checks). The name 'lang-fo' is only restated, and the nine parameters (ref, url, city, etc.) are completely unexplained, making the purpose ambiguous and potentially misleading.

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 29 siblings. No context, no exclusions, no mention of alternatives. An agent has no basis to select this tool over similar validation tools like 'domain-shape', 'fetch-status', or 'validate-json'.

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

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

The description mentions that the body is discarded, which is some behavioral transparency, but it does not disclose network behavior, potential side effects, failure modes, or whether the tool actually makes an HTTP request. With no annotations provided, this leaves significant 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?

The description is short and to the point, with no unnecessary filler. It would benefit from a bit more detail, but the current structure 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?

There is no output schema, no annotations, and the description only gives a minimal purpose. Missing context includes return format, error behavior, parameter usage, and relationship to sibling tools, making this inadequate for an agent to use confidently.

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

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

The schema descriptions cover all 9 parameters but are generic and mostly unrelated to the stated purpose, such as 'City name for a public weather hint' and 'IANA timezone name'. The tool description does not clarify which parameter is the actual URL or how the others relate to 'HTTP status for a public library docs URL'.

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 it returns HTTP status for a public library docs URL and discards the body, which gives a basic idea of the action and target. However, it does not explicitly state the operation verb (e.g., 'get', 'check') and could be confused with sibling tools like fetch-status or browser-url-ok.

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

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

There is no guidance on when to use this tool versus alternatives such as fetch-status, normalize-url, or status-catalog. The description does not mention any conditions, exclusions, or comparative use cases.

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

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

With no annotations, the description discloses only that values are discarded; it does not mention side effects, errors, return format, or the fact that most parameters appear to be 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 very short and free of fluff, stating the operation in two direct sentences.

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, no required input, no example, and no explanation of how to supply the JSON object or interpret the count, so the definition 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 parameter descriptions are generic and mostly unrelated to the stated purpose; no parameter is clearly defined as the JSON object whose keys should be counted, and descriptions such as 'discarded after the check' actively confuse invocation.

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 action 'Count keys in a JSON object' is clear, but the tool name suggests 'memory' and the parameter list does not identify which input is the JSON object, making the intended purpose ambiguous in 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?

No guidance is given about when to use this tool versus siblings such as validate-json or search-query-len, nor any 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does mention that query and fragment are dropped, which is a useful behavioral trait. However, it does not disclose that several input parameters (ref, city, feed, etc.) are effectively ignored or discarded, nor does it mention failure modes or error handling. The description is minimal and leaves significant 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?

The description is a single concise sentence with no wasted words. It front-loads the core purpose and includes the key behavioral note about dropping query and fragment. This is an ideal length for a simple tool.

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

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

Given the tool has 9 parameters (many seemingly unrelated to URL normalization) and no output schema, the description is inadequate. It does not explain which parameters are relevant, what the return format looks like beyond the three components, or any error conditions. An agent would need to rely heavily on the schema descriptions, which are present but not tied to the tool's main function.

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

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

Schema description coverage is 100%, so each parameter already has a description. The tool description does not add any parameter-specific meaning beyond what the schema provides. While it implies the 'url' parameter is the focus, it never names it or explains how the other parameters relate. This meets the baseline for high schema coverage but does not go beyond it.

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 verb 'Return' and the resource 'origin, host, and path for a URL', which defines the tool's purpose. It is specific and unambiguous. However, it does not differentiate this tool from sibling tools like browser-url-ok or figma-url-shape, so it loses a point for lack of sibling distinction.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any context, prerequisites, or exclusions. An agent has no explicit signal about when normalize-url is the right choice among the many URL-related 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?

The only behavioral disclosure is 'No browser is launched,' which clarifies a non-browser approach. However, it does not mention whether the tool makes network requests, follows redirects, checks responses, or has any side effects or rate limits. With no annotations provided, this sparse disclosure leaves most behavior unknown.

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, consisting of two short sentences that convey the core action and a key limitation. It avoids unnecessary detail and is efficiently structured. However, it lacks examples or structured breakdown that could enhance clarity without bloating.

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

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

The description is highly incomplete given the nine parameters and lack of output schema. It does not explain how the parameters relate to checking a URL (e.g., what 'ref', 'city', 'feed', etc., mean for this action), what constitutes 'can be opened' (e.g., HTTP 200 vs. any response), or what the return value indicates. Critical operational context is missing, making the tool effectively unusable based on the description alone.

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

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

The parameter descriptions are entirely mismatched with the tool's purpose. For example, 'ref' is described as 'Git ref name; discarded after the shape check' and 'city' as 'City name for a public weather hint; discarded after the call.' These are irrelevant placeholders that would mislead an agent. The 'url' parameter description ('HTTPS URL to normalize or cite') is also vague and inconsistent with 'check whether a URL can be opened.'

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

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

The description clearly states the action ('Check whether a URL can be opened') and the resource (URL). It is specific but does not differentiate from similar sibling tools like browser-url-ok or fetch-status, which could also check URL accessibility. The phrase 'No browser is launched' adds a slight differentiator but is more about behavior than purpose.

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

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

The description gives no indication of when to use this tool instead of alternatives. It lacks any comparison to sibling tools or conditions that would guide selection. An agent would have to guess whether to use this for a quick status check versus a full browser call.

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

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

The description discloses that the query is 'discarded after the length check,' which is a useful side-effect note. However, it does not describe the return value, output format, or any potential edge cases, and there are no annotations to fill the 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 concise, using only two short sentences. It is front-loaded with the core purpose and contains no extraneous information.

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

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

Given the tool's nine optional parameters, the description is too sparse. It does not specify the expected return value, clarify that only 'query' is the intended input, or mention how the other parameters relate to the tool. Important operational context is missing.

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

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

The schema has 100% description coverage, so each parameter is individually described. However, the description itself adds no extra meaning beyond the schema, and many parameters appear unrelated to the stated purpose, creating potential confusion about which parameter should be supplied.

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 explicitly states the tool's purpose: 'Count characters in a search query.' The verb 'count' and resource 'search query' are clear and specific. No sibling tool has a similar function, so it is well differentiated.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or relationships to sibling tools, leaving usage context entirely implicit.

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

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

No behavioral details are disclosed. The description neither states that the tool is read-only nor describes any side effects, return format, or edge cases, and no annotations are provided to supplement this.

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 that immediately states the tool's purpose. It is well within acceptable length and has no redundant or verbose 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?

Given the tool has nine optional parameters and no output schema or annotations, the description is severely incomplete. It fails to explain what the catalog contains, how the parameters are used, or what the caller should expect as a result, leaving the agent without enough context 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 nine parameters have descriptions that are entirely unrelated to the stated purpose of cataloging HTTP status codes (e.g., 'City name for a public weather hint'). These descriptions do not clarify how the parameters affect the tool's behavior, making them confusing and semantically inconsistent with the tool's function.

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 identifies the tool as a catalog of common HTTP status codes, which is a specific resource. However, it lacks an explicit verb like 'returns' or 'lists,' and it does not differentiate itself from related sibling tools such as fetch-status or web-fetch.

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

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

The description provides no guidance on when to use this tool versus any alternative. There is no mention of conditions, prerequisites, or comparisons to sibling tools, leaving the agent without direction on selection.

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

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

With no annotations, the description carries the transparency burden, but it only hints at behavior via 'Prompt discarded,' suggesting input may be ignored. It does not disclose side effects, output format, error behavior, or any constraints.

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 at two short sentences, with no redundant wording. It front-loads the primary purpose and uses the second sentence for a behavioral note.

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, the description should clarify what the returned template contains and how the nine optional parameters affect it, but it does not. The phrase 'Prompt discarded' adds ambiguity rather than resolving how inputs are used.

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 itself adds no parameter semantics, but the schema descriptions cover 100% of parameters, so the baseline of 3 applies. The individual parameter descriptions do provide some meaning, even if the top-level description does not.

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 identifies the tool's action ('Return') and object ('a three-step thinking template'), making its primary function evident. However, 'thinking template' is somewhat generic and does not differentiate it from possible similar template-returning tools.

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

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

No guidance is provided about when to use this tool over any alternative, nor any context for when it is appropriate. The description only states what it returns, not when to invoke 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, and the description does not disclose any behavioral aspects such as read-only guarantees, side effects, or potential errors. The tool likely only performs a read, but this is not stated.

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 and free of fluff, using a single sentence to convey the core function. There is no unnecessary detail or repetition.

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 simple read-only tool, the basic purpose is stated, but the description omits any details about output format, error handling, or constraints (e.g., what happens if the timezone name is invalid). Given the small scope, the missing information is minor but still leaves some 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?

The description mentions 'named IANA timezone' which clearly maps to the 'zone' parameter, but the schema includes eight other parameters with descriptions that seem unrelated to timezone lookup (e.g., 'Git ref name', 'HTTPS URL'). The tool description does not clarify that these parameters are irrelevant or that only 'zone' should be used, leaving ambiguity.

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

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

The description clearly states the tool's function: returning the current time for a named IANA timezone. However, it does not differentiate this from sibling tools like 'utc-time' or 'iana-zones' that might also deal with timezones, so it is not fully explicit about its unique purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives. It only states what it does, lacking any contextual instructions such as 'use this for a specific timezone, use iana-zones for a list of zones'.

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 states the output and implies a simple read operation. It does not mention side effects, errors, output format, or network/disk behavior. Some parameter descriptions mention 'discarded' and 'no disk access,' but these are not integrated into a coherent 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 extremely concise and free of fluff, which is appropriate for a simple timestamp tool. However, given the unusually large and irrelevant parameter list, a bit more structural explanation would be warranted.

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 lacks essential context: no return format, no example, no error behavior, and no explanation of how the nine optional parameters relate to the tool. For a trivial tool this might be acceptable, but the mismatched schema makes the overall context 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?

All nine parameters have individual descriptions, but they are unrelated to a UTC timestamp tool and mostly indicate the values will be discarded. The tool description does not explain why these parameters exist or how they affect the result, so the semantic link between the inputs and the tool's purpose is missing.

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' conveys that the tool returns the current UTC time, but it is a noun phrase rather than an explicit action statement. It does not clearly distinguish itself from sibling tools like timezone or iana-zones beyond the UTC emphasis.

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 timezone or iana-zones. The description provides no context for choosing utc-time over other timestamp or timezone 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 states 'The body is discarded,' implying the input is not retained, but it does not disclose whether the operation is read-only, what it returns, or any side effects. With no annotations provided, the description carries the full burden and is inadequate for understanding 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 sentence, concise and front-loaded, stating the purpose immediately and adding a side note about discarding. There is no unnecessary content, though it is so terse it omits critical context. It earns its place but could be more 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 9 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain how the various parameters relate to JSON validation, what the expected input format is, or what the tool returns. The schema helps but does not resolve ambiguity about which parameters are relevant, making it hard for an agent to call 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 does not mention any parameters directly. The input schema has 100% coverage, so each parameter has a description. The tool description adds no additional meaning beyond the schema and could be ambiguous about which parameter corresponds to 'a body.' Baseline 3 applies due to full schema coverage.

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

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

The description clearly states the action: 'Check whether a body is valid JSON.' This identifies the verb and resource, and the tool name reinforces it. However, it does not differentiate from sibling validators like domain-shape or github-repo-shape, and the schema includes many unrelated parameters, creating slight ambiguity about 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?

The description gives no guidance on when to use this tool versus alternatives. There is no mention of conditions, exclusions, or sibling tools. An agent must rely on the name and schema alone, which is insufficient for a tool with many similar validators.

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

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

No annotations are present, so the description must carry the full burden of explaining behavior. It indicates an external data source (Open-Meteo) but does not state whether the operation is read-only, whether a network call is made, how failures are handled, or whether unrelated 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 concise sentence with no redundant wording. However, its brevity comes at the cost of clarifying the large parameter set, so it is not as complete as it could be while remaining concise.

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

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

With nine optional parameters and no output schema, the description leaves major gaps: it does not identify required inputs, output shape, or how the 'hint' behavior relates to temperature. The one-sentence description is insufficient for an agent to call this tool confidently in all 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?

The schema includes descriptions for all parameters, but most are unrelated to weather and only describe generic discard/check behavior. The description adds that city is used for temperature, but it does not clarify which of the other eight parameters are accepted, ignored, or required.

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

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

The description states the tool returns current temperature for a city via Open-Meteo, identifying a clear action and resource. However, it lacks an explicit verb and is contradicted by an input schema with nine unrelated optional parameters, which muddies the tool's 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?

The description implies a use case for getting current temperature, but it gives no guidance about when to choose this tool over sibling tools such as geo-hint, timezone, or web-fetch. No exclusions, conditions, or alternative recommendations 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?

No annotations are provided, so the description carries the transparency burden. It discloses the body is discarded, but omits redirects, error behavior, authentication requirements, and whether content type is returned even on non-200 responses.

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

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

The main description is concise and front-loaded, but the tool definition overall is cluttered by 7 irrelevant parameters, which undermines clarity and makes the structure misleading.

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, the description should explain what the tool returns beyond status and content type, and how errors are surfaced. It does not, and the parameter list adds unrelated options, leaving the tool incomplete for an agent to call correctly.

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

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

Although every parameter has a description, most are unrelated to web-fetch (ref, city, feed, json, path, zone, query) and appear copied from other tools. The url description says 'normalize or cite' rather than fetch, which conflicts with the tool's stated purpose.

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

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

The description clearly states the tool performs an HTTP fetch and returns status and content type, discarding the body. This is a specific verb and resource, though it doesn't differentiate from sibling fetch/status 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?

The description gives no guidance on when to prefer this tool over the many siblings (fetch-status, browser-url-ok, normalize-url, inspect-robots). It only states 'public URL' and body discarded, leaving selection up to inference.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. It only mentions that the title is discarded after the call, but says nothing about side effects, authentication, rate limits, or other behavioral aspects.

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, using two short sentences with no redundant or irrelevant 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?

The description is incomplete for effective use: it does not explain which of the nine parameters corresponds to the title, gives no example, and does not describe the return value or failure behavior. This is a significant gap for a tool with this many parameters and no output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself does not add parameter-level meaning, and the schema parameters appear unrelated to the stated purpose, but the tool description does not actively misrepresent 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 clearly states the tool's purpose: checking whether a Wikipedia title exists. It uses a specific verb and resource, but does not map this purpose to any of the schema's parameters, which slightly reduces clarity.

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

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

The description provides no guidance on when to use this tool versus sibling tools, no context for invocation, and no mention of appropriate versus inappropriate use cases.

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