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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It names the core metrics returned and scopes the data to 'your site,' but it does not mention time range, aggregation, ordering, pagination, or any access requirements beyond what the schema already states.

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 action, the platform, and the key data fields with no filler. Every word is informative and the structure is immediately scannable by an agent.

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 relatively simple, has an output schema, and all parameters are documented, so the description does not need to explain return values. However, it lacks any usage context or behavioral caveats, leaving the agent to infer when and how to invoke it beyond the basic purpose.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add parameter-specific meaning beyond the schema; it only summarizes the tool's output. It comports with the schema but adds no extra semantic value for site_url, limit, or 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 uses a specific verb ('Get'), names the resource ('Bing search query data'), and lists the returned metrics (impressions, clicks, CTR, position). It also inherently distinguishes itself from the sibling 'gsc_search_queries' tool by specifying Bing as the data source.

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

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

No guidance is provided on when to use this tool versus alternatives like gsc_search_queries or gads_keyword_ideas. The description implies it is for Bing query data, but it does not state scenarios, exclusions, or why an agent should choose it over siblings.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It usefully reveals that the tool relies on the free BuiltWith API and requires no API key, which is meaningful operational context. It does not disclose rate limits, failure modes, data freshness, or whether the 'any website' claim has constraints, so transparency is only partial.

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

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

The description is compact and front-loaded: the first sentence states the core purpose, and the second adds essential API/auth context without waste. Every sentence earns its place, and there is no redundant repetition of the tool name or schema details.

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 lookup tool with complete schema descriptions and an output schema present, the description is largely complete. It covers the external API and authentication requirement, while the return format is presumably handled by the output schema. Minor omissions like rate limits or explicit sibling differentiation prevent a perfect score.

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

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

Schema description coverage is 100%, so the schema already documents both parameters clearly: 'domain' and 'format'. The description adds context about what the analysis covers but does not add meaning beyond the schema for either parameter; therefore, 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, informative verb ('Detect') with a clear resource ('technology stack of any website') and enumerates the covered categories (CMS, analytics, ads, frameworks, hosting). It is distinct from the sibling tools in function, though it does not explicitly name a competing tool such as semrush_domain_overview to draw the boundary.

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: whenever you need to identify a website's CMS, analytics, ads, frameworks, or hosting. However, it does not explicitly describe when not to use it or recommend any sibling alternative, so the usage guidance remains implicit rather than fully directive.

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

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

With no annotations, the description carries the burden and does disclose that this is a read operation scoped to organic traffic with specific metrics. However, it does not mention output format, date-range behavior, or data aggregation, so it is only minimally transparent.

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

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

A single, front-loaded sentence with no filler; the action, resource, and key metrics are presented efficiently. It loses one point only because the brevity omits contextual guidance.

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

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

The tool has six parameters with no schema descriptions and no annotations, so the description is too sparse for full invocation guidance. The output schema may cover return values, but it cannot compensate for missing input semantics and usage context.

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

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

Schema description coverage is 0%, and the description provides no explanation of the six input parameters (days, limit, format, metrics, dimensions, property_id). Naming the returned metrics does not compensate for undocumented 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?

Describes a concrete action and resource: 'Get organic traffic metrics ... from GA4,' and lists the primary metrics (sessions, engagement, bounce rate). The GA4 source and organic channel distinguish it from sibling tools like gsc_search_queries, even without naming an alternative.

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

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

No guidance on when to prefer this tool over sibling analytics tools (e.g., gsc_search_queries, bing_search_queries). The description only states what the tool does and never mentions 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?

With no annotations provided, the description carries the behavioral disclosure burden. It conveys a read-only retrieval operation and the kind of data returned, but does not mention authentication requirements, account prerequisites, rate limits, or what happens when no ideas are found. This is acceptable but not rich.

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, compact sentence conveys the core action, resource, source, and result contents with no fluff. It is front-loaded and every word earns its place.

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

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

The output schema existence reduces the need to document return shapes, but the tool still has five input parameters with no semantic coverage, no usage guidance, and no annotation context. An agent cannot fully understand language_id, location_id, or output format behavior from this definition, leaving it incomplete for non-default calls.

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 adds no explanation for seed_keywords, limit, format, language_id, or location_id. Only their names and defaults appear in the schema, so an agent cannot reliably construct non-default requests with the right ID formats or expected 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 uses a specific verb 'Get' with a concrete resource ('keyword ideas') and names the source ('Google Ads') as well as the returned metrics (search volume, competition, bid estimates). This clearly distinguishes it from sibling keyword tools like semrush_keyword_overview or gsc_search_queries.

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 choose this tool over alternatives such as semrush_keyword_overview or google_trends_explorer. It merely states what the tool does, without exclusions, prerequisites, or routing hints.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. 'Get' implies a read-only operation, but the description does not disclose authentication needs, whether reviews are full text or summaries, how performance metrics are aggregated, or any rate-limit/account requirements.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the core purpose efficiently and is appropriately sized for a tool whose details are partially captured by the schema and output schema.

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

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

