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

Annotations already declare readOnlyHint, openWorldHint and destructiveHint=false, so the safety profile is covered; the description adds genuine value with the credit cost (1 credit per call) and the shape of the response payload. It omits any mention of rate limits, result caps, or whether cached/proxied results are returned, which keeps it from a 5.

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

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

Two short sentences: identity and return shape first, cost second. No filler, no restatement of the schema, and every sentence earns its place.

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

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

With nine parameters fully documented in the schema and no output schema, the description compensates well by listing the returned fields and the per-call cost. It is not fully complete because it never tells the agent how this engine relates to the many sibling search tools in the same server.

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 all nine parameters carry their own documentation, including the cc/mkt mutual exclusion and the pagination defaults, so the schema already does the heavy lifting. The description adds nothing about parameter meaning, which is the expected baseline-3 outcome in this configuration.

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

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

The description gives a specific verb and resource ('Query Bing Search via API') and enumerates the returned fields (title, link, snippet, position), so an agent knows exactly what it gets back. The Bing name implicitly separates it from the google_search/brave_search/duckduckgo_search siblings, but it never states that differentiation explicitly.

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

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

There is no when-to-use guidance at all: nothing says when Bing is preferable to google_search, brave_search, or google_search_light, all of which appear as siblings. The only usage-adjacent sentence is a cost note, which is not a selection criterion.

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

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

Annotations already declare readOnlyHint, openWorldHint and destructiveHint, so the safety profile is covered. The description adds genuinely new operational context in "Credit cost: 1 credit per call", which is not captured in annotations or schema. It stops short of describing result shape or rate/limit behavior, so it is useful 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?

Two short sentences with the cost constraint front-loaded at the end where it is most actionable. The leading fragment "Brave Images." merely repeats the tool name and title and is the only wasted token.

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 six parameters all fully described in the schema and annotations covering the safety profile, the description only needs to add cost and capability context, which it does. The absence of an output schema means the return format ("structured image results") remains undefined, but the fields parameter and pagination note partially compensate.

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

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

Schema description coverage is 100%, so every parameter including gl, hl, page, safe, query and fields is already documented in the schema with examples and defaults. The description's mention of "pagination and SafeSearch" only restates capabilities the schema explains in more detail, adding no syntax or edge-case meaning.

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

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

The description states a specific verb and resource ("Search Brave Images via API") and names the resulting artifact ("structured image results"). It distinguishes itself by provider name, but never contrasts with the obvious alternatives in the sibling list such as google_images or bing_search, so differentiation is implicit rather than stated.

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

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

There is no when-to-use or when-not-to-use guidance. With google_images, bing_search, duckduckgo_search and others available for image queries, the description gives the agent no basis for choosing Brave over an alternative beyond the provider name.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds genuine operational context by disclosing the credit cost (1 credit per call) and the availability of pagination, but says nothing about result volume, rate limits, or failure modes.

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

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

Two short sentences, front-loaded with purpose before the cost note, with nothing extraneous. Minor redundancy in restating the product name as both the first phrase and the search target.

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 five-parameter search tool with full schema coverage, a complete annotation set, and no output schema, the definition covers what the tool does, its cost, and its pagination capability. What remains missing is sibling differentiation guidance, which is not essential for calling 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 every parameter (query, gl, hl, page, fields) is already documented with defaults and examples in the schema. The description adds no parameter-level meaning beyond that, so the baseline 3 is appropriate.

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

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

The description gives a concrete verb and resource ("search Brave Search") and states the return shape ("structured organic results with pagination"), which is clear. It does not differentiate itself from sibling search engines like google_search, bing_search, or duckduckgo_search, nor from brave_images/brave_videos beyond the implicit adjective "organic".

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 pick Brave over the many sibling search providers, and no exclusions or preconditions (e.g., rate limits, credit budget considerations) are stated. The only implied usage signal is "organic results," which faintly suggests web results rather than images/videos.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so safety is covered. The description adds a genuinely useful detail not in the annotations: a fixed credit cost of 1 per call, which affects whether an agent should call it repeatedly. It stops short of describing result fields or pagination limits, but for a read-only search tool that is a minor gap.

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

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

