Spook SEO

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

The description discloses that the tool is 'free, AI-generated, rate-limited,' adding behavioral context beyond the readOnlyHint annotation. The rate-limit warning is particularly useful for agents managing API usage, which is a concrete behavioral trait.

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 that conveys the core function quickly. It includes some redundancy by repeating the title 'Ad Copy Generator:', but it remains concise and front-loads the essential information.

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

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

With no output schema and low parameter coverage, the description should clarify return values and parameter behavior. It does not mention what the generated output looks like or how parameters affect results, making it incomplete for even a simple 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 only 33%, and the tool description does not explain the meaning of 'topic,' 'product,' or 'platform.' With such low schema coverage, the description should compensate by clarifying parameter semantics, but it fails to do so, leaving agents to guess.

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 'Generate ad headlines and descriptions,' providing a specific verb and resource. This clearly distinguishes it from sibling generator tools like headline-generator or meta-description-generator by scoping to advertising copy.

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

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

The description offers no guidance on when to use this tool versus alternatives. It lacks any mention of use cases, exclusions, or references to sibling tools, leaving the agent to infer applicability without support.

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

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

Annotations already declare readOnlyHint=true, and the description adds that it returns a score (0-100) and provides specific fixes. However, it does not disclose how scoring works, whether input length is limited, or what the response structure looks like.

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

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

A single, front-loaded sentence that conveys the action, scale, target engines, and additional output (fixes). Every word serves a purpose; no fluff 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?

The description covers the essential purpose and high-level output (score + fixes) but lacks details on return format or edge cases. Since there is no output schema, more context about the response structure would be needed for full 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 0%, and the description does not elaborate on the 'text' parameter beyond using the word 'content'. It fails to mention input format, length constraints, or language support, leaving the agent to infer from the parameter name alone.

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 ('Score') and names the exact resource ('content'), with a clear 0-100 scale and specific target engines (ChatGPT, Perplexity, AI Overviews). It distinguishes itself from sibling tools like readability-checker by focusing on AI answer engine quotability.

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 clearly implies when to use this tool: when you need to assess and improve content for AI answer engines. It provides a specific context but does not explicitly name alternatives or state 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?

The readOnlyHint annotation already signals a safe read-only operation. The description adds behavioral clarity by specifying the scope (AI crawlers) and listing example crawlers, making it clear what the tool checks. No contradictions.

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

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

A single, direct sentence that is front-loaded with the action and resource. No unnecessary words.

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

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

With one parameter and no output schema, the description adequately conveys the tool's purpose and expected result (whether AI crawlers are allowed or blocked). It is self-contained and understandable without additional context.

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

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

The schema fully documents the single parameter 'robotsTxt' with a clear description. The tool description does not add extra parameter details, but the schema coverage is 100%, so baseline 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 uses a specific verb 'Check' with the resource 'robots.txt' and states the exact purpose: to see which AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Google-Extended, ...) are allowed or blocked. This clearly distinguishes it from sibling tools like robots-txt-tester.

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 usage context: when you need to inspect a robots.txt regarding AI crawler permissions. It does not explicitly contrast with alternatives like robots-txt-tester or robots-txt-generator, but the purpose is clear enough.

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

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

Annotations already include readOnlyHint=true, and the description adds functional context by specifying the covered AI models (ChatGPT/Perplexity/Gemini/Claude) and the 'where it's invisible' aspect. However, it does not disclose return format, number of prompts generated, or any usage caveats. The added context is useful but not rich enough to exceed the baseline.

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, dense sentence that is front-loaded with the core function ('Generate prompts') and immediately specifies the purpose. There is no redundant wording or repetition of the title/schema information, making it an appropriately sized and well-structured 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 simplicity (4 params, no output schema), the description covers the primary purpose and scope. However, it does not clarify the output format (e.g., a list of prompts vs. a report with visibility gaps), which is a notable omission for an agent that cannot infer from an output schema. Yet the description is close to fully contextual for a prompt-generator 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 50%, with category and competitors having descriptions, while brand and audience lack them. The tool description indirectly clarifies 'brand' as the subject of visibility testing, but does not explain 'audience' or add detail beyond the schema. Since coverage is exactly at 50% and the description minimally compensates, a mid-range score 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 clearly specifies a unique action: generating prompts to test brand recommendation across four named AI models and to identify where a brand is invisible. This verb+resource formulation distinguishes it from sibling generators (e.g., ad-copy-generator, blog-outline-generator) which focus on content creation rather than brand visibility testing.

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 use case—checking brand visibility in AI responses—which provides clear context for when to choose this tool. However, it does not explicitly mention exclusions or alternatives, such as comparing with aeo-checker for broader answer-engine optimization. The context is clear enough for selection but lacks formal alternative guidance.

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

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

The annotation readOnlyHint=true already indicates a safe read operation. The description adds useful context such as 'free' and 'no-signup' requirements, which are not in the annotations, and clarifies that it accesses existing rankings rather than making changes. This adds value beyond the structured data.

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 concise sentences that front-load the main purpose and quickly add use-case context. Every sentence earns its place with no redundant jargon, making it highly efficient.

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

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

With a simple one-parameter read-only tool and no output schema, the description fully covers what the tool returns (queries, search volume, traffic) and the free/no-signup nature. It gives enough context for the agent to choose and invoke the tool correctly without missing critical details.

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 covers 100% of the single parameter (domain) with a clear description 'A domain, e.g. example.com'. The tool description adds no additional meaning about the parameter, so the baseline of 3 for high schema coverage 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 clearly states what the tool does: it provides a free, no-signup SEO snapshot for any domain, listing queries ranked on page 1-2 with search volume and estimated traffic. This specific verb+resource (snapshot for domain) distinctly differentiates it from sibling SEO tools like keyword generators or content checkers.

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 says 'Great first look before signing up,' which clearly indicates the primary use case as an initial free assessment. It implies when to use it but does not explicitly name alternatives or exclusion scenarios, so it stops short of a perfect 5.

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 tool is free, AI-generated, and rate-limited, which are behavioral traits not covered by the readOnlyHint annotation. It adds meaningful constraints for the agent, though it does not detail rate limits or input size limits.

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 a parenthetical for extra context. Every word earns its place, and there is no fluff.

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 2-parameter tool with no output schema, the description covers the core action and key constraints, but it does not state what the tool returns or any limitations on input length. The agent would know to send text and an optional tone, but not what to expect in response.

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 contributes some context for the 'text' parameter by indicating it is the source text to be rephrased, but it does not explain the 'tone' parameter beyond the schema's minimal description. With 50% schema coverage, the description only partially compensates.

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 with a specific verb ('Rephrase') and resource ('text'). It distinguishes from siblings like article-summarizer, which condenses rather than rephrases.

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 over alternatives. It does not mention any exclusions or alternative tools (e.g., article-summarizer for summarizing). Usage is only implied by the verb, but no clear context is given.

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 include readOnlyHint=true, and the description adds valuable context beyond that: it mentions the output format (TL;DR, key points, summary) and constraints (free, rate-limited). This helps the agent understand what to expect without contradicting annotations.

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, front-loaded with the tool's name and purpose, and every word adds value. The parenthetical with constraints is efficient and not redundant.

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 single-parameter tool with no output schema, the description adequately covers input (article text) and output (TL;DR, key points, summary). It also notes rate-limiting. It lacks details like output length or usage limits, but given the tool's simplicity, it is reasonably complete.

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

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

The schema has one parameter 'text' with no description (0% coverage). The description compensates somewhat by implying 'text' is the article to condense, but it does not provide specific constraints (e.g., max length, accepted format). Thus it only partially clarifies the parameter's meaning.

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 'Condense' and clearly states the resource (an article) and output structure (TL;DR, key points, summary). This distinguishes it from siblings like article-rewriter or generate_article, which serve different purposes.

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 when to use the tool (when you need a condensed summary of an article) and provides context such as 'free, AI-generated, rate-limited'. However, it does not explicitly name alternatives or exclusions, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint: true, and the description adds important behavioral context: the tool is free, AI-generated (implying non-deterministic results), and rate-limited. This informs the agent about potential limitations and cost implications, going beyond the annotation.

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 efficiently communicates the tool's purpose and key constraints. No redundant words or filler; every phrase adds value, including the parenthetical note on being free, AI-generated, and rate-limited.

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 one-parameter tool with no output schema, the description covers the purpose, output features (keyword ideas with search intent and difficulty), and rate-limiting context. It stops short of detailing the exact return format or rate limit specifics, but is adequate for a simple generator.

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

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

The schema description coverage is 0%, and the description only adds 'for a topic' without elaborating on what constitutes a valid topic (e.g., format, examples, length). While 'topic' is self-explanatory, the description does not fully compensate for the missing schema description, though the single param is simple.

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 generates SEO keyword ideas for a topic, and specifies the additional output features of search intent and difficulty. It distinguishes this tool from sibling generators by focusing specifically on keywords with SEO attributes.

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 usage when keyword ideas are needed for a given topic, but it does not provide explicit guidance on when to use this tool versus alternatives like content-idea-generator or keyword-density-checker. No exclusions or alternative tool references 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?