Although an output schema exists, the tool has four undocumented parameters, no annotations, and no guidance about the account/location hierarchy or defaults. The description is too thin to fully support correct invocation in varied contexts.

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 weakly maps to the location_id parameter via 'for a location'. It provides no explanation of days, format, or account_id, so an agent cannot determine how to correctly supply the parameters for a specific account/location.

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 ('Get') and the resource ('Google Business Profile reviews and performance metrics') with a location scope, which is specific enough to distinguish it from siblings like yelp_business_reviews or ga4_organic_performance. However, 'performance metrics' is somewhat broad, and it does not explicitly differentiate itself from potentially overlapping analytics tools.

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

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

No guidance is provided about when to use this tool versus alternatives such as yelp_business_reviews or gsc_search_queries. The description gives no exclusions, prerequisites, or decision criteria.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It transparently states this creates a new file and that the default is a Google Doc, which is useful. However, it does not explain what happens when folder_id is omitted, whether existing files could be affected, or any permission/authorization requirements.

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

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

The description is only two sentences and every sentence earns its place: first states the core action, then clarifies the default type, then gives the key alternative. No filler or redundant restatement of the tool 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?

The description covers the core creation action and the two main document types, and an output schema exists so return-value details are not needed. However, with four undocumented optional parameters and no explanation of folder placement or content behavior, an agent may still make incomplete or incorrect calls.

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 for all four parameters. It only explains mime_type by giving the default and the spreadsheet value. Title, content, and folder_id are left entirely to inference from their names, with no explanation of how they are used or how they interact with the created file.

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 creates a new file in Google Drive, uses the specific verb 'Create', and identifies the resource. It also distinguishes the default Google Doc behavior and how to switch to Sheets, which differentiates it from sibling tools like gdrive_update_doc, gdrive_list_files, and gdrive_read_file.

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 use: creating a new file, with a default type and an explicit way to request a spreadsheet. It does not explicitly name alternatives or state when not to use this tool, but the create-versus-read/update/list distinction among siblings is largely 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the basic function and optional filters; it says nothing about pagination, default folder behavior, ordering, whether only metadata is returned, or any limits such as max page_size. The existence of an output schema helps, but the description adds minimal behavioral context beyond the obvious.

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 redundancy. It states the core action, the resource, and the key optional filters in minimal space. 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 simple list operation with an output schema, the description is minimally adequate: an agent can infer that this returns a list of files and that folder_id/mime_type are optional filters. However, parameter semantics are thin, there is no usage guidance relative to sibling gdrive_search, and behavioral details like pagination and defaults are missing. It is complete enough for basic invocation but leaves meaningful gaps.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It mentions 'folder or MIME type,' which maps to folder_id and mime_type, but it does not explain the format parameter, the meaning of an empty folder_id, page_size semantics, or expected values. Parameter names are somewhat self-explanatory, but the description leaves important semantics unaddressed.

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

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

The description states a specific verb and resource ('List files in Google Drive'), with optional filtering by folder or MIME type. This clearly distinguishes it from sibling tools like gdrive_read_file, gdrive_create_doc, gdrive_update_doc, and even gdrive_search by presenting a list-oriented operation. No ambiguity remains about what the tool does.

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

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

The phrase 'List files in Google Drive' implies the tool is for directory-style listing, and the optional filters offer some context for narrowing the result set. However, there is no explicit guidance on when to prefer this over gdrive_search, what the 'search' tool is for, or any exclusions/prerequisites. Usage is implied rather than stated.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does reveal an important behavior: the tool exports Google Docs/Sheets/Slides rather than simply returning raw bytes, with plain text as the default. Still, it does not mention behavior for non-Google files, authentication needs, error conditions, or side effects.

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

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

The description is two concise sentences with no filler. It leads with the primary action and then adds the export-specific behavior and default format, earning 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 is simple and has an output schema, so describing return values is unnecessary. However, the description leaves gaps around supported export formats, required file types, and behavior for non-Google Drive files, which an agent may need to know for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It does partially: export_format is connected to 'requested format' with a default of plain text, and file_id is implied by 'a Google Drive file.' However, it does not explain accepted MIME values, whether file_id must point to a specific file type, or how the format string should be structured.

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

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

The description is specific: it names the verb ('Read'), the resource ('Google Drive file'), and the transform behavior (exports Google Docs/Sheets/Slides to a requested format). This clearly distinguishes gdrive_read_file from sibling tools like gdrive_list_files, gdrive_search, gdrive_create_doc, and gdrive_update_doc.

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 an agent needs to retrieve file content, especially Google Workspace documents in a chosen export format. However, it does not explicitly state when to prefer this over listing or searching files, nor does it provide exclusions or mention 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only restates the basic search intent and does not mention read-only behavior, authentication requirements, default limits, or how full-text search interacts with metadata search.

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 sentence with no filler or redundancy. The primary action and scope are front-loaded, and every word contributes meaning.

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 5 parameters, no annotations, and no parameter descriptions, the definition is too thin for reliable invocation. An agent cannot determine how to construct an effective search, what format values are valid, or whether mime_type filtering is supported. The output schema covers return values, but the input behavior is underspecified.

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 hints at query mapping to file name and full_text mapping to content, but it does not explain limit, format, mime_type, or how the parameters combine. Only partial compensation 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 states a specific verb ('Search'), a clear resource ('Google Drive'), and the two search dimensions ('file name or full-text content'). It is distinct enough from siblings like gdrive_list_files, though it does not explicitly contrast itself with them.

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

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