Three short sentences are front-loaded with the core action, and the credit cost is stated up front where an agent will see it. The leading 'Brave Videos.' sentence merely restates the title and could be dropped without loss.

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 six parameters all documented in the schema and safety covered by annotations, the description supplies what is missing: the external Brave backend, credit cost, and support for pagination and SafeSearch. Return values are only summarized as 'structured video results', but with no output schema that is a modest gap rather than a blocking one.

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

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

Schema description coverage is 100%, so all six parameters, including gl, hl, page, safe, and fields, are already documented in the schema with examples. The description only echoes pagination and SafeSearch at a high level without adding syntax or constraints beyond the schema. Baseline 3 is appropriate when the schema carries the parameter burden.

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

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

The description gives a specific verb and resource ('Search Brave Videos') plus the result shape ('structured video results with pagination and SafeSearch'), so the agent knows exactly what the tool does. It does not differentiate from siblings such as google_videos or brave_search, so an agent must infer which search backend to prefer.

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

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

There is no explicit when-to-use, when-not-to-use, or alternative named. The only guidance is implicit in the name and the mention of pagination/SafeSearch. Nothing tells the agent why it would pick brave_videos over google_videos or brave_search.

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

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

The annotations already declare readOnlyHint, openWorldHint, and destructiveHint, so the safety profile is covered elsewhere. The description does add the non-obvious cost model ('1 credit per call'), which is genuinely useful. It says nothing about result counts per page, how deep pagination goes, or whether results are cached or rate-limited.

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, front-loaded with the action and resource, no filler. Minor redundancy in restating the tool name before 'Query DuckDuckGo', but nothing that costs the reader real effort.

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 five-parameter, fully documented read-only search tool with no output schema, the description covers the essentials plus cost. It is still thin on result shape and pagination limits, which an agent must know to iterate correctly, so it 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?

Schema description coverage is 100%, so the schema already explains gl, hl, page, query, and fields in adequate detail. The description only alludes to 'region and language' without adding format, defaults, or interaction semantics beyond that. Baseline 3 applies when the schema carries the parameter burden.

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 pair ('Query DuckDuckGo via API and retrieve structured organic results') and names the engine, which in practice separates it from google_search, bing_search, and brave_search. It stops short of any explicit contrast with those siblings.

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

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

There is no guidance on when to pick this engine over the many sibling search tools, nor on prerequisites or exclusions. The only decision-relevant fact offered is the credit cost, which speaks to budget rather than to selection.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds one useful behavioral fact beyond them: the endpoint is free, so it costs no credits. It says nothing about result size, pagination, or matching behavior.

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

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

Two short sentences with no wasted words, and the retrieval outcome is front-loaded. The first sentence merely restates the title, which is the one redundancy in an otherwise tight definition.

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

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

This is a simple two-parameter read-only lookup with full schema coverage and no output schema, and the description states what you get back (country codes) and that it is free. Only sibling differentiation is missing, which is minor for a narrowly scoped reference lookup.

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

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

Schema description coverage is 100%, with both 'query' (case-insensitive match on code or name) and 'fields' (comma-separated projection, no credit change) fully documented in the schema. The description adds no parameter detail beyond that, so the baseline 3 applies.

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

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

The description uses a specific verb and resource ('Search Google countries and retrieve country codes'), and the 'Finder' naming plus sibling names (finder_google_languages, finder_google_locations) let an agent infer the domain. It is clear but does not explicitly distinguish itself from those close siblings.

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

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

There is no guidance on when to choose this over finder_google_locations or finder_google_languages, nor any stated prerequisite or exclusion. The purpose implies usage ('search countries') but nothing steers selection among the many search 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?

Annotations already declare readOnlyHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds that it is a "free Finder endpoint", which is meaningful context given the fields parameter notes credit costs. It says nothing about response shape, result limits or pagination, so credit for added context is limited.

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

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

Two short sentences with the action front-loaded and no padding. The only waste is the leading "Google Languages." fragment, which duplicates the title and the resource already named in the following sentence.

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

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