The readOnlyHint annotation already signals a non-destructive operation. The description adds valuable behavioral context by stating the tool is 'free, AI-generated, rate-limited,' which goes beyond the annotation and informs the agent of cost and rate-limit characteristics. No contradiction with annotations.

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 a useful parenthetical. It is concise and front-loaded with the action. The main waste is starting with 'Blog Outline Generator:', which repeats the title, but the rest is efficient.

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

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

The tool is simple with one parameter and no output schema. The description provides a high-level sense of the output ('structured, SEO-friendly blog post outline') but lacks details on the exact format (e.g., headings, subheadings, word count). Given the simplicity, this is adequate but not complete.

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

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

The schema description coverage is 0%, so the description must compensate for parameter meaning. It fails to explicitly mention the 'topic' parameter or clarify its expected format. The tool's name and description imply topic, but this is not clearly stated, leaving the parameter semantics underspecified.

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: 'Produce a structured, SEO-friendly blog post outline.' The verb 'produce' and specific resource 'blog post outline' leave no ambiguity. It distinguishes itself from sibling tools like blog-keyword-generator and content-idea-generator by focusing on outlines.

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 does not explicitly state when to use this tool versus alternatives. It implies usage for generating blog outlines but lacks explicit when-to-use, when-not-to-use, or alternative guidance. The parenthetical mentions free, AI-generated, and rate-limited, which is contextual but not usage guidance.

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

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

Annotations declare readOnlyHint=true, and the description adds 'AI-generated' and 'rate-limited', disclosing that outputs are non-deterministic and throttled. This goes beyond the annotation, though it doesn't detail rate limit specifics or error handling. The 'free' attribute also provides a cost context.

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

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

The description is compact: one core sentence plus a parenthetical listing constraints. It front-loads the purpose and includes only essential extra info. The slight redundancy of repeating 'Business Name Generator' before the actual description costs a point, but there is no filler.

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

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

For a simple generator with no output schema, the description covers the core purpose and key constraints (free, AI-generated, rate-limited). It does not specify output format or count, but that is not critical for a name generator. The description is reasonably complete given the tool's simplicity and the readOnly annotation.

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 each parameter (style, topic, keywords) having a clear description. The tool description adds no additional parameter semantics beyond the schema, so it meets the baseline of 3 for high schema coverage. No further elaboration on parameter relationships or defaults is provided.

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 'Generate brandable business name ideas', using a specific verb (generate) and resource (business name ideas). This distinguishes it from sibling generators like ad-copy-generator or blog-outline-generator, which target different content types. The purpose is unambiguous despite the redundant title prefix.

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 usage when the user needs business name ideas, but provides no explicit guidance on alternatives or when not to use it. The 'free, AI-generated, rate-limited' note hints at constraints but not usage scenarios. It lacks the explicit alternative-referencing seen in best-practice examples.

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 readOnlyHint annotation indicates a safe read operation, and the description is consistent with that, describing 'generate' as a pure transformation. However, the description does not add any behavioral context beyond what the annotation already provides, such as not fetching the URL or not validating it. With annotations covering the main safety trait, a score of 3 is appropriate.

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, front-loaded with the verb and resource, with no filler words. It is appropriately sized for the tool's simplicity and 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?

Given the tool's low complexity (one parameter, no output schema), the description adequately communicates the core purpose and the nature of the output (a link tag). However, the lack of parameter semantics and any mention of URL format or return specifics leaves a slight gap, but overall it is sufficient for the intended use.

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

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

The schema has 0% description coverage for the only parameter 'url'. The description merely says 'for a URL', which adds little meaning beyond the parameter name. It does not specify whether the URL must be absolute, whether it is a string, or any constraints, so it fails to compensate for the lack of schema 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 specific verb 'generate' and the resource, a rel=canonical link tag, for a given URL. This precisely distinguishes it from sibling tools like hreflang-generator or meta-tag-generator.

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 usage when a canonical tag is needed but does not explicitly explain when to use this tool over alternatives or provide exclusions. For example, it doesn't mention that hreflang-generator should be used for alternate language tags. The usage context is implied but not explicitly 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?

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description does not add behavioral context beyond listing the counted metrics, which is already implied by the title. No mention of output format, limitations, or edge cases.

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 that front-loads the action and lists all counted entities. No empty words 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?

For a simple one-parameter tool, the description is adequate but incomplete. It does not describe the return format or how sentences/paragraphs are detected. Without an output schema, the agent may need additional information about the response structure.

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 a single required 'text' parameter with no description (0% schema coverage). The description only mentions 'in text,' adding minimal meaning beyond the parameter name. It lacks constraints like max length or accepted input formats.

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's function with a specific verb ('Count') and resource (characters, words, sentences, paragraphs). It is clear and includes details that partially distinguish it from siblings like word-counter, but it does not explicitly note the 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?

No guidance is provided on when to use this tool versus alternatives such as word-counter or readability-checker. The description is purely functional and lacks contextual use cases 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 declare readOnlyHint=true, and the description adds useful behavioral context: the tool is free, AI-generated, and rate-limited. This goes beyond the annotation by disclosing potential variability in outputs and possible usage limits, which helps an agent set expectations. No contradiction with annotations.

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, front-loaded with the core action. The phrase 'Content Brief Generator:' repeats the tool title, which is slightly redundant, but overall the text is compact and avoids unnecessary detail. The parenthetical about free/rate-limited is brief and 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?

The tool is simple (2 params, no nested objects), and the description explains its purpose. However, without an output schema, the description does not specify what the generated content brief looks like or how it is returned, which might leave an agent uncertain about the response structure. The read-only annotation and low complexity reduce the need for extensive detail, so a score of 3 reflects the minor gap.

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

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

The schema description coverage is only 50% (only 'audience' is described). The tool description mentions 'target keyword' but adds no detail about the 'keyword' parameter's format or requirements beyond the parameter name. The 'audience' parameter is entirely absent from the description, so the description does little to compensate for the schema's missing 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 uses the specific verb 'Create' and clearly identifies the resource ('a detailed SEO content brief') and the input ('for a target keyword'). It distinguishes this tool from siblings like 'blog-outline-generator' or 'ad-copy-generator' by focusing on an SEO content brief, making the purpose unambiguous.

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

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

The description implies the tool should be used when generating an SEO content brief for a keyword, which provides clear context. However, it does not explicitly mention when not to use it or reference alternative tools like 'blog-outline-generator'. The 'free' and 'rate-limited' notes add some practical context but not direct exclusions.

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

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

The description adds 'free, AI-generated, rate-limited' beyond the readOnlyHint annotation, giving valuable operational context. It also indicates the output is predictive ('expected to cover'). However, it does not reveal any edge-case behavior or error handling, but the annotation already covers mutability.

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 followed by a concise parenthetical of key qualifiers. It is front-loaded with the tool's purpose and contains no redundant phrases or filler.

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

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

Given no output schema, the description does not specify the return format (e.g., list of strings) or how language affects results. It covers the basic function but is missing important contextual details for a tool with zero schema coverage 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?

With schema description coverage at 0%, the description must compensate for parameter meanings. It only hints at 'keyword' via the phrase 'targeting a keyword' and entirely omits the 'language' parameter's role or valid values. This leaves a gap for agents needing to set both parameters correctly.

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

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

The description clearly states the tool lists terms and entities for an article targeting a keyword. The verb 'List' and resource 'terms and entities' make the purpose explicit, distinguishing it from content generators or other SEO 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 implies use for content planning by referencing 'an article targeting a keyword,' but it does not explicitly state when to use this tool versus alternatives like blog-outline-generator or content-brief-generator. No exclusions or alternative tool mentions 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?

The readOnlyHint annotation already indicates a safe read operation, and the description adds meaningful context: 'free, AI-generated, rate-limited'. This discloses cost, generation method, and rate limits, which are useful behavioral traits not captured by annotations. No contradiction with readOnlyHint.

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 a parenthetical that packs useful info (free, AI-generated, rate-limited). It is front-loaded with the core purpose and contains no filler, every part 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 one required parameter and no output schema, so the description should explain what the returned content ideas look like. It mentions 'formats and angles' but does not specify the number of ideas, their structure, or any formatting details. The absence of output schema strengthens the need for a description of return values, which is only partially fulfilled.

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 0%, so the description must compensate. It only says 'for a niche', which weakly maps to the required 'topic' parameter, but it does not explain expected format, examples, or constraints. The meaning added is minimal, leaving the agent to infer how to fill the 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 phrase 'Generate content ideas with formats and angles for a niche' clearly specifies the action (generate), the resource (content ideas), and the scope (formats, angles, niche). This distinguishes it from sibling tools like blog-outline-generator or content-brief-generator, which focus on different deliverables.

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 minimal guidance on when to use this tool. 'For a niche' implies a use case, but there is no explicit statement about when to choose this over alternatives, nor what not to use it for. It lacks any mention of preferred scenarios 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 declare readOnlyHint=true, covering the safety profile. However, the description adds no further behavioral context, such as output format or rounding behavior, which would be useful for an agent invoking the tool.

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

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