The usage is implied: an agent would use this tool when it needs to find Drive files by name or content. However, there is no explicit guidance about when to prefer this over gdrive_list_files or other GDrive siblings, and no exclusions or alternative routes.

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

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

No annotations are provided, so the description carries the full burden, yet it only restates the mutation ('Update ... content or title'). It omits critical behavioral facts: whether content replaces the entire document, what happens if content is omitted, whether file_id is required, and any permission or access implications.

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

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

A single, front-loaded sentence with no filler. Every word contributes meaning, and it stays appropriately short for a simple update operation.

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 mutating tool with no annotations and 0% schema coverage, the description is too thin: it does not say whether at least one of content/new_title is required, whether content overwrites all existing content, or what the output schema returns. The sibling context shows the GDrive family but the description does not help an agent sequence related tools to obtain file_id.

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 no parameters are required, but the description does not clarify that file_id identifies the target and is effectively mandatory. It also does not explain the default empty strings — e.g., whether omitting content means keep current content or clear it. The description only loosely maps 'content' and 'new_title' without adding real parameter-level 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?

States the exact operation ('Update'), the resource ('an existing Google Doc'), and the scoped fields ('content or title'). It is clearly differentiated from sibling tools like gdrive_create_doc and gdrive_read_file.

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

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

It implies usage for existing docs rather than creation, but provides no explicit when/when-not or alternatives. An agent must infer that gdrive_create_doc should be used for new documents, and no guidance is given about using gdrive_search or gdrive_list_files to obtain the file_id.

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

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

With no annotations, the description carries the behavioral disclosure burden. The verb 'Get' signals a read operation and 'with all their account IDs' gives some return-content context. However, it does not address failure behavior, partial-match resolution, authorization needs, or rate 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 focused sentence with no wasted words. The core action and object are stated upfront, and the output scope is included efficiently.

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 lookup with a full output schema, the description plus schema are largely sufficient. It lacks a little guidance on when to prefer this tool over list_clients, but nothing required to make the call is missing.

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

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

Schema description coverage is 100%, and the schema already explains client name/slug format and matching behavior. The description adds no parameter-level meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description names a specific verb ('Get'), a specific resource ('a specific client's profile'), and the key output ('all their account IDs'). 'Specific client' clearly distinguishes it from the sibling list_clients tool.

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 'a specific client' implies the tool is for single-client lookups rather than listing clients, but it never explicitly states when to use it versus list_clients or other sibling tools. No alternatives or exclusions are mentioned.

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

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

With no annotations, the description carries full disclosure burden. It states the core capability but lacks details on output format, limitations beyond keyword count, potential rate limits, or whether it is a read-only operation. It does not contradict any annotation, but leaves significant behavioral characteristics undisclosed.

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 main action and constraint. It contains no filler or redundancy. While it could add a bit more information without bloating, it is appropriately sized for its 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 tool with 4 parameters, no annotations, and absent schema descriptions, the description is insufficient. It does not explain how 'timeframe,' 'geo,' or 'format' affect results, nor does it clarify the output structure despite having an output schema. An agent would struggle to set parameters correctly beyond 'keywords.'

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 property descriptions). The description mentions only 'keywords' and its limit ('up to 5'), but does not explain 'geo,' 'format,' or 'timeframe' semantics. Even the keyword meaning is only partially covered (limit, not usage examples or expected format). Thus, it adds minimal value beyond property names.

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

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

The description states a specific verb ('explore') with a clear resource ('Google Trends') and includes key details: 'interest over time and related queries' and 'up to 5 keywords.' This distinguishes it from sibling research tools like gads_keyword_ideas or gsc_search_queries, which target different data sources.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or competing tools. An agent must infer usage context from the name and domain alone.

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

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

With no annotations, the description must carry the behavioral disclosure burden. 'Get' implies a read-only operation, and the listed metrics clarify what is returned, but the description does not mention authentication requirements, rate limits, aggregation behavior, or failure handling. This is acceptable for a simple read query but leaves 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 efficient sentence with the core action, source, and metrics front-loaded. There is no redundant wording or filler, so every element 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 five parameters, absent schema descriptions, no annotations, and a close sibling like bing_search_queries, this description is too thin. An agent cannot reliably infer valid dimension values, default behavior, or how to specify the GSC property. The presence of an output schema helps, but the overall usage context remains underspecified.

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 explains none of the five parameters. It only implies query-level data through 'search query performance,' leaving site_url, days, row_limit, dimensions, and format without any semantic guidance. The description does not 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 states a specific verb ('Get'), a concrete resource ('search query performance'), and the data source ('Google Search Console'), while naming the returned metrics (clicks, impressions, CTR, position). This makes it easy to distinguish from siblings like bing_search_queries or ga4_organic_performance.

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 identifies Google Search Console as the data source, giving clear context for when this tool is relevant. It does not mention alternatives or exclusion criteria, but the source-based framing is unambiguous enough to route an agent away from Bing or GA 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?