For a simple two-parameter read-only lookup this is adequate: the annotations carry the safety profile and the schema carries the parameter detail. It still omits what the returned language records look like and whether the result set is complete or capped, which matters for an open-world lookup.

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

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

Schema coverage is 100%, with both the query filter semantics (case-insensitive substring match) and the fields projection fully documented in the schema. The description adds no parameter-level detail beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource: "Search Google languages and retrieve language codes", which clearly separates it from sibling lookups like finder_google_locations and finder_google_countries. It is clear without opening the schema, though the opening "Google Languages." just restates the title.

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

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

Usage is only implied — an agent can infer this is the tool for resolving language names/codes before calling another API. There is no explicit when-to-use or when-not-to-use guidance, and no sibling tool is named as an alternative or complement.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds one genuinely useful behavioral fact not in the annotations: it is a free endpoint, so no credits are consumed. It says nothing about ordering, result limits, or pagination behavior beyond what the schema already mentions.

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

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

Two short sentences, front-loaded with the resource and followed by what it returns and its cost profile. The only waste is the leading 'Google Locations.' fragment, which merely restates the title.

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 read-only lookup with full schema coverage and no output schema, the definition covers the essential facts: what is searched, what identifiers come back, and that the call is free. The main omission is sibling disambiguation, which matters here given several overlapping finder_* tools.

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

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

Schema description coverage is 100%, with both query and fields fully documented in the schema itself, including dot notation and the fact that fields does not change credit cost. The description adds no parameter-level meaning beyond that, so the baseline of 3 applies.

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

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

The description states a concrete verb and resource: find supported Google locations and retrieve their location IDs and country codes. It is clear what an agent gets back at a high level, but it does not distinguish this tool from the near-identical sibling finder_google_countries, which an agent would have to disambiguate on its own.

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

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

There is no explicit when-to-use statement, no exclusions, and no named alternative. The overlap with finder_google_countries and finder_google_languages is left entirely unresolved, so an agent has no textual basis for choosing between them beyond the tool name.

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

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

Annotations already declare readOnlyHint, openWorldHint, and destructiveHint, so the safety profile is covered. The description contributes the per-call credit cost and the shape of returned data, which are genuinely additive. It says nothing about result volume, pagination limits, or what an async job response looks like, which are the remaining behavioral 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?

Two short sentences, with the core action front-loaded, and no filler. The leading 'Google Images.' merely restates the title and name, which is the one wasted fragment, but the rest is tightly written.

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 ten-parameter, read-only search tool with full schema coverage and annotations covering safety, the description is nearly sufficient: it names the source, the return payload, and the cost. The absence of guidance on when to prefer this over brave_images and on the async workflow are the only meaningful omissions.

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 ten parameters (query, gl, hl, cr, lr, page, safe, fields, google_domain, async) are already documented in the schema. The description adds no parameter-level meaning beyond the credit note tied to the fields parameter. Baseline 3 applies because the schema does the heavy lifting.

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

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

The description uses a specific verb and resource ('Search Google Images via API') and enumerates the returned fields (URLs, titles, sources, dimensions), so the agent knows exactly what the tool produces. It does not distinguish itself from close siblings such as brave_images or google_videos, leaving the choice between image search providers to the caller.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no mention of the sibling image-search tools (brave_images) that could substitute. The only contextual note is a pricing statement ('1 credit per call'), which is useful but is not usage guidance.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful context beyond that: a credit cost of 1 per call, and the fact that pagination exists. It does not cover rate limits, result caps, or what the scraper does when no listings are found, so it is helpful 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?

Three compact sentences with the purpose front-loaded, and the credit-cost note placed last where it is easy to find. The opening 'Google Jobs.' merely restates the title and is wasted space. Otherwise, there is no padding.

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

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

With 13 parameters, a scraper behavior, and pagination to handle, the definition is thin: it never explains that next_page_token drives paging, nor that it is a paid call whose filters (ltype, lrad, uds) are optional refinements. The complete schema and the annotations compensate for much of the gap, and no output schema exists to explain return values. Adequate, but not fully sufficient for a tool of this complexity.

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

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