The description is a single, clear sentence with no redundant content. While it is extremely brief, it is appropriately concise for a simple calculator 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?

For a simple calculator with complete schema and readOnly annotation, the description is mostly sufficient. The main gap is the lack of explicit output format (e.g., percentage vs decimal), which would improve agent understanding.

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 clear descriptions for both 'visitors' and 'conversions'. The description does not add any additional meaning beyond the schema, so the baseline 3 is appropriate.

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

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

The description uses a specific verb 'Calculate' and resource 'Conversion rate', clearly identifying the tool's purpose. It distinguishes from sibling calculators like ctr-calculator or cpc-calculator, though it adds little beyond 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?

No guidance is provided on when to use this tool versus sibling calculators, nor any exclusions or prerequisites. The description is purely functional and lacks context.

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

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

The description is consistent with the readOnlyHint annotation; 'Calculate' is a pure read-only computation. However, it does not disclose the formula (cost/clicks), behavior on zero clicks, or return format. Annotations cover the safety aspect, so a baseline score is appropriate.

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 zero wasted words. It is front-loaded and directly states the tool's purpose.

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 is simple, and the schema plus annotation provide decent coverage. However, with no output schema, the description should state the return format (e.g., a number), which it does not. Edge cases like division by zero are also not addressed, but for a simple calculator this is a minor gap.

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

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

The input schema fully describes both parameters ('Total cost' and 'Clicks'), and the description adds no additional meaning. The relationship between parameters is implied by 'Cost per click' but not explicitly stated.

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 'Calculate Cost per click (CPC)' uses a specific verb and resource. It distinguishes from sibling calculators like cpm-calculator and ctr-calculator by naming the exact metric, though it lacks additional scope or context beyond 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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention cpm-calculator, ctr-calculator, or any conditions such as 'use when you have cost and click data'.

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

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

Annotations already declare readOnlyHint=true, which covers the safety profile of this pure calculation tool. The description adds no additional behavioral context beyond what annotations provide, such as side effects or prerequisites, but it does not contradict the annotations either.

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 that gets straight to the point. It contains zero filler and is appropriately sized for a simple calculator tool, making it highly efficient and front-loaded.

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

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

Given the simplicity of the tool, the description is largely complete. However, it does not explicitly state the formula or the return value format, though these are strongly implied by the tool's purpose and the parameter names. Annotations and schema cover the remaining context, making it adequate for a basic calculator.

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 fully describes both parameters ('Total cost' and 'Impressions'), and the description adds no extra meaning beyond what is already in the schema. With schema description coverage at 100%, 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 uses a specific verb 'Calculate' and clearly identifies the resource as 'Cost per 1,000 impressions (CPM).' This distinguishes it from sibling calculator tools like cpc-calculator and ctr-calculator by naming the exact metric, leaving no ambiguity about the tool's function.

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

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

The description implies usage for computing CPM but provides no explicit guidance on when to choose this over other calculators or any exclusions. Since the tool name and description are self-explanatory, the usage context is implied rather than stated.

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

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

Annotations only indicate readOnlyHint=false and destructiveHint=false, which align with the description. The description adds valuable behavioral context: it requires an agent API key and instructs to return the URL to the user. It implies a side effect (adding a paid site) but doesn't fully disclose what happens if the URL is not approved or if there are failures. Still, the auth requirement and the user interaction step are beyond the annotations.

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

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

The description is two sentences, front-loaded with the primary action. The first sentence clearly states what the tool does, the second gives usage guidance and auth requirements. Every sentence adds value; there is no filler or repetition of the tool's name.

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 low complexity (0 parameters, no output schema), the description covers all essential aspects: purpose, usage timing, expected output (URL to return), and prerequisites (agent API key). It adequately prepares the agent to select and invoke the tool correctly, including its relationship to create_site.

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 is empty (0 parameters), so there is no parameter detail to explain. The baseline for 0 params is 4, and the description doesn't need to add param semantics because none exist. It doesn't repeat any schema info, which 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 clearly states the tool's function: 'Get a Stripe Checkout URL to add the first paid site to the account.' It names the specific action (get URL), the resource (Stripe Checkout URL), and the context (first paid site). It also distinguishes itself from the sibling tool create_site by explaining this is needed beforehand, so there's no ambiguity about its 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 explicitly says when to use: 'Needed before create_site if the account has no available slot.' It also explains the expected flow: 'Return the URL to the user to approve payment.' This gives clear context and a prerequisite, effectively guiding the agent on when to invoke it relative 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?

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description discloses key behaviors: language/market auto-detection from the homepage, the requirement for a paid slot, the return of siteId, and the agent API key requirement. These add meaningful context about side effects and conditions.

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

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

The description is concise and front-loaded: two sentences plus a parenthetical. Every sentence adds value—purpose, prerequisite, return value, and authentication. No unnecessary words.

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

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

The description covers the essential purpose, prerequisite, and return value. However, with 7 parameters and minimal schema descriptions, the lack of parameter semantics and the absence of an output schema leave gaps. While the tool is not overly complex, the description is not fully complete for robust invocation of optional parameters.

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

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

Schema description coverage is only 14%, with only 'domain' having a description. The tool description adds no parameter-specific meaning; it does not explain 'name', 'niche', 'brandVoice', 'description', 'publishWebhookUrl', or 'publishIntegration'. With such low schema coverage, the description fails to compensate, leaving the agent without semantic guidance for most parameters.

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

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

The description clearly states the tool's purpose: 'Add a new site to the account.' It also mentions the return value ('Returns the new siteId') and distinguishes itself from sibling tools like create_checkout by specifying a prerequisite. The verb 'Add' and resource 'site' are explicit.

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 explicit usage guidance: 'Requires an available paid site slot (use create_checkout first if none).' This tells when to use this tool and directs the agent to an alternative when a prerequisite is unmet. It also mentions the agent API key requirement, giving clear conditions for invocation.

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 annotations declare readOnlyHint=true, and the description does not contradict this; the verb 'write' refers to content generation, not data mutation. The description usefully adds that the tool is 'free, AI-generated, rate-limited,' which are behavioral traits not covered by the annotation. This is valuable context beyond the structured fields.

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 exceptionally concise, consisting of a single sentence (plus a parenthetical). It front-loads the core purpose and adds only necessary operational notes. No wasted words or redundant repetition of the title beyond the initial phrase, which is acceptable.

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

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

There is no output schema, and the tool has three parameters. The description states the core function but does not describe what the output looks like or how to provide parameters effectively. For a simple text-generation tool, the purpose is clear, but the missing parameter guidance and output expectations leave it minimally viable rather than complete.

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

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

The schema description coverage is only 33% (only 'goal' has a description), and the tool description itself does not explain any parameters. It neither clarifies what 'product', 'goal', or 'topic' mean nor provides examples or syntax. Given the low schema coverage, the description should compensate, but it remains silent on parameter semantics.

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

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

The description uses the verb 'write' with the specific resource 'call-to-action phrases,' clearly distinguishing this tool from sibling generators like ad-copy-generator or headline-generator. The direct statement 'Write effective call-to-action phrases' is unambiguous and action-oriented.

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, nor does it mention any exclusions or prerequisites. The only additional context is pricing and rate limits, which are operational details rather than usage guidance. No sibling tools are referenced for comparison.

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 not contradict the readOnlyHint annotation. However, it adds no behavioral context beyond the annotation—such as return format or handling of zero impressions. Given the annotation covers safety, a neutral score is appropriate.

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 sentence and front-loaded, making it extremely concise. However, it borders on under-specification; still, for a simple calculator, it's appropriately brief.

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

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

The tool is simple with full schema coverage and a read-only annotation. However, no output schema exists, and the description doesn't mention the return format (e.g., decimal or percentage). This leaves a minor gap, so it's not fully complete.

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

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

The input schema already describes both parameters ('Clicks' and 'Impressions') with 100% coverage. The description adds no additional parameter semantics, so the baseline of 3 is applied.

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 the specific verb 'Calculate' and identifies the resource as 'Click-through rate', making the tool's purpose clear. It distinguishes from sibling calculators by naming a distinct metric, though it doesn't explicitly contrast with them.

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

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