No annotations are provided, so the description carries the behavioral burden. It states the operation and return fields, but 'recent' is ambiguous (created vs. updated) and there is no mention of ordering, time window, or pagination. For a read-only list tool, this is adequate but not fully transparent.

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

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

A single sentence communicates the verb, resource, scope, and returned fields with no filler. It is front-loaded and every word earns its place.

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

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

Given the low complexity, full parameter schema, and output schema, the definition is mostly complete for basic invocation. The main gaps are the undefined meaning of 'recent' and the absence of any guidance on when to use this tool versus sibling HubSpot tools like hubspot_deals.

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

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

The input schema has 100% description coverage for both parameters (limit and format), so the schema already provides the parameter meanings. The description adds no parameter-level detail beyond listing output fields, but no compensation is needed because the schema is strong.

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 ('List') and resource ('HubSpot contacts'), and enumerates the returned fields (name, email, company, lifecycle stage). It clearly identifies what the tool does, though it does not explicitly contrast it with the sibling hubspot_deals tool.

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

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

The intended use is implied: an agent should call this when it needs recent HubSpot contacts. However, there are no explicit when-to-use conditions, exclusions, or mentions of alternatives such as hubspot_deals, so the guidance is minimal.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It indicates a read-only listing operation, but does not mention pagination behavior, meaning of 'recent', authentication requirements, rate limits, or any other operational caveats.

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

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

The description is a single focused sentence with no filler. The core action and resource are front-loaded, and every word adds relevant information.

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

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

Given the simple parameter set, an output schema, and a straightforward list operation, the description is mostly complete for an agent to call the tool correctly. The main gaps are the undefined 'recent' window and absence of any usage caveats, but these are minor for this 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?

The input schema covers both parameters with clear descriptions, so baseline is 3. The description's mention of returned fields adds mild context but does not meaningfully enrich the meaning of 'limit' or 'format' beyond what the schema already states.

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

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

The description states a specific action ('List recent HubSpot deals') on a clear resource (deals) and names the key data fields returned (stage, amount, close date, owner). This distinguishes it from the sibling hubspot_contacts and the other marketing 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 phrase 'List recent' implies this is the tool for retrieving recent HubSpot deals, but there is no explicit statement about when to use it versus alternatives like hubspot_contacts. No exclusions or alternative tool names are provided.

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

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

With no annotations provided, the description carries the full behavioral burden. 'Search' clearly indicates a read-only kind of operation and the facet list gives some behavioral context. However, it does not disclose authentication requirements, rate limits, or any other behavioral cautions; the presence of an output schema partially reduces the need to describe return values.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently communicates the tool's domain and purpose in a way that an agent can 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 straightforward search/facet tool with four documented parameters and an output schema present, the description plus schema provides enough context for correct invocation. It could be slightly stronger with an explicit note about which facet values are supported or what the search returns, but those are already partially covered by the schema and 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?

The input schema already provides 100% coverage for all four parameters, so the description does not need to compensate. The description adds example facet types, but it also introduces 'company sizes' which is not listed in the schema's facet description, adding limited and possibly confusing semantic value. Thus it sits at the baseline.

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 ('Search') and a clear resource ('LinkedIn ad targeting facets'), and lists example facet categories. It distinguishes itself from sibling platform-specific tools by naming LinkedIn explicitly. It loses a point because the description mentions 'company sizes' while the input schema's facet description lists 'seniorities' instead, creating minor ambiguity.

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

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

The description implies usage for LinkedIn ad targeting research, and sibling names like meta_interest_targeting and tiktok_interest_targeting suggest platform-specific alternatives. However, it does not explicitly state when to prefer this tool over those alternatives or when not to use it, so the guidance is implied rather than stated.

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

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

No annotations are provided, so the description carries the burden. 'List' and 'see' signal a read-only operation, and the description discloses the output conceptually: mappings from friendly names to GA4, Search Console, Google Ads IDs. It does not mention side effects, but none are implied.

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

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

Three short sentences, each earning its place: action, use case, and example mapping. The description is front-loaded and contains 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 simple list operation with an output schema, the description covers the core behavior and data scope well. The only gap is the undocumented `format` parameter, which prevents a perfect score.

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 ignores the only parameter, `format`. Schema description coverage is 0%, so the description needed to compensate by explaining acceptable values, but it does not. The agent gets no additional semantics beyond the bare schema definition.

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-resource pair: 'List all client profiles with their configured account IDs.' It clearly distinguishes from sibling get_client_profile by emphasizing 'all' rather than a single client.

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 explicitly says 'Use this to see which clients are set up and what accounts they have linked,' giving clear context for when the tool is appropriate. It does not mention alternatives or exclusions, but the intended use case is well stated.

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

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