Schema description coverage is 100%, so all 13 parameters, including the conflicting location/uule pair and the next_page_token, are documented in the structured data. The description only alludes to title/company/location fields and pagination, adding essentially no syntax or constraint detail beyond the schema. Baseline 3 is appropriate when 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 gives a specific verb and resource ('Scrape Google Jobs results via API') plus the kind of data returned (structured job listings with title, company, location) and pagination support. That is a clear, concrete purpose. It stops short of distinguishing itself from nearby siblings such as google_search or google_news, so it falls just short of a 5.

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

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

There is no when-to-use or when-not-to-use guidance and no mention of alternatives like google_search or google_maps. The only contextual signal is the credit cost, which tells the agent about expense but not about tool selection. An agent must infer from the name alone when this tool is the right choice.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful context beyond that: a cost model of '1 credit per call'. It does not disclose result caps, pagination depth limits, or rate limits, which matter for an open-world search tool.

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

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

Three short sentences, front-loaded with the purpose and ending with the cost note. The leading 'Google Maps.' fragment merely restates the title and could be dropped, but overall there is almost no wasted text.

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 nine-parameter open-world search tool with no output schema, the description covers purpose, likely return content, and cost, which is adequate to call it. It omits pagination/result-count limits and any routing guidance against its numerous search siblings, leaving real gaps an agent must discover by trial.

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 nine parameters (cr, gl, hl, ll, lr, page, query, fields, google_domain) are already documented in the schema. The description adds no extra syntax or semantics for any of them; its only related contribution is naming likely returned fields, which the schema's 'fields' parameter already covers.

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

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

The description gives a specific verb+resource ('Search Google Maps via API') and names the return content (address, website, phone), so an agent knows it is a place/local-business lookup rather than a web search. It does not explicitly contrast itself with the many sibling search tools (google_search, google_search_light, brave_search), so it stops short of full sibling differentiation.

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

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

There is no statement of when to prefer this over google_search, google_search_light, or the finder_google_* tools, and no exclusions or prerequisites. Usage is only implied by the mention of 'structured place results', which an agent must infer means local/business lookups.

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

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

Annotations already declare readOnlyHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful context beyond that: the credit cost (1 credit per call) and the fact that results are paginated. It does not explain result freshness, ranking behavior, or limits, but the cost disclosure is a meaningful addition for an agent budgeting calls.

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, front-loaded with the purpose before the cost note. Minor waste in 'Google News.' as a standalone opener, which merely restates the title before the actual verb sentence.

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

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

There is no output schema, so the burden of describing the 'structured news results' falls on the description, which only asserts they are structured and paginated without saying what fields come back. Given nine parameters with full schema docs and helpful annotations, the definition is adequate but leaves the agent guessing about the sibling choice and the return shape.

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 nine parameters (query, gl, hl, cr, lr, num, page, fields, google_domain) are already documented in the schema. The description only echoes the pagination capability that page/num already describe, adding no syntax or semantics of its own. 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?

States a specific verb+resource: 'Search Google News' and 'retrieve structured news results with pagination'. This clearly separates it from non-news siblings like google_maps or google_shopping. However, it never distinguishes itself from google_search, google_search_light, or google_search_ai, which an agent could easily confuse it with.

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

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

Usage is only implied: an agent can infer it should be used for news queries because the resource is Google News. There is no explicit when-to-use guidance, no mention of when to prefer google_search, and no prerequisites or exclusions stated.

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

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

Annotations already declare readOnlyHint, openWorldHint and non-destructive, so safety is covered. The description adds genuinely useful operational facts that annotations cannot express: a cost of 1 credit per call and the availability of pagination. It stops short of rate limits, per-page caps, or what triggers failure, which matters for a paid open-world call.

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

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

Two short sentences, zero filler, with the core action first and cost/pagination compactly appended. Nothing to cut.

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 13-parameter read-only search tool whose params are fully documented in the schema and which has no output schema, the description covers action, data shape in outline, pagination and cost. The missing piece is sibling differentiation and any hint of the SERP response shape beyond 'structured SERP data'.

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 13 parameters, including the uule/location mutual exclusion and the deprecated num, are already documented in the schema. The description adds no parameter meaning beyond that, which is the baseline case when 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?