The description provides no guidance on when to use this tool versus the many sibling calculators (e.g., CPC, CPM, ROAS). It doesn't state when this metric is appropriate or exclude other cases, leaving usage implied.

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 include readOnlyHint=true, which indicates a non-destructive operation. The description adds behavioral context by stating it is 'free, AI-generated, rate-limited,' disclosing both the nature of output and the existence of rate limits. This goes beyond the annotation's basic safety signal, though it could be enhanced with details about output size or caching 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 concise and efficiently worded, with only one sentence and a brief parenthetical. The opening 'FAQ Generator:' is redundant with the title but does not waste much space. The key information is front-loaded, and every part adds value, though the redundancy could be trimmed.

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 is simple (one parameter, no output schema) and the description adequately conveys its purpose and output nature (a set of Q&As). It includes practical details like free and rate-limited. Without an output schema, the description does not fully detail the response structure, but for this type of generator tool, it is reasonably complete.

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

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

Schema has 0% description coverage, with only a 'topic' string parameter. The description compensates by indicating the topic is the subject of the FAQ generation ('for a topic'). This provides meaning beyond the schema's bare type definition, though it doesn't specify expected format or examples. For a single parameter, this is sufficient.

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: 'Generate a set of frequently asked questions and answers for a topic.' The verb 'Generate' and resource 'frequently asked questions and answers' are specific and distinguish it from sibling tools like ad-copy-generator or blog-keyword-generator. The parenthetical adds further context about being free and AI-generated, reinforcing 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?

No usage guidance is provided. The description does not mention when to use this tool versus alternatives, nor does it give examples of appropriate use cases. It only states what it does, leaving the AI agent to infer when to select it. With many sibling generator tools, explicit guidance is needed.

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?

Discloses non-obvious behaviors beyond annotations: asynchronous execution, background processing, immediate articleId return, idempotency per query, and auth requirements (active subscription, agent API key). Annotations only say not read-only/not destructive, so the description carries the full burden and does so well.

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

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

The description is two sentences plus a parenthetical, front-loading the main purpose then adding essential behavioral notes. Every sentence adds value with no redundancy or filler.

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

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

For a tool with no output schema, the description covers the immediate return (articleId), background processing, polling/callback alternatives, idempotency, and auth. It omits error handling and timeout details, but is otherwise adequate for a tool of this complexity.

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

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

Schema describes query and callbackUrl, but siteId is undocumented. The description's 'for a site' phrase minimally clarifies siteId's role, but does not add meaningful syntax or format details. Schema coverage is 67%, so the description partially compensates but not fully.

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 ('Generate'), the resource type ('SEO article draft'), and the target ('site targeting a search query'). This distinguishes it from sibling tools like article-rewriter or blog-outline-generator.

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 explicit context for async operation ('generation runs in the background - poll get_article/list_articles, or pass callbackUrl') and idempotency. It does not explicitly contrast with alternative generators, but the purpose clarity makes the primary use case obvious.

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?

Beyond the readOnlyHint annotation, the description adds an authentication requirement (agent API key) and specifies the return payload. This is useful operational context. However, it does not address error behavior or edge cases like missing article IDs.

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, information-dense sentence that covers purpose, return fields, use case, and auth requirement. There is no redundant content, and it is well-structured for quick parsing.

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 get-by-id tool, the description covers the essentials: what it does, what it returns, when to use it, and the auth requirement. However, it does not clarify if the tool works only for draft articles or any status, and it omits error handling 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?

The input schema has 0% description coverage for articleId, and the description only says 'Fetch one article by id' without explaining the ID format, length, or where to obtain it. This adds minimal meaning beyond the parameter name itself.

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 fetches a single article by ID and enumerates the specific returned fields (markdown body, meta, FAQs, SEO score, status, published URL). It also provides a use case, distinguishing it from sibling tools like list_articles.

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 a concrete usage context: 'Use to review a draft before publishing.' It implies this is for single-article retrieval but does not explicitly contrast with list_articles or publish_article, lacking when-not guidance or alternative mentions.

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 declare readOnlyHint=true, and the description adds the auth requirement (agent API key). This is useful behavioral context beyond annotations, though it does not detail error conditions 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 description is a single, front-loaded sentence with a brief parenthetical about authentication. Every word earns its place, and there is no 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?

For a simple one-parameter, read-only getter, the description covers the essential selection and invocation needs. It does not detail the output structure, but the tool's simplicity and the readOnly annotation make this adequate.

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 one parameter (siteId, string, required) with zero description coverage. The description says 'by its id', which clarifies that siteId is the site identifier but adds little other semantic detail.

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 gets one site's details and status by ID, using a specific verb and resource. It distinguishes from siblings like list_sites (plural) and get_site_metrics (metrics-focused).

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 clear context for when to use the tool: when you need a single site's details/status given its ID. It does not explicitly list alternatives or exclusions, but the singular and ID-based phrasing implies appropriate usage.

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

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

Annotations already declare readOnlyHint=true, so the read-only nature is covered. The description adds valuable context: 'No cost', 'cached' metrics (indicating not live), and the API key requirement. This goes beyond the annotations without contradicting them.

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 efficient sentence plus a parenthetical note. It front-loads the core purpose, then adds cost, use case, and auth requirement. 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 only 2 params and no output schema, so the description carries the burden of explaining what the agent gets back. It lists the key metrics (clicks/impressions, domain rating, organic traffic, top keywords), gives cost and auth info, and states a specific use case. The only gap is the lack of a more explicit link to the days parameter in the return data, but overall it's reasonably complete.

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

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

Schema coverage is 0% (no descriptions for siteId or days). The description mentions 'daily' trend and 'a site's performance', which loosely maps to the days and siteId parameters, but it doesn't explicitly explain their formats, ranges, or how days affects the trend. The description fails to compensate for the missing schema 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 starts with the verb 'Read' and specifies the resource: a site's performance metrics (Search Console clicks/impressions trend and cached SEO metrics). This clearly distinguishes it from sibling tools that generate content or calculate SEO scores.

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

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

It provides an explicit use case: 'Use to check whether Spook is working' and notes the prerequisite of an agent API key. It doesn't discuss when not to use it or name alternatives, but the context is clear given the sibling set.

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 practical context beyond the readOnlyHint annotation, including that it is free, AI-generated, and rate-limited. It also mentions that it lists corrections, giving insight into the output behavior. While it doesn't detail every aspect of the response format, it provides useful transparency for a read-only tool.

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

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

The description is a single concise sentence with a parenthetical for extra context, making it front-loaded and efficient. However, it begins by repeating the title 'AI Grammar Checker,' which is slightly redundant, though it does not significantly detract from its compactness.

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 one-parameter tool, the description covers the core purpose and notes rate limits, but it omits details about return value structure (e.g., whether corrected text is returned alongside corrections) and any constraints on input size. This leaves some gaps in completeness for an agent needing 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?

With schema description coverage at 0%, the description carries the burden of explaining the 'text' parameter, but it never explicitly references the input parameter or its expected format. The purpose implies text input, but no details about language, length, or content expectations are provided, leaving parameter semantics under-specified.

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 fixes grammar, spelling, and punctuation and lists corrections, which is a specific verb+resource+output combination. It distinguishes itself from sibling tools like readability-checker and keyword-density-checker by focusing on grammar correction, making its purpose unambiguous.

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

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

The description implies use when grammar, spelling, or punctuation correction is needed, but it does not explicitly mention alternatives or when not to use it. It lacks direct comparison to sibling tools, so guidance on usage is only inferred from the stated purpose.

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 declare readOnlyHint=true, and the description adds behavioral context: 'free, AI-generated, rate-limited.' This informs the agent about rate limits and the AI-generated nature, which annotations do not cover. No contradictions.

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 sentence but includes a redundant 'Hashtag Generator:' prefix that repeats the title. The parenthetical adds useful behavioral facts. Overall efficient but could trim the prefix.

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 generator, the description covers purpose, key parameters, and behavioral constraints. It doesn't specify the exact return format, but 'generate relevant hashtags' implies the output is a list of hashtags. Without an output schema, this is acceptable.

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 describes 'platform' as optional with examples, but 'topic' has no description. The description mentions 'for a topic and platform,' reinforcing the parameter roles but adding little beyond the schema. With 50% coverage, description could compensate more but doesn't add constraints or output format.

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 'Generate relevant hashtags for a topic and platform,' specifying the action and resource. It differentiates from sibling generators like business-name-generator and content-idea-generator by focusing solely on hashtags, making selection unambiguous.

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

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

The description provides clear context that this tool is for generating hashtags given a topic and platform, implying social media use. It does not explicitly name alternatives or exclusions, but the sibling list includes many generator tools and this one is uniquely identified by name.

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

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

The description adds behavioral detail beyond the readOnlyHint annotation by explaining the scoring dimensions and the 0-100 scale. This gives the agent a clear picture of what the tool evaluates, though it omits details about return 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?