With no annotations, the description carries the behavioral disclosure burden. It clearly indicates a read-only listing operation and reveals the key output (counts and stats), but it does not disclose pagination, authentication requirements, rate limits, or any behavior around the 'format' parameter. This is a basic but not rich level of 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, tightly worded sentence with no filler. The main action and resource are front-loaded, and the added detail about subscriber counts and stats 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 simple list operation with one optional parameter and a present output schema, the description covers the core behavior. However, it leaves the 'format' parameter unexplained and offers no guidance on access or limitations, so an agent is not fully equipped to invoke the tool in non-default ways.

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 only parameter 'format' has no schema description, and schema description coverage is 0%. The tool description does not mention this parameter at all, leaving an agent to guess what values are accepted or how the parameter affects the output. The description fails to compensate for the lack of schema-level 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 a specific verb ('List') with a clear resource ('Mailchimp audiences') and specifies what is returned ('subscriber counts and stats'). It is immediately distinguishable from sibling tools like mailchimp_campaigns because the resource is 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?

No guidance is provided about when to use this tool versus alternatives. The description simply states what it does; there is no mention of prerequisites, exclusions, or why an agent would choose this over a sibling like mailchimp_campaigns.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It adds meaningful context by specifying 'recent' and listing the metrics included, but it does not clarify the meaning of 'recent', how missing metrics are handled, or any account/authentication assumptions.

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 resource, the action, and the relevant metrics without any filler. 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 simple two-parameter tool with a fully documented schema and an output schema present, the description is largely complete. The only slight gap is the ambiguous term 'recent,' but overall the agent has enough information to select and invoke this 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?

Schema description coverage is 100%: both 'limit' and 'format' are already documented in the input schema. The description adds no additional parameter-level meaning, so 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 clearly states the specific resource (Mailchimp email campaigns), the action (get recent), and the key metrics returned (open rates, click rates, send counts). It distinguishes itself from siblings like mailchimp_audiences by focusing on campaigns and their performance data.

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 'Get recent Mailchimp email campaigns' makes the primary use case clear: retrieving recent campaign performance metrics. No explicit exclusions or alternative routing are given, but no close sibling requires this distinction.

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

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

No annotations are provided, so the description carries the burden of explaining behavior. It clearly describes a read-only listing operation and its output content, but it does not mention potential dependencies on connected platforms, failure conditions, or details about how counts are computed.

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, front-loaded with the action, and contains no filler. Both sentences add value: the first defines what the tool returns, the second frames when to use it.

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 an output schema, the description covers the core purpose and usage context. However, it leaves the `format` parameter unexplained and does not differentiate this tool from the closely related `marketing_prompts` sibling, so the context 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 input schema has a single `format` parameter with a default of 'markdown', but zero schema description coverage. The description does not mention or explain the `format` parameter, its possible values, or how it affects output. The impact is modest because the parameter is optional, but the description still fails to compensate for the schema 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 and resource ('List all marketing prompt categories') and states the result, including counts of available prompts. It is clear enough to distinguish from sibling tools like marketing_prompts, though it does not explicitly name that sibling.

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 explicit guidance: 'Use this to discover what types of marketing tasks you can do with your connected platforms.' This provides clear context for when the tool is appropriate, though it does not mention situations where an alternative might be preferred.

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

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

With no annotations provided, the description carries the full burden. It clearly communicates a read-only browsing/showing behavior with no side effects, and it explains that results depend on which APIs are configured. It could add more detail about default behavior, but the read-only nature is sufficiently transparent.

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

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

The description is concise and front-loaded with the core purpose. Filter values are enumerated usefully. Minor redundancy exists between 'based on your connected platforms' and 'based on which APIs you have configured', but overall it is tight and well-structured.

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

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

The description covers the tool's purpose, source of data, and filtering options, and an output schema exists to handle return-value details. However, it omits any explanation of the 'format' parameter or the behavior when optional parameters are left empty, leaving a meaningful gap for a three-parameter 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 for the input schema's lack of parameter documentation. It does provide useful allowed values for 'category' and 'level', but it says nothing about the 'format' parameter, leaving one of three parameters semantically unexplained.

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 ('Browse') with a clear resource ('ready-to-use marketing prompts') and a concrete context ('based on your connected platforms'). It clearly distinguishes this from a generator tool by emphasizing pre-built, immediately usable prompts.

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 the tool: when the user wants ready-to-use prompts filtered by configured APIs. It does not explicitly name alternatives or state when not to use it, but the context is specific enough for an agent to infer the intended use case.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only search, but does not disclose authentication needs, rate limits, data freshness, or whether results are estimates/approximate.

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

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

The description is a single, front-loaded sentence with no filler. It is appropriately sized, even though brevity leaves some behavioral and usage details to be filled elsewhere.

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

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

With a simple schema (one required string, two optional defaults) and an output schema, the description is minimally sufficient to invoke the tool. However, it lacks any mention of prerequisites or edge cases, so it is 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?

Schema description coverage is 0%, and the description only adds that the query is a 'topic'. It does not explain the `limit` parameter or the possible `format` values, nor how the query is interpreted by Meta.

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 action ('Search'), the resource ('Meta ad interests'), and the specific output ('audience size estimates'). This clearly identifies the platform and distinguishes it from sibling tools like TikTok and LinkedIn interest targeting.

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

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

No guidance is given about when to choose this tool over alternatives such as TikTok or LinkedIn interest targeting. It does not mention use cases, exclusions, or prerequisites, so an agent must infer when this is the right 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?