States a specific verb and resource: scrape Google Search results and return structured SERP data with pagination. Clear what it does, but it never distinguishes itself from near-neighbors like google_search_light, google_search_ai, or brave_search/duckduckgo_search, so an agent cannot route on description alone.

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

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

No when-to-use or when-not-to-use guidance at all. It mentions pagination exists but never says to use it instead of google_search_light, or when Google is the right engine versus bing_search or duckduckgo_search, all of which are 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, destructiveHint=false, so the safety profile is covered. The description adds two genuinely useful facts beyond that: the billing impact (3 credits per call) and the shape of the payload (text_blocks, references, shopping_results). It says nothing about latency, rate limits, or failure modes for a live web-backed query.

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?

Four terse sentences, front-loaded with purpose, then output shape, then cost. The opening fragment "Google AI Mode." largely repeats the title, but everything else earns its place.

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

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

With nine parameters fully documented in the schema and no output schema, the description's brief note on returned fields (text_blocks, references, shopping_results) fills the main structural gap. What remains missing is the positioning against sibling search tools, which matters given the density of alternatives.

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

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

Schema description coverage is 100% and all nine parameters carry their own explanations, including the uule/location mutual exclusion and the cr/lr delimiter syntax. The description adds no parameter meaning beyond the schema, so the baseline 3 applies.

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

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

"Query Google AI Mode via API" gives a specific verb and a named branded resource, so an agent knows this hits Google's AI Mode endpoint. It never says how that differs from sibling google_search or google_search_light, so differentiation rests entirely on the product name.

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

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

There is no when-to-use guidance: nothing explains when AI Mode is preferable to google_search, google_search_light, or duckduckgo_search, and no exclusions are stated. The only selection signal an agent gets is the 3-credit cost, which is presented without any comparison to cheaper 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?

Annotations already declare readOnlyHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds the useful commercial detail of 1 credit per call, but says nothing about the shape of the result (a list of suggestion strings) or whether localization params affect cost.

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

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

Two short sentences, front-loaded with the purpose, then the cost. The opening sentence merely restates the title verbatim, which is mild waste, but nothing else is extraneous.

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 an 8-parameter read tool with no output schema, the description covers purpose and cost but not the returned value's structure or how the suggestion list relates to cp/cr/lr. An agent can call it correctly from the schema alone, but the description leaves gaps a richer definition would fill.

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 all 8 parameters (cp, cr, gl, hl, lr, fields, google_domain) are documented in the schema itself. The description adds no additional parameter meaning, so the baseline 3 applies.

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

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

The description uses a specific verb and resource ('Get Google Search autocomplete suggestions') tied to a given query, which is clearly distinct from full-search siblings like google_search or google_search_light. It does not explicitly name or contrast those siblings, keeping it short of a 5.

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

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

The autocomplete framing implies the use case (query expansion / prefix suggestion lookup), and the credit cost line hints at the tradeoff versus other search tools. However, there is no explicit when-to-use / when-not-to-use guidance and no named alternative among the many search 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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so safety is covered by structured data. The description adds genuinely new context: the 1-credit-per-call cost and the fact that results are organic only. It omits rate limits, result volume/pagination behavior, and whether errors still consume credits.

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

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

Two compact sentences, front-loaded with the identity and followed by differentiators and cost. Slight redundancy in restating the title verbatim, but no filler and nothing buried.

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 7-parameter read tool with rich schema coverage and full annotations, most requirements are met elsewhere. The gap is that no output schema exists and the description never indicates what a result record contains, which matters because the `fields` parameter asks the agent to project specific nested fields.

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

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