Single sentence that is front-loaded with the action and contains no filler. Every word is meaningful and directly contributes to understanding the tool's purpose.

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 one-parameter, read-only analyzer, the description covers the purpose, criteria, and score range. It does not explicitly describe the return format, but the (0-100) notation implies a numeric score, which is sufficient for the tool's simplicity.

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 one parameter ('headline') with no description (0% coverage). The description's phrase 'a headline' merely restates the property name and adds no additional semantic meaning, failing to compensate for the lack of schema 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 action ('Score'), the resource ('a headline'), the output scale (0-100), and the specific criteria involved (length, word balance, power/emotional words, numbers, brackets). This distinguishes it from sibling generators like headline-generator or seo-title-generator.

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 usage context is implied: use this tool when you have a headline and want a quantitative score. However, it does not explicitly contrast with alternative tools or state when not to use it, so it falls short of a full 5.

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 declare readOnlyHint=true, which the description does not contradict. The description adds behavioral context beyond annotations by explicitly noting 'free, AI-generated, rate-limited', disclosing rate limits and non-deterministic AI output. It lacks other behavioral details like return format, but the added caveats are valuable.

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 front-loaded, using a single sentence plus a parenthetical. Every word serves a purpose, with no redundant information or fluff.

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 1-parameter tool and no output schema, the description should clarify expected output format or usage scenarios. It mentions rate limiting and AI generation but omits return type, potential multiple outputs, and configuration details, leaving notable gaps for agent decision-making.

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 0%, and the description does not compensate by explaining the 'topic' parameter. While the parameter name is self-explanatory, no guidance is given on input format, examples, or constraints, leaving the agent uncertain about valid values.

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 generates catchy, click-worthy headlines (specific verb + resource). However, it does not differentiate from sibling tools like headline-analyzer or seo-title-generator, which also deal with headlines.

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 versus alternatives, such as headline-analyzer for analysis or youtube-title-generator for niche-specific titles. It only implies usage by stating its core function.

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 the optional x-default behavior and the multilingual page context, but does not disclose the output format (e.g., whether it returns HTML link elements, a string, or an array). The readOnlyHint annotation already covers safety, so the description provides limited additional behavioral context.

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

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

One sentence with no redundant words; the action and optional parameter are stated clearly. It is appropriately sized and front-loaded.

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

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

There is no output schema and no parameter descriptions, and the description doesn't cover return format or input validation. For a tool with a non-trivial array input, this is insufficient 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 description mentions 'optional x-default' but does not explain the structure of the required 'rows' parameter (array of objects with url and lang). With schema_description_coverage at 0%, this is a significant gap.

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

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

The description uses the specific verb 'generate' with the resource 'hreflang link tags' and clarifies the domain (international/multilingual pages). This clearly distinguishes it from sibling generators like canonical-tag-generator or meta-tag-generator.

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 suggests usage context (international/multilingual pages) but does not explicitly state when to choose this tool over alternatives or when not to use it. The use case is implied rather than articulated.

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 readOnlyHint annotation already conveys safe read operations, and the description adds that it outputs the most frequent words/phrases with density. However, it does not disclose return format, stopword handling behavior, or limits, so some context is missing beyond the annotations.

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

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

The description is a single, front-loaded sentence with no filler or redundant details. It efficiently communicates 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?

With no output schema and only one parameter documented, the description leaves meaningful gaps about expected return data and parameter effects. It provides a basic understanding but not enough for robust agent invocation without additional assumptions.

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 only 25% (only the 'n' parameter has a description). The tool description does not explain any of the parameters, including text, limit, or removeStopwords, leaving agents without sufficient guidance on parameter semantics.

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

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

The description clearly states the tool analyzes text to find the most frequent words and phrases and their density, with the purpose of spotting keyword stuffing or thin coverage. This specific verb-resource combination distinguishes it from sibling tools like word-counter or readability-checker.

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 case is implied through the mention of keyword stuffing and thin coverage, but the description does not explicitly state when to use this tool over alternatives or provide any exclusionary guidance. It lacks comparisons 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?

Beyond the readOnlyHint annotation, the description adds that an agent API key is required and reveals the output includes status fields. It does not cover pagination or error handling, but with the annotation already signaling a safe read operation, the added context is 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?

The description is a single concise sentence plus a parenthetical, front-loading the core purpose. Every word earns its place 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?

Given the simple tool with two parameters and no output schema, the description covers the return content (statuses) and the required auth. It lacks explicit pagination/sorting details, but 'recent' conveys ordering, making it adequate for this complexity.

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

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

The input schema has 0% description coverage, and the description only implicitly references siteId ('for a site') and limit ('recent'). It does not explicitly explain parameter formats or default behavior, though it provides partial context that helps infer their 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 it lists recent articles for a site, including their status (draft/review/published) and generation status. It distinguishes from sibling tools like get_article (single article), generate_article (create), publish_article (publish), and list_sites (list sites) by specifying the resource and 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 provides clear context for when to use the tool: to fetch recent articles for a site. It also notes a prerequisite (agent API key). It does not explicitly name alternatives or state when not to use, but the scoped context is adequate for such a simple list operation.

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 behavior. The description adds valuable context beyond that: it requires an agent API key, has no financial cost, and returns scored, ranked queries. These details disclose operational requirements and output characteristics not present in the annotations or 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?

The description is extremely concise: three short clauses that cover the core purpose, cost, a parameter variant, and an auth requirement. Every phrase adds information, with no redundancy or filler. The most important content is front-loaded.

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

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

For a straightforward read-only list tool with three self-explanatory parameters, the description covers the essential aspects: output type, scoring/ranking, cost, auth, and the main parameter variant. It lacks a detailed explanation of limit's default behavior or the exact scoring methodology, but those are not critical for correct tool 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 descriptions are absent (0% coverage), so the description must compensate. It clarifies questionsOnly ('question-shaped queries') and implies siteId via 'for a site'. The limit parameter is left to the schema, but its meaning is standard. Partial compensation for the non-obvious parameter is provided.

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: it lists winnable search queries for a site, scored and ranked. It distinguishes this from sibling list tools like list_articles and list_sites by specifying the unique resource (opportunities). The verb 'list' is implicit in the name, but the description makes the output unambiguous.

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

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

The description provides clear context for when to use the tool: to retrieve winnable search queries for a site, with a note that there is no cost. It also explains the questionsOnly variant. However, it does not explicitly contrast with alternative tools or state when not to use it, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is known. The description adds valuable context beyond annotations: it specifies the account scope and the agent API key requirement, which are not in the annotations. It does not discuss pagination or rate limits, but for a simple read-only list operation, the added context is sufficient.

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 that is front-loaded with the verb 'List' and the resource, then provides the necessary scope, output fields, and auth requirement in a compact form. Every phrase 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?