With no annotations at all, the description must carry the full burden of behavioral disclosure, but it only states the high-level outcome. It does not mention that the tool likely fetches the URL, performs a network-based audit, may be slow or rate-limited, or whether any state changes or credentials are involved. The behavior is hinted at but not meaningfully disclosed beyond the tool name.

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 that conveys the core purpose without filler. It is front-loaded with the key verb and resource. It loses one point only because it omits essential parameter and usage context that could have been included without much extra length.

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 three parameters, none of which are described in the schema or the tool description, and there are no annotations to fill the gap. Although an output schema exists, an agent cannot invariantly understand the role of 'format' and 'strategy' or how to tailor the audit. This is incomplete for a tool with multiple meaningful options.

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, but it only clarifies the URL target and says nothing about 'format' or 'strategy'. An agent reading the description cannot know what formats are available, what strategy means, or how those defaults affect results. The description adds minimal value beyond the raw 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 opens with the specific verb 'Audit' and names the resource ('a URL's performance') plus the concrete outputs ('Core Web Vitals and optimization tips'). This clearly distinguishes the tool from the marketing/research siblings, none of which perform technical URL performance auditing.

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

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

There is no guidance about when to choose this tool over alternatives, no indicated prerequisites, and no exclusions. The single sentence merely implies that one should use it when a URL performance audit is needed, which is not enough to help an agent weigh options among the many sibling tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It conveys a read-only search operation and lists the output contents, but it does not mention output format defaults, limit behavior, access constraints, or any other operational details. This is acceptable for a simple search tool but leaves some behavior to inference.

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 action and resource, then concisely lists the relevant output fields. There is no filler, repetition, or unnecessary detail.

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

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

For a simple tool with only three parameters, full schema coverage, and an output schema, the description provides enough core information to guide invocation. It could improve by explicitly stating read-only behavior or exclusions, but the low complexity means nothing essential is missing.

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

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

Input schema has 100% description coverage, so the baseline is 3 even without detailed parameter explanations in the tool description. The description adds context about what results look like but does not need to explain query, limit, or 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 uses a specific action ('Search') and a specific resource ('Pinterest pins'), and it names the returned fields (titles, descriptions, links, save counts). This clearly differentiates it from the sibling tools, which are mostly about other platforms or different data types.

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

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

The description implies the correct context: use this tool when topic-level Pinterest pin research is needed. It does not explicitly state when not to use it or name a sibling alternative, but since no other sibling covers Pinterest pins, the usage context is reasonably clear.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It transparently says the tool 'Returns customized prompts you can copy and use immediately,' implying a non-mutating, generation-only behavior. However, it does not explicitly state absence of side effects, rate limits, or other operational caveats.

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

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

The description is well-structured and front-loads the core action, then provides input guidance and output expectation. The examples add useful context rather than padding. It is slightly longer than strictly necessary but every sentence earns its place.

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

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

For a simple three-parameter generation tool with an output schema present, the description covers the essential input semantics and output value. It could be more complete by naming the sibling 'marketing_prompts' as an alternative, but the overall invocation contract is clear.

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 explains 'business_type' with multiple examples, and clarifies that 'goals' and 'platforms' are optional via 'optionally your marketing goals and preferred platforms.' It does not specify a format for multi-value strings, but the semantic meaning for all three parameters is present.

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

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

The description uses a specific verb and resource: 'Generate a personalized set of marketing prompts.' It clearly states what the tool does and provides concrete examples of the required input. However, it does not differentiate from the sibling 'marketing_prompts' tool, so it loses the sibling differentiation point.

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

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

The description gives clear usage context: provide business type, optionally goals and platforms, and get prompts. It does not explicitly state when to use this tool versus alternatives such as 'marketing_prompts' or 'marketing_categories', nor does it 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?

With no annotations, the description carries the burden of disclosing behavior. It communicates that the operation is a non-mutating search and highlights the returned data, but it does not disclose rate limits, authentication requirements, default sorting behavior, or that responses are read-only. For a simple search tool this is adequate but not rich.

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 packs the action, target, and output highlights with no filler. 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 output schema covers return details, so not explaining response format is acceptable. However, the description is incomplete as a call specification: six undocumented parameters, no usage guidance, and no mention of defaults or constraints. An agent could invoke it with the required query, but would have to guess at optional parameter semantics.

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 adds no meaning for any of the six parameters. Even though param names are self-evident, the description does not explain query syntax, allowable sort/time_filter values, limit bounds, or the format parameter.

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

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

The description begins with a specific verb ('Search') and a clear resource ('Reddit'), and further scopes the result set to posts about a topic while naming the key returned elements: scores, comments, and top comment excerpts. It is easy to distinguish from sibling tools like youtube_topic_research or google_trends_explorer.

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 use case is implied by the tool name and 'Search Reddit for posts about a topic,' but the description does not explicitly state when to prefer this over sibling research tools or mention exclusions/limitations. There is no when-not-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'get' signals read-only intent, but the description does not mention authentication needs, rate limits, data freshness, or pagination behavior. For an unannotated external API tool, this is minimal behavioral disclosure.

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, front-loaded sentence with no filler. Every phrase earns its place, but it stops short of also providing a brief usage note or alternative guidance.

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

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

Given the simple 4-parameter schema, full parameter documentation, and presence of an output schema, the description covers the essential purpose and result content. However, it lacks sibling differentiation and enough usage context for an agent to reliably select this tool among the many marketing research tools in the sibling list.

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 all four parameters with 100% coverage, so the baseline is 3. The description adds light context by naming the output areas, but it does not clarify how 'limit' applies across those areas or what the 'database' codes affect beyond the schema's own explanation.

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

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

The description clearly identifies the action and resource: 'Get domain analytics overview from Semrush' and lists the main result areas (organic traffic, keywords, top pages). It is specific enough to convey the tool's purpose, though it does not explicitly distinguish itself from the similar sibling semrush_keyword_overview.

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 choose this tool over related research tools such as semrush_keyword_overview, gsc_search_queries, or ga4_organic_performance. The phrasing implies a high-level domain check, but it provides no exclusions, prerequisites, or preferred scenarios.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only lists outputs. It does not state whether the operation is read-only, whether API keys or quotas apply, how database selection affects results, or what rate limits exist. The word 'Get' implies a read operation, but no meaningful behavioral detail is added beyond that.

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 written sentence that front-loads the verb and resource. It lists the key output metrics in a readable em-dash list without 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 simple three-parameter lookup with a full output schema, the description is mostly complete: it names the tool's purpose and the expected data categories. It omits external-service context like authentication or rate limits, but those are not essential for understanding how to invoke the tool. Given the low complexity and rich schema, the definition is sufficient for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents keyword, database, and format. The description adds nothing about parameter meaning beyond stating the output metrics; it doesn't clarify how database codes map to regions or how format affects response structure. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description uses a specific verb ('Get') and resource ('keyword metrics from Semrush'), and enumerates the exact metric types returned: volume, difficulty, CPC, and SERP features. This clearly differentiates it from sibling tools like semrush_domain_overview, which targets domain-level data rather than keyword data.

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

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

The description gives no explicit guidance on when to use this tool versus the many sibling research tools. It does not mention alternatives, exclusions, or context such as 'use for keyword research rather than domain overview'. The intended use is only implied by 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does communicate a read-style operation and specifies returned fields, but it remains silent on pagination, rate limits, authorization, or any caveats around the status filter.

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

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

The description is a single focused sentence with no filler. It front-loads the action and resource and communicates the main return contents efficiently, though it could have briefly mentioned filtering capability.

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 listing with full schema coverage and an output schema, this describes the core call adequately. However, it lacks guidance on when to use it among many siblings and omits behavioral caveats, making it only minimally 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?

Parameter schema coverage is 100%, and each parameter (limit, format, status) already has a concise schema description. The tool description adds no additional parameter-level meaning, so the baseline score 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 clearly states the action ('Get'), the resource ('recent Shopify orders'), and the key data returned ('totals, fulfillment status, and customer info'). It is distinguishable from sibling tools like shopify_products, though it does not explicitly contrast itself with any alternative.

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

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

No guidance is given about when to use this tool versus alternatives, or what status/format values are appropriate for different scenarios. The description implies a general 'recent orders' use case but provides no exclusions or decision context.

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

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

No annotations are provided, so the description carries the full burden for behavioral context. The verb 'List' implies a non-mutating read operation, and the description names the returned fields, but it does not disclose pagination, auth requirements, rate limits, default behavior, or data freshness. This is neutral but not richly transparent.

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

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

The description is a single front-loaded sentence with no filler words. It efficiently states the verb, resource, and key output fields. It could have added operational context, but it is concise and readable.

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 list tool with two well-documented parameters and an output schema, the description is largely sufficient for an agent to invoke it correctly. The main gaps are operational caveats such as pagination, auth, and inventory freshness, but these are secondary given 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?

Schema description coverage is 100%, so both `limit` and `format` are already documented clearly in the input schema. The description adds product-field context but does not provide additional meaning for the parameters themselves. 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 the specific verb 'List' and identifies the resource as Shopify products, explicitly naming the included fields: titles, prices, inventory status, and variants. This clearly distinguishes it from the sibling tools, which target other platforms such as Mailchimp, Google Ads, and GA4.

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 state explicit when-to-use or when-not-to-use guidance. It implies usage by describing the operation, but it does not name alternatives or exclusions. Since sibling tools are unrelated to Shopify product listings, the missing exclusion guidance is less critical, but still absent.

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

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

With no annotations, the description must stand alone: 'Get' signals a read-only operation, which is useful, but no side-effect, auth/scope, pagination, or output behavior is disclosed. Since an output schema exists, some of this burden is relieved, but the text adds only minimal behavioral context beyond the word 'Get.'

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 that front-loads the actionable resource and purpose immediately. No fluff, repetition, or unnecessary detail.

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

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

For a two-parameter read tool with full schema coverage and an output schema, the description provides the core 'what' and 'why' but not the 'when not' or platform-alternative context. This is borderline acceptable given low complexity, but the missing selection guidance keeps it from a 5.

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

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

The input schema already documents advertiser_id and format with 100% coverage, so the baseline is satisfied. The description adds no additional meaning about parameter formats, constraints, or their relationship to the returned categories.

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 ('Get') and resource ('TikTok Ads interest categories'), making the tool's core function identifiable. It clearly communicates the research purpose, and the platform name separates it from cross-platform siblings like meta_interest_targeting, though it doesn't explicitly spell out when to choose it over 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 phrase 'for audience targeting research' gives an implicit context for using the tool, but no when/when-not statements or alternatives are given. An agent must infer that this is for TikTok-specific research rather than Meta or LinkedIn, and isn't warned about when not to use it.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does convey the return fields and implies a read-only, temporal scope ('recent'), but it does not define the recency window, mention rate limits, or clarify auth requirements. The output schema helps, but behavioral traits beyond the basic result fields are under-specified.

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 written sentence that front-loads the action and resource, then names the key outputs. There is no filler or 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?

The tool is simple, and the output schema plus full parameter descriptions cover most invocation needs. However, the 'recent' time range is undefined, and there is no statement about when to use this tool in the broader research-tool context. This leaves a moderate gap for an agent trying to reason about expected scope and applicability.

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

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

Schema description coverage is 100%, so the parameters are already documented in the schema. The description adds no meaningful parameter-level detail beyond stating output fields; 'recent' is a behavioral scope rather than a parameter clarification. 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 states a specific verb and resource: 'Search recent tweets/posts on X (Twitter)' and lists the key return fields (text, likes, retweets, impression counts). It is clearly distinguished from sibling tools, since it is the only X/Twitter search tool, though 'recent' lacks a precise time window.

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, and there are no exclusions or context about which sibling tools to prefer. An agent gets no direction about whether to pick this over the many research/marketing sibling tools.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It mentions 'recent' and 'specific', but does not clarify sorting, review availability, invalid ID behavior, rate limits, or that this is a read-only operation. The output schema helps with return values but not runtime behavior.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the resource and scope, and it is appropriately sized for such a straightforward tool.

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

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

Given the low complexity, single required parameter, and presence of an output schema, the description is mostly complete. Minor gaps include not mentioning that yelp_business_search may be needed to obtain a business ID and not operationalizing 'recent,' but these do not severely impair correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents business_id, limit, and format clearly. The description adds no extra parameter meaning beyond aligning 'specific business' with business_id, so 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 states a clear verb ('Get'), a specific resource ('recent Yelp reviews'), and a scope ('for a specific business'). It naturally distinguishes itself from the sibling yelp_business_search, which finds businesses rather than reviews.

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

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

There is no guidance on when to use this tool versus alternatives, such as yelp_business_search for finding the business first. The description implies use when you already have a business ID, but it does not explicitly state 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?

No annotations are provided, so the description carries the behavioral disclosure burden. 'Search' implies a read-only operation, and the listed outputs tell the agent what kind of data to expect, but the description does not mention access requirements, rate limits, or any non-obvious constraints. It is adequate for a simple search tool, but not richly transparent.

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

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

One short sentence conveys the core action, resource, and returned data fields with no fluff. The most useful information is front-loaded and every word earns its place.

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

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

The output schema exists and all parameters are documented, so invocation details are covered. However, the description lacks any mention of when to choose this tool over closely related siblings like 'yelp_business_reviews' or 'gbp_insights'. For a research tool among many alternatives, a bit more orientation would make it complete.

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

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

Schema description coverage is 100%, so all parameters are already documented in the input schema. The description does not add extra meaning about term, location, limit, or format, but it does not need to since the schema handles that burden. It earns the baseline score of 3.

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

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

The description clearly names the action ('Search') and resource ('Yelp businesses'), and adds the output fields: ratings, review counts, categories, and pricing. It does not explicitly contrast with the sibling tool 'yelp_business_reviews', but the 'business search' wording versus 'reviews' makes the primary purpose fairly distinguishable.

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

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

No guidance is given about when to use this tool instead of alternatives such as yelp_business_reviews, gbp_insights, or other research tools. There are no explicit conditions, exclusions, or scenarios provided, leaving the agent to infer suitability from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only search operation, but it does not disclose rate limits, pagination behavior, output structure, or any side effects. The behavioral information is minimal and mostly inferred from the word 'search'.

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

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

The description is a single front-loaded sentence with no filler. It communicates the main purpose efficiently, though it sacrifices explanatory depth for brevity.

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

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

For a tool with four parameters and no annotations, the description is incomplete. The presence of an output schema helps with return values, but the description still lacks parameter semantics, usage boundaries, and behavioral caveats, so an agent cannot fully judge how to call this tool well.

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 explain order, format, or max_results. The only implicit mapping is the topic corresponding to 'query', but the description adds no real meaning beyond the obvious parameter names and defaults.

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

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

The description states a specific verb ('Search'), a clear resource ('YouTube videos'), and the data returned ('view counts, likes, engagement data'). This clearly distinguishes it from sibling research tools like reddit_topic_research or google_trends_explorer.

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 YouTube topic research, so an agent could infer when to use it. However, it gives no explicit guidance on when not to use it or which alternative tool to prefer, leaving the choice to inference.

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