Schema description coverage is 100%, so every one of the 7 parameters is already documented with examples (country codes, lang_ delimiters, dot-notation for fields). The description adds no parameter-level meaning beyond the schema, which is the expected baseline when the schema does the work.

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 a specific verb and resource ("Scrape lightweight Google Search results via API") plus a scope qualifier ("organic results only"). It distinguishes itself from generic search by being fast/cost-efficient, but never names the sibling google_search or google_search_ai it is meant to be chosen over, so the differentiation is implicit rather than 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?

'Fast, cost-efficient, organic results only' implies the usage context (cheap, high-volume, non-paid results) and the credit cost tells the agent the budget impact. However, there is no explicit when-to-use versus the many sibling search tools listed, and no stated preconditions or exclusions.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so safety is covered. The description adds genuinely useful economic context ('Credit cost: 1 credit per call') and confirms results come from an external API, but says nothing about result volume, pagination limits, or failure 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?

Three short sentences, front-loaded with the resource name and immediately followed by the operation and output shape; the cost note is a useful trailing tag. The opening 'Google Shopping.' merely restates the title and title annotation, so it is near-redundant but harmless.

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

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

With no output schema, the description does the work of stating what comes back (prices, ratings, merchant data), and the credit cost covers the main non-obvious operational concern. Pagination semantics and typical result counts remain unstated, which is a modest gap for an 11-parameter tool whose schema is otherwise fully documented.

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

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

Schema coverage is 100% with all 11 parameters individually documented, including gl, hl, cr, lr, uule, location, fields, and page. The description adds no parameter-level meaning beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Scrape Google Shopping results') plus the payload shape ('structured product listings with prices, ratings, and merchant data'). That makes it clearly a product-listing search, distinguishable from generic siblings like google_search or google_images, though no sibling is named explicitly.

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

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

There is no when-to-use guidance, no indication of when a plain google_search would suffice, and no mention of the pagination or query-scoping conditions under which this tool is appropriate. Usage must be inferred entirely from the phrase 'Google Shopping'.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description's most valuable addition is the explicit cost model ('1 credit per call'), which is real behavioral context absent from annotations. It stops short of disclosing pagination limits, result caps, or what 'metadata' actually contains, which matters for a 12-parameter search tool with no output schema.

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

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

Three short sentences, front-loaded with the tool name and purpose, then the return shape, then the cost. Nothing is redundant, though the first sentence ('Google Videos.') merely restates the title and could be merged.

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 annotations covering safety and the schema covering all parameters, the main missing pieces are sibling selection guidance and any sense of return volume or pagination limits. The credit-cost note partially compensates, but for a 12-parameter, open-world search tool the description is only minimally adequate.

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

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

Schema description coverage is 100%, so every one of the 12 parameters (cr, gl, hl, lr, num, page, safe, uule, query, fields, location, google_domain) is already documented in the schema. The description adds no parameter meaning whatsoever, so the baseline of 3 applies rather than anything higher.

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 Google Videos via API and retrieve structured video results with metadata'), which clearly distinguishes it from generic web search siblings like google_search or search. However, it does not explicitly differentiate itself from the near-neighbor brave_videos, leaving the agent to infer the provider distinction from the name alone.

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 brave_videos, yahoo_search, or google_search, and no stated preconditions or exclusions. The only usage signal is implicit in the tool name and the word 'Search', so the agent must infer selection from sibling names.

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

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

Annotations already cover the safety profile (readOnly, openWorld, non-destructive), and the description adds real behavioral context beyond them: engine fallback order, default gl=us/hl=en, the absence of a page parameter, and a concrete cost of 1 credit per call. That credit cost is exactly the kind of fact an agent cannot get from annotations or schema.

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

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

Sentences are dense and mostly front-loaded, but the opening 'Search.' is a wasted tautology and the text is cut off mid-sentence ('the response is always pag…'), leaving an incomplete clause that reads as broken rather than concise.

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

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

With no output schema, the description carries the burden of explaining results and does address engine fallback, locale defaults, and cost. However, the truncation kills the pagination explanation right after asserting there is no page parameter, leaving the agent without the critical answer of how to get more results.

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

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

Schema description coverage is 100%, so gl, hl, engines, fields and query are already fully documented in the input schema. The description largely restates the gl/hl defaults and the auto engine order that the schema already provides, adding no new syntax or constraints.

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

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