This is a simple listing tool with no parameters and a read-only annotation. The description adequately covers what it lists, the fields included, the scope, and the auth requirement. Since there is no output schema, listing the output fields directly fulfills the need for return-value transparency.

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 has zero parameters, so the baseline is 4. The description compensates by explaining the implicit scope (the API key's account) and the output fields, which gives meaning beyond the empty input schema. No parameter details are needed.

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 ('List') and the resource ('Spook sites') with a specific scope ('on the account this API key belongs to'). It also enumerates the returned fields (id, domain, autopilot state, publishing setup), distinguishing it from sibling listing tools like list_articles and list_opportunities.

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 clear context for use: it lists all sites for the current API key's account. It mentions a prerequisite ('requires an agent API key'), which is useful. However, it does not explicitly contrast with alternatives like get_site or list_articles, so it stops short of a full 5.

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 readOnlyHint annotation is present and the description does not contradict it. The description adds context about the input parameters, but it does not clarify whether the file is returned as a string or if there are any side effects, which could be useful given the mutable-sounding verb 'Generate'.

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 that front-loads the main action ('Generate an llms.txt file') and lists the key inputs. Every word serves a purpose, with no padding.

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

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

Despite having 4 parameters and a nested structure (sections containing links with url/title/notes), the description gives only a high-level overview. There is no output schema, so the description should state what the tool returns (e.g., the generated file content). The lack of return value explanation and nested structure details makes this 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 0%, so the description carries the burden. It identifies siteName, summary, details, and sections, but does not clarify optionality (only siteName is required per schema) or the structure of sections/links. The phrase 'sections of links' is vague and does not convey the nested schema.

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

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

The description clearly states the verb 'Generate' and the resource 'llms.txt file', with a list of inputs. This distinguishes it from sibling tools like robots-txt-generator and sitemap-generator.

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 is used to create llms.txt files, but it does not explicitly state when to use it over alternatives or mention any exclusions. For a generator with many siblings, more explicit guidance would be 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?

Annotations declare readOnlyHint=true, and the description adds 'rate-limited' which is a useful operational constraint beyond the annotation. However, it does not disclose output format, expected number of descriptions, or behavior when rate limits are hit. The added value is minimal but non-zero, so a 3 is appropriate.

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

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

The description is concise and front-loaded, with a single sentence plus a parenthetical. However, it begins with 'Meta Description Generator:' which repeats the tool title, wasting words. Otherwise, it is tightly written with no filler.

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

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

The tool has only 3 parameters and no output schema, but the description does not provide the necessary parameter guidance or return format. Given the low schema coverage, the description should carry more of the explanatory burden. It explains what the tool does but not how to use it or what to expect, making it 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 low (33% - only 'tone' has a description). The tool description does not compensate by explaining 'keyword' or 'topic' semantics. It only vaguely implies the keyword is the main input through the purpose. This is insufficient given the low coverage, hence a score of 2.

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

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

The description states a clear verb ('Write'), a specific resource ('SEO meta descriptions'), and a purpose ('maximize click-through rate'). This distinguishes it from sibling tools like seo-title-generator and ad-copy-generator by focusing on meta descriptions specifically.

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 it (for generating meta descriptions), but there is no explicit guidance on alternatives or exclusions. The parenthetical 'free, AI-generated, rate-limited' gives context but does not compare to siblings. It meets the 'implied usage' level, not clear contextual guidance.

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

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

The description adds a small behavioral detail by stating it also builds an X-Robots-Tag header. However, given readOnlyHint is present, the safety profile is already known. The description does not disclose how defaults are handled, validation, or output format, so it provides only modest transparency.

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

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

The description is a single, front-loaded sentence that states the core function and scope. Every word earns its place, with no redundant or filler 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?

With 8 parameters, no output schema, and minimal annotations, the description does not fully convey the tool's behavior. It omits what the generated tag looks like, how parameters interact, or any constraints on values. This is incomplete for a non-trivial generator 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 0%, so the description must compensate. It only loosely references 'index/follow and snippet directives' without explaining each parameter's meaning, value formats (e.g., maxSnippet), or enum options. The description adds minimal value over 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 uses a specific verb ('Build') and clearly identifies the resource ('meta robots tag (and X-Robots-Tag header)'). It also mentions the input scope ('index/follow and snippet directives'), which differentiates it from sibling tools like robots-txt-generator and meta-tag-generator.

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 usage for generating a meta robots tag but provides no explicit guidance on when to use this tool versus alternatives. It does not mention any exclusions or alternative tools, leaving context-dependent decision making to the agent.

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 annotations already declare readOnlyHint=true, so the description doesn't need to restate the safety profile. The description adds value by specifying the output scope (which tag groups are included), but it does not disclose other behavioral traits such as whether the output is raw HTML, how defaults are handled, or any side effects. No contradiction exists between 'Generate' and readOnlyHint.

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 the purpose and lists the included tag types without any filler. Every word earns its place, making it highly efficient and easy to scan.

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 moderate complexity and lack of an output schema, the description conveys that the output is a set of HTML meta tags and identifies what those tags cover. It does not mention parameter defaults or behavior when optional parameters are omitted, but for a generation tool with zero required parameters, this is a minor gap and sibling tools provide contextual alternatives.

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 43%, and the description adds some semantic mapping by linking canonical→url, Open Graph→image/ogType/siteName, and Twitter→twitter handle. However, individual parameters like ogType and siteName are not explicitly explained, and the description does not fully compensate for the low schema coverage. The tag-category context helps but is not parameter-specific.

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 ('Generate') and a specific resource ('complete set of HTML meta tags'), then enumerates the exact tag types included: title, description, canonical, Open Graph, and Twitter Cards. This clearly differentiates it from sibling tools like meta-description-generator or canonical-tag-generator, which focus on a single tag type.

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 'complete set' provides clear context that this tool is for generating all major meta tags at once, implying it is the right choice when a full set is needed. It does not explicitly name alternatives or state when not to use it, but the sibling tool list makes those alternatives discoverable, so the context is clear without 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 provide only readOnlyHint=true. The description adds behavioral context by stating it's 'free, AI-generated, rate-limited,' which informs the agent about pricing, generation nature, and rate limits. This aligns with the annotation and adds value beyond it.

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 efficient—one core sentence plus a parenthetical. It front-loads the main action. Slight redundancy exists in the 'Paragraph Generator:' prefix which repeats the title, but the rest is 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?

For a simple tool with two parameters and no output schema, the description adequately covers what the tool does, the input type, and a key constraint (rate limit). It doesn't describe the exact response format, but given the simplicity and readOnlyHint, this is sufficient.

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 only 50% (tone has a description, topic does not). The description clarifies the primary parameter 'topic' by explaining it can be a topic or sentence to expand, but it does not elaborate on the optional 'tone' parameter or its accepted values. It adds some meaning but doesn't fully compensate for the coverage gap.

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

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

The description uses a specific verb 'Expand' and specifies the resource 'a topic or sentence into a well-written paragraph,' clearly distinguishing it from sibling generators (e.g., ad-copy, headline, blog-outline). It states the exact output type.

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 clearly implies usage context: when you have a topic or sentence and need a well-written paragraph. However, it does not explicitly name alternative tools or exclusions, so it lacks the explicit differentiation seen in higher-scoring examples.

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 annotation readOnlyHint=true already indicates a safe read operation. The description adds valuable behavioral context by mentioning 'free, AI-generated, rate-limited', which warns about rate limits and the nature of output. This goes beyond the annotation without contradicting it.

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 concise sentence, front-loaded with the core action. However, it redundantly restates the tool title at the beginning, which is slightly wasteful but acceptable.

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 two-parameter tool with no output schema, the description covers the core purpose and adds caveats about cost and rate limits. Still, it omits any guidance on expected output length or tone, which would be helpful for a generator 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?

With 50% schema description coverage, the description should compensate for missing parameter details, but it does not mention any parameters. The 'features' parameter is documented in the schema, but 'product' lacks description and the tool description adds no clarification. This is below the baseline for tools with partial 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 uses a specific verb ('Write') and resource ('product descriptions'), making the tool's purpose immediately understandable. It also distinguishes itself from sibling generators like ad-copy-generator or meta-description-generator by focusing on product descriptions.

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 usage through its naming and purpose but does not explicitly state when to use this tool versus alternatives. No exclusions or alternative recommendations are provided, leaving the agent to infer based on the tool name.

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

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

Annotations already indicate a write operation (readOnlyHint=false) and non-destructiveness. The description adds meaningful behavior: SEO-score enforcement, refusal with 'published:false', and the API key requirement. No contradiction with annotations.

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

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

Two sentences, no filler. The primary action is front-loaded, followed by key constraints. Every word earns its place.

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

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

For a single-parameter tool with no output schema, the description covers purpose, auth requirement, and failure mode. It lacks explicit success response details but the refusal explanation partially compensates.

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 a single required articleId with no description. The description only implies the article is generated, but does not clarify where to obtain articleId or its format. Given 0% schema coverage, this is a clear gap.

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

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

The description clearly states 'Publish a generated article to the site's connected CMS', providing a specific verb, resource, and context. It distinguishes itself from siblings like generate_article or update_publishing by focusing on the publishing action.

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 specifies the target (generated articles) and a prerequisite (agent API key), and the SEO-score floor implies when the tool should not be used. However, it does not explicitly name alternative tools or state when to prefer another 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?

Annotations already declare readOnlyHint=true, so no warning about side effects is needed. The description adds that the tool computes readability metrics, which is useful, but it does not disclose input limits, output format, or interpretation of 'reading level'. It meets the minimum but lacks richer behavioral context.

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

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

The description is one concise sentence that front-loads the action and clearly lists the outputs. No wasted words, high scanability.

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 is simple with one parameter and no output schema, so the description must cover return values. It names the expected outputs (Flesch scores, reading level) but does not specify their format or the scale of the reading level. Adequate but leaves some 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 0%, so the description must compensate. It mentions 'text' implicitly but adds no details about length limits, language expectations, or formatting. The single parameter is simple, but the description does little beyond restating the schema field.

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

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

The description clearly states the tool's function: scoring text readability using Flesch Reading Ease and Flesch-Kincaid Grade, plus a reading level. This specific verb-resource pair and metric list distinguishes it from sibling tools like grammar-checker or word-counter.

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, no mention of exclusions or prerequisites. It only states what the tool does, leaving usage context entirely to the agent.

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 no behavioral context beyond the readOnlyHint annotation. It does not mention the formula (revenue/adSpend), edge cases like zero ad spend, or the output format despite the ambiguous 'percentage' hint. With readOnlyHint already provided, the description contributes nothing extra.

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

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

The description is short but not concise: it repeats 'ROAS' unnecessarily and includes a confusing parenthetical. Every word does not earn its place, and the structure is less effective than a simple 'Calculate ROAS as revenue divided by ad spend.'

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 calculator, the schema plus readOnlyHint cover most needs. However, the lack of an output schema means the description should clarify the return format; the vague 'percentage' hint is incomplete. The description is minimal but not fully inadequate, so a 3 is appropriate.

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 descriptive parameter names and descriptions ('Revenue from ads', 'Ad spend'). The description adds no additional parameter meaning, but the schema already fully explains both parameters, 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 states the tool calculates ROAS, which is a specific verb and resource, but the phrase 'Calculate ROAS, ROAS (percentage)' is redundant and does not distinguish it from sibling calculators like cpc-calculator or ctr-calculator. The repetition and ambiguous 'ROAS (percentage)' weaken clarity.

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

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

There is no guidance on when to use this calculator versus similar siblings (e.g., cpc-calculator, cpm-calculator). The description gives no context about scenarios where ROAS calculation is appropriate, nor does it exclude 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?

Annotations provide readOnlyHint=true, so the safety profile is covered. The description adds capability details (e.g., blocking specific bots, linking a sitemap) but does not disclose the output format, whether it returns text, or default behavior when no parameters are provided. No contradiction exists.

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

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

The description is a single, tightly structured sentence that front-loads the purpose and uses a colon-separated list to enumerate features. No wasted words; every phrase adds 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?

The description covers core capabilities and is useful for a generator with no required parameters and no output schema. However, it omits the crawlDelay parameter semantics, does not explicitly state that output is a plain-text robots.txt, and does not describe default behavior when no args are given. Adequate but with identifiable 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?

Since schema description coverage is 0%, the description must compensate. It maps most parameters with meaningful phrases: 'allow or block crawlers' maps to mode, 'disallow paths' to disallow, 'block specific bots' to blockedBots, and 'link a sitemap' to sitemap. However, crawlDelay is omitted, leaving one parameter semantically uncovered.

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 ('Build') with a clear resource ('valid robots.txt') and enumerates distinct actions: allow/block crawlers, disallow paths, block bots, and link sitemap. This makes it unambiguous and differentiates it from sibling tools like robots-txt-tester and sitemap-generator.

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 is used when a robots.txt needs to be generated, but it does not explicitly state when to use it over alternatives such as robots-txt-tester or explicitly mention exclusions. The usage context is clear though no alternative 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?

Annotations declare readOnlyHint=true, and the description aligns with this by describing a non-destructive test action. The description does not add extra behavioral context such as edge-case handling, return format, or the need to provide the full robots.txt content as a string, which would be valuable beyond the annotation.

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 that immediately conveys the tool's core purpose. It has no unnecessary filler and is well front-loaded with the action 'Test'.

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 is simple and read-only. The description clearly states what it does, but since there is no output schema, it leaves the return value ambiguous (e.g., a boolean vs. detailed report). However, the phrase 'whether ... allows or blocks' strongly implies a boolean result, making it mostly complete for a straightforward tester.

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 no parameter descriptions (coverage 0%), so the description must clarify the parameters. It explicitly names all three: 'robots.txt' (robotsTxt), 'URL path' (url), and 'user-agent' (userAgent). This gives meaningful semantics, although it does not detail the exact format of the robotsTxt parameter (e.g., whether it is the file content or a 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 clearly states the tool 'tests whether a robots.txt allows or blocks a given URL path for a given user-agent.' This specifies a concrete action (test), the resource (robots.txt), and the relevant inputs (URL path, user-agent). It distinguishes itself from sibling tools like robots-txt-generator by focusing on testing rather than generation.

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 is for checking robots.txt conformance, but provides no explicit when-to-use guidance or comparison with alternatives. Sibling tools such as robots-txt-generator are not mentioned, so the user must infer the intended use case from the name and 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?

Annotations already declare readOnlyHint=true, and the description adds the supported types and the 'valid' guarantee. However, it does not disclose the return format, validation behavior on invalid input, or how the structured data is delivered, leaving some transparency gaps.

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 of about 16 words, front-loading the purpose and supported types. Every word earns its place, with no fluff.

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 five parameters, one required, with nested objects and no output schema, the description is too brief. It omits parameter relationships, expected outputs, and error handling, making it incomplete for practical 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 0%, and the description only restates enum values already present in the schema. It fails to explain the structure of faqs, article, product, or organization parameters, providing no added meaning beyond the input schema.

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

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

The description clearly states the tool builds JSON-LD structured data with specific types (FAQ, Article, Organization, Product), matching the enum. This specific verb and resource scope differentiates it from sibling content generators, making its purpose unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as faq-generator or other markup generators. It merely states the action without context, prerequisites, or exclusions.

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

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

The description adds useful operational details beyond the readOnlyHint annotation, including that it is 'free, AI-generated, and rate-limited.' This provides helpful context about cost and throttling. No contradictions found.

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

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

The description is extremely brief and front-loaded with the core purpose. The parenthetical with 'free, AI-generated, rate-limited' adds value without redundancy. 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?

Given the lack of an output schema and many sibling generators, the description does not explain what the tool returns (e.g., a single title or multiple options) or how to choose among similar tools. It also omits parameter details, leaving significant gaps for an AI agent.

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 'topic' but does not clarify the required 'keyword' parameter or the difference between them. With 0% schema coverage, the description carries the burden of explaining parameters, and it fails to do so adequately.

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 clear verb ('Write') and resource ('SEO-friendly title tags'), making the purpose obvious. However, it does not distinguish this from sibling tools like headline-generator or youtube-title-generator beyond the 'SEO' qualifier, so it misses the top score for 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?

No guidance is given on when to use this tool versus alternatives such as headline-generator or meta-description-generator. It lacks explicit use cases, exclusions, or prerequisites.

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

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

The description adds behavioral context beyond the readOnlyHint annotation by specifying pixel-width truncation for desktop and mobile. This discloses how the tool behaves under different device conditions, which is useful for the agent.

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

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

The description is a single, well-structured sentence that front-loads the main action and includes relevant details without unnecessary words.

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

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

The description covers the core function and inputs but does not specify what the tool returns (e.g., an image, HTML, or text). Since there is no output schema, this missing information could leave the agent uncertain about the output format.

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 75%, and the description reinforces the meaning of title, description, and device parameters. However, it does not add much beyond the schema for the URL parameter, and the device parameter's enum is already in the schema.

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

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

The description clearly states the tool's specific function: previewing how title and meta description render in Google search. It includes a specific verb ('Preview') and resource ('a page's title and meta description') and distinguishes itself from sibling tools that generate titles or descriptions.

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 context clearly implies when to use the tool (when you have a title/description and want to see SERP rendering), and there are no exclusions. However, it does not explicitly compare against alternatives or mention 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?

Annotations offer minimal information (readOnlyHint=false, destructiveHint=false). The description adds meaningful behavioral context by explaining what the autopilot does when enabled and the API key requirement, which helps the agent understand the tool's side effects and prerequisites.

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

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

The description is only two sentences with no fluff. The first sentence states the core action, and the second adds essential context and a requirement. This is an ideal structure 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?

For a simple two-parameter toggle with no output schema, the description covers purpose, behavior, and a prerequisite. It does not discuss return values or potential side effects beyond enabling automation, but these are secondary for this tool's simplicity. The main gap is the absence of alternative tool guidance, but that is a minor issue.

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 0%, but the parameter names are self-explanatory. The phrase 'site's autopilot on or off' maps to siteId and enabled, providing basic semantics. However, no explicit parameter-level detail is added, so it does not fully compensate for the lack of schema descriptions.

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

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

The description states a clear action ('Turn a site's autopilot on or off') and defines what autopilot means ('Spook plans, writes, and publishes articles automatically'). This distinguishes it from sibling tools like generate_article or publish_article, which handle specific content steps rather than a site-wide automation toggle.

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 clear context for when to use it (when toggling site-wide automation) and mentions a prerequisite (requires an agent API key). It does not explicitly name alternatives or exclusions, but the context is unambiguous.

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 readOnlyHint annotation already signals no state mutation, and the description adds 'optional lastmod' which is schema content. It does not disclose return format (e.g., XML string vs. file) or any limits, but the safe/non-destructive behavior is covered by annotations.

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 that is front-loaded with the core purpose and includes the key parameter context. Every word earns its place with no 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?

The tool is simple (2 params, no nested objects) and no output schema exists. The description implies the output (XML), but does not explicitly state whether it returns the sitemap content directly or writes it somewhere. For a low-complexity generator, this is nearly complete.

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

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

Schema coverage is 0%, so the description must compensate. It does convey that 'urls' is a list of URLs and 'lastmod' is an optional date, adding basic meaning beyond the raw schema types. However, it lacks detail on URL format (absolute vs relative) or date format (ISO 8601).

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

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

The description clearly states a specific verb and resource: 'Build an XML sitemap' from a list of URLs. It distinguishes the tool from sibling generators like robots-txt-generator or schema-generator by naming the exact output type (XML sitemap).

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 usage context (when you have a list of URLs and need a sitemap), but it does not explicitly state when not to use it or mention alternatives. It is clear enough for a simple tool, but lacks explicit exclusions or 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?

Annotations already indicate readOnlyHint=true, so the description does not need to restate safety. It adds valuable behavioral details: lowercasing, hyphenation, accent handling, and optional stopword removal, which are not present in the annotations or schema. No contradiction exists.

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

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

A single, well-structured sentence that front-loads the primary action and includes key features. No unnecessary words, making it efficient for an AI agent to parse quickly.

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 transformation tool with no output schema, the description covers input, processing, and options. The return value (a slug string) is implicit. Combined with the read-only annotation, the tool is fully understood in 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?

Schema description coverage is 0%, so the description carries the burden. It mentions 'stopword removal' (mapping to removeStopwords) and 'hyphenated' (implying separator default), but it does not explain the separator parameter or provide examples. It partially compensates but leaves some param semantics implicit.

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: transforming a title into a URL slug. It specifies the output characteristics (lowercase, hyphenated, accent-safe) and optional stopword removal, making it distinct from sibling tools like headline-generator or meta-description-generator.

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 when to use the tool (when a clean, SEO-friendly slug is needed from a title). It provides clear context but does not explicitly mention alternatives or exclusions. The purpose itself is sufficiently self-explanatory for typical 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?

The description adds behavioral context beyond the readOnlyHint annotation, noting that the tool is free, AI-generated, and rate-limited. This is useful operational information. However, it does not detail the output format or any limitations beyond rate limits, but given the annotation covers safety, the extra context merits a 4.

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, efficient sentence plus a parenthetical. It front-loads the purpose and adds concise operational context (free, AI-generated, rate-limited). No unnecessary words 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?

For a simple tool with two parameters and no output schema, the description is minimally adequate. It lacks information on what the generated posts look like, whether multiple options are returned, or any usage examples. The rate-limit and platform-specific notes are helpful, but the description does not fully explain the return value or expected output, leaving a gap in 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 50%, with only 'platform' having a description. The text 'platform-specific' hints at the platform parameter but does not clarify the 'topic' parameter or provide details on how platform values affect output. The description adds minimal value over the schema.

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

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

The description clearly states the tool writes platform-specific social media posts, with a specific verb ('Write') and resource ('social media posts'). It distinguishes itself from sibling tools like ad-copy-generator and content-idea-generator by focusing on social media posts and platform specificity.

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 does not provide explicit guidance on when to use this tool versus alternatives. It mentions 'platform-specific' but does not state when to choose this over other content generators, nor does it offer any exclusions or alternative tool references.

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

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

Beyond the readOnlyHint annotation, the description adds useful behavioral context: 'free, AI-generated, rate-limited'. This disclosure of rate limits and generation method helps the agent set expectations, though it does not detail output format or limitations.

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

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

The description is a single, front-loaded sentence with a parenthetical adding context. It is concise, with no wasted words or redundant information.

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

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

For a simple one-parameter generator, the description covers the core purpose and adds behavioral notes. However, it lacks usage guidance, response format expectations, and parameter elaboration, leaving some gaps for an agent deciding how to invoke it.

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

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

The schema has zero description coverage for the 'topic' parameter, and the tool description does not explain what the topic should contain or how to format it. The parameter name is somewhat self-explanatory, but the description fails to add meaningful guidance for a parameter with no schema 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 'Write high-converting email subject lines' uses a specific verb ('write') and resource ('email subject lines'), clearly distinguishing it from sibling tools like headline-generator or seo-title-generator. The title also reinforces the purpose.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of use cases, exclusions, or related tools, leaving the agent to infer usage solely from the name and purpose.

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 indicate the tool is neither read-only nor destructive. The description adds valuable behavioral context: 'nextjs' is credential-free and returns a blog API key, and the operation requires an agent API key. It explains side effects like returning credentials, which goes beyond the annotations. No contradiction detected.

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

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

The description is extremely concise: two sentences that front-load the purpose and then provide specific, actionable configuration details. There is zero wasted text, and every clause adds meaningful information. This is exemplary conciseness.

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

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

The description covers the two primary integration options (nextjs and webhook) and auth requirements, but it does not mention the other valid publishIntegration values (wordpress, ghost, shopify, rest, none) from the schema. With no output schema, return values are only specified for nextjs. This is adequate for a simple configuration tool but has clear gaps for users considering other integrations.

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 0%, so the description must add meaning. It explains the semantics of publishIntegration ('nextjs' vs 'webhook'), conditional usage of publishWebhookUrl, and the meaning of publishMode. However, it omits details for publishWebhookSecret and the additional integration enum values (wordpress, ghost, etc.), leaving some parameters partially unexplained. Still, the description meaningfully clarifies the most important parameters.

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

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

The description clearly states the tool's function: 'Configure where a site publishes.' This is a specific verb+resource pair that immediately distinguishes it from siblings like publish_article (publishing articles) and create_site (site creation). It also enumerates the main configuration options, making the purpose unambiguous.

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

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

The description provides clear context for when to use the tool: to configure a site's publishing destination. It gives concrete instructions on how to set different integration types (nextjs vs webhook) and publishMode, but does not explicitly mention alternatives or when not to use it. This is clear context without exclusions, warranting a 4.

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 include readOnlyHint:true, which aligns with the description and reduces the need for extra safety disclosure. However, the description adds no additional behavioral context—such as whether existing query parameters are preserved or replaced, or what the output format looks like. It is consistent with annotations but not richly informative.

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 immediately identifies the action and the involved parameters. Every word is necessary; there is no filler, repetition, or unnecessary explanation.

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, the description should explain what the tool returns. It only says 'Append...to a destination URL,' implying an output but never explicitly stating it returns the built URL. It also lacks details on edge cases or validation behavior. For a simple tool, this is a notable omission.

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 0%, so the description must compensate. It lists the five UTM parameters (source, medium, campaign, term, content) plus the destination URL, which provides some meaning beyond raw property names. However, it does not explain what each parameter represents, which are required vs optional, or provide examples. Standard UTM familiarity may help, but the description alone is insufficient for a new agent.

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

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

The description clearly states the tool's function: 'Append UTM tracking parameters...to a destination URL.' This is a specific verb+resource combination and obviously distinguishes it from the many generator/calculator siblings. The list of parameters further clarifies its 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 provides no guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. It merely states what it does. With many sibling tools like ad-copy-generator or meta-tag-generator, there is no explicit positioning or use-case context.

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

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

The readOnlyHint annotation already indicates a safe read operation. The description adds behavioral context by enumerating the specific metrics calculated, which goes beyond the annotation. It does not detail edge cases like whitespace handling or reading speed assumptions, but given the annotation coverage, this is adequate.

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 redundancy. Every word contributes to explaining the tool's functionality.

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 is simple, but without an output schema, the description should clarify what the tool returns. It lists the metrics counted but does not explain the response format or units for reading/speaking time. This is a minor gap for an otherwise clear 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 schema has one required 'text' string parameter with no description (0% coverage). The description refers to 'in text,' which confirms the parameter is the input to analyze, but adds no additional syntax, constraints, or format details. Since the parameter name is self-explanatory, the description provides marginal added 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 uses the verb 'Count' with a clear resource list: words, characters, sentences, paragraphs, and reading/speaking time. This distinguishes it from the similar 'character-counter' sibling by covering more metrics.

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 clearly implies its use case: analyzing text to get quantitative metrics. However, it does not explicitly mention when to use it versus 'character-counter' or other text analysis tools, lacking exclusions or alternatives.

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

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

Annotations already declare readOnlyHint=true, so the description adds value by noting the tool is 'free, AI-generated, rate-limited.' This provides behavioral constraints (rate limits) and output nature (AI-generated) beyond annotations. It does not thoroughly explain output structure, but given annotation coverage, the added context is useful.

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 plus a concise parenthetical. It front-loads the tool's name and then explains the function in one clause. Every word contributes to understanding the tool's purpose and constraints, 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?

For a simple one-parameter tool with no output schema, the description is largely complete. It states the function, the input role, and key behaviors (free, rate-limited). It does not specify the return format, but the description implies the output includes title, description, and tags. This is sufficient for a low-complexity 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 has 0% description coverage for the sole parameter 'topic'. The description partly compensates by stating 'for a video topic,' implying the input is the video topic. However, it does not elaborate on format, examples, or how the topic influences the output. The description provides minimal added meaning beyond the schema field name.

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 clearly states the tool's function: 'Write a YouTube title, description, and tags for a video topic.' It uses a specific verb (Write) and identifies the resource (YouTube title, description, tags) and context (video topic). This distinguishes it from sibling tools like seo-title-generator or meta-description-generator.

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 clear context for when to use: when you have a video topic for YouTube content. It indicates the tool is for YouTube-specific metadata, but does not explicitly mention exclusions or alternatives. The phrase 'for a video topic' implies usage, though it lacks direct references to sibling tools.

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