The description states a concrete behavior: a single call walks engines in order and returns the first organic results, which distinguishes it from engine-specific siblings like google_search or bing_search. The lead sentence is just 'Search.' and no sibling is named explicitly, so differentiation is implied rather than stated.

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 explains the default routing (engines=auto tries Google, then Brave, Bing, DuckDuckGo, Yahoo, Baidu), which implies when to leave the default alone and when to pass an explicit engine list. It gives no explicit when-to-use/when-not guidance versus the many sibling search tools, nor any prerequisites.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds genuinely new behavior: a fixed one-hour lookback window, cross-tenant/cross-account data scope, and an account-level enablement gate that surfaces as HTTP 403 — all things the agent cannot infer from the annotations.

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

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

Three compact sentences, front-loaded with the resource and scope before the caveats. The opening "Stats." is pure redundancy with the title and could be cut, but nothing else is padded.

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 read-only, two-optional-parameter tool this covers scope, time window, and the activation failure mode well. However, with no output schema, the description never hints at what metrics come back (latency, error rate, uptime), leaving the agent unable to judge whether the response answers its question.

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 parameters are already fully documented including the engine/path pairing rule and an example path. The description only reinforces that the tool targets "an engine or endpoint" without adding syntax, defaults, or precedence rules beyond the schema, so the baseline 3 applies.

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

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

"Infrastructure health for an engine or endpoint over the last hour" names a specific resource (health metrics), a target dimension (engine or endpoint), and a time window, which distinguishes it from the search-oriented siblings. The leading "Stats." merely restates the title and adds nothing, keeping it short of a 5.

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

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

The line "Not scoped to your account or tenant" implicitly routes account-level questions to the sibling `usage` tool and tells the agent this is system-wide telemetry. It also gives concrete operational guidance for the 403 case, though it never states the positive trigger (e.g. diagnosing errors or latency) or names an alternative explicitly.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds that the figures are real-time and that a credit balance is included, but says nothing about response shape, units, or freshness semantics beyond the word 'real-time'.

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

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

Two short sentences, front-loaded with the resource and its scope. The leading 'Usage.' fragment merely restates the tool name and title, which is the only wasted element.

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 parameterless, read-only lookup with no output schema, the description gives enough to call it correctly and anticipate the kind of data returned. The lack of any detail on the statistics' fields is a minor gap 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?

The tool takes zero parameters, so the baseline is 4; there is no parameter meaning for the description to carry. The description correctly does not invent any inputs.

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

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

States a specific verb ('Retrieve') and concrete resources ('real-time usage statistics and credit balance for your Autom account'), so the agent knows exactly what data comes back. It does not distinguish itself from the sibling tool 'stats', which plausibly overlaps in purpose.

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

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

The purpose implies when to call it (checking consumption/quota), but there is no explicit guidance and no mention of when to prefer the sibling 'stats' tool instead. Usage is inferable rather than stated.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds genuinely new context: organic-results-only output and a per-call credit cost the annotations do not convey. It stops short of describing result volume or pagination limits, so it is useful 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?

Three short sentences with the core capability first and the cost note last, so nothing buries the lede. The opening 'Yahoo Search.' largely duplicates the title, which is the only wasted fragment.

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 five parameters, no output schema and full schema coverage, the essentials are covered, but an agent still lacks details on how many results a page returns and whether deep paging is capped. The credit cost note partly compensates for the missing output shape.

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

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

Schema description coverage is 100%, with gl, hl, page, query and fields all documented including the fields projection. The description only alludes to country and language, restating what the schema already says, so the baseline 3 applies.

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

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

Uses a specific verb ('Query') plus the named resource ('Yahoo') and states the outcome ('structured organic results with country and language'). The engine name alone separates it from google_search, bing_search, brave_search and duckduckgo_search siblings, though the description never explicitly frames that choice.

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

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

No when-to-use or when-not-to-use guidance and no mention of alternatives among the many other search tools. The only supplementary information is a cost note ('1 credit per call'), which is pricing, not selection guidance.

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