Searchapi

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

Annotations already provide readOnlyHint=true and destructiveHint=false. The description adds that the tool returns titles, sources, thumbnails, and publication dates, which is useful behavioral context beyond the annotations. It does not mention pagination behavior or rate limits, but the read-only nature is covered.

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 three sentences with no fluff. It front-loads the core purpose, then lists return fields, and gives a brief usage hint. 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?

Given there is no output schema, the description partially describes the return structure (titles, sources, thumbnails, dates) but not the exact shape. The parameter schema is comprehensive, covering market codes, time periods, etc. The description is adequate for a simple read-only search tool, though it could be slightly more explicit about the result format.

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

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

Schema description coverage is 100%, so all parameters (q, page, sort_by, market_code, time_period) are documented in the schema. The description adds no parameter-specific details beyond the schema, aligning with the baseline of 3 for full coverage.

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

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

The description clearly states the verb ('Search') and resource ('news articles using Bing News'), and specifies what is returned. It is distinctly a news-specific search, differentiating it from sibling tools like bing_search (general web search) and the google_* search variants.

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

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

The description gives a usage context ('Good for finding recent news coverage and trending stories') but does not explicitly name alternatives or conditions for when not to use it. It implies the use case but does not mention bing_search as a fallback for general web queries.

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?

Read-only and non-destructive behavior is already covered by annotations, so the description adds limited new behavioral detail. It does indicate that the output includes organic results and related searches, which is useful but minimal.

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-load the core action immediatelyadian and mention the key differentiator. No filler or repetition of schema fields.

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 search tool with 100% schema coverage and strong annotations, the description sufficiently conveys purpose, output type, and sibling differentiation. It could be slightly more explicit about return shape, but the absence of an output schema and the simple nature of the tool make the current description 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 all four parameters are already documented. The description adds no additional parameter-specific meaning beyond confirming the general purpose of 'q'.

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

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

The description names a specific action and resource ('Search the web using Bing') and explicitly contrasts itself with Google, distinguishing it from sibling search tools like google_scholar or google_images_light.

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?

Clear context is provided: this is a web search tool using Bing and is an alternative to Google. It does not explicitly enumerate exclusions or state precisely when to prefer it over other sibling tools, but the 'different ranking algorithms and results' note gives useful selection 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds that it returns organic results, which is a useful behavioral trait beyond annotations. It does not discuss pagination, result count, or any quirks, but the annotation coverage lowers the burden. No contradiction with annotations.

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

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

The description is two concise sentences with zero wasted words. The core purpose is front-loaded, and the privacy differentiation follows immediately. 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 search tool with fully documented parameters, the description adequately states what it does and the nature of results (organic). Given there is no output schema, it could mention more about the return format or any 'light' limitations, but it is sufficient for an agent to decide whether to call it. Slightly more detail on output would push it to 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?

Schema description coverage is 100%, so all three parameters (q, locale, time_period) are fully documented in the schema itself. The description adds no additional parameter-specific 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?

States a specific verb and resource: 'Search the web using DuckDuckGo' and notes 'Returns organic results.' It differentiates from Google by calling itself a 'Privacy-focused alternative to Google,' which helps distinguish it from google_search_light. However, it does not explicitly differentiate from other search engines like bing_search, so it falls short of a perfect score.

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

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

The description provides clear context by positioning the tool as a privacy-focused alternative to Google, implying it should be used when privacy or unbiased results matter. It does not explicitly state when not to use it or list alternative tools, but the privacy angle is a meaningful usage signal for an agent.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context beyond annotations: it discloses that the tool resolves mobile share links and canonicalizes URLs automatically, and that it returns public information only. It doesn't mention rate limits or pagination, but for a read-only fetch tool the key behaviors are disclosed.

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

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

The description is two sentences: the first states the core function and return data, the second gives the parameter selection rule. Every sentence earns its place, and the most important operational guidance (prefer url) is front-loaded in the second sentence. No filler or redundancy.

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

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

For a read-only tool with 3 optional parameters, 100% schema coverage, and no output schema, the description covers the essential context: what it fetches, what it returns, and how to choose parameters. The only minor gap is that it doesn't explicitly state what happens if multiple parameters are provided or if none are provided, though 'exactly one' implies the constraint. Overall it's complete enough for an agent to invoke 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 all three parameters thoroughly. The description adds value by prioritizing url over the others and explaining the resolution behavior, which complements the schema's per-parameter descriptions. It doesn't add much beyond the schema, but the baseline of 3 is exceeded by the explicit preference rule and the 'exactly one' constraint.

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 ('Fetch') and resource ('public business page information from Facebook'), and enumerates the exact data returned (name, category, address, phone, website, ratings, reviews, followers, photos). It clearly distinguishes itself from sibling tools like instagram_profile and tiktok_profile by focusing on Facebook business pages.

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 selection guidance: 'Provide exactly one of page_id, username, or url — prefer url when the user pasted any Facebook link (including mobile share links), since the tool resolves the canonical page automatically.' This tells the agent when to use each parameter and why url is preferred, which is actionable routing guidance.

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

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

The annotations already establish readOnlyHint, openWorldHint, and destructiveHint false, so the description does not need to restate safety. It adds value by disclosing that output includes citations and reference links and that image analysis is a distinct behavior requiring a public URL.

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

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

The description is short, front-loaded with the high-level purpose, and formats the two call modes with minimal prose. Every sentence contributes usable information with no filler.

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

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

For a tool with only three string parameters, full schema coverage, no nested objects, and no output schema, the description covers the key behavioral differences between text and image calls. The annotation cluster handles safety, and the description confirms the output expectation of citations and links.

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 description mostly restates the conditional requirements already present in the schema (q vs url). The 'text search' and 'image analysis' framing helps organize the parameters, but it does not add new meaning about location, constraints, or output interpretation beyond what the schema already provides.

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 action and resource: 'Get Google's AI-generated responses (AI Overviews) with source citations and reference links.' This clearly distinguishes it from sibling search tools like google_search_light or google_images_light, which do not provide AI Overviews.

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 two calling modes are explicitly laid out with their parameter requirements: text search requires q, and image analysis requires url with optional q. This gives clear operating context, though it does not explicitly name alternatives or exclusion cases relative to sibling tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds behavioral context beyond annotations by stating that it returns a price-per-day list and that it shows the cheapest price. It doesn't mention potential quirks like date range limits or response format details, but given the strong annotation coverage and the clear scope, this is sufficient.

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

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

Two sentences with zero fluff. The core action and return are front-loaded in the first sentence; the sibling differentiator occupies the second. 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 tool has 18 parameters, 3 required, no output schema, and moderate complexity, the description provides sufficient high-level context: what it returns (list of dates with prices), when to use it, and how it differs from the round-trip sibling. For a read-only calendar lookup, this is complete enough for an agent to invoke it without misunderstanding.

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 fully documents all parameters and their defaults. The description adds no parameter-level semantics beyond what the schema already provides (e.g., outbound_date's role as the start date). Baseline 3 applies because structured data carries the 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 states a specific verb ('Get a price calendar') with a precise resource ('cheapest one-way flight price for each day'). It clearly distinguishes itself from the sibling google_flights_calendar_round_trip by naming it explicitly. An agent can identify this tool's unique purpose without opening the schema.

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 an explicit use case: 'useful for finding the cheapest departure day when you have flexible travel dates.' It also explicitly names the round-trip alternative and the condition for choosing it ('For round-trip price calendars... use google_flights_calendar_round_trip instead'). No inference is required.

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

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

Annotations already indicate read-only and open-world, so the description doesn't need to repeat that. The description adds that it returns a grid of date pairs, which is useful. It doesn't disclose details like rate limits, but the open-world hint covers some of 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 two sentences, front-loaded with the core purpose and includes a clear pointer to the sibling tool. No wasted words.

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

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

Given the complexity (19 params, 2 enums, no output schema), the description doesn't explain the return structure in detail, but it's not critical since the tool is read-only. It provides the key context: flexible date ranges and the grid output. Could mention that the calendar expands on the dates provided, but that's already in the schema.

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

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

Schema description coverage is 100%, so all parameters are well-documented. The description itself doesn't add much beyond what the schema already provides. The baseline is 3, and there's no additional meaning added.

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

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

The description clearly states it provides a price calendar for round-trip flights, specifically a grid of date pairs with prices. It distinguishes itself by mentioning the one-way 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?

It explicitly states when to use it (when both departure and return dates are flexible) and names the one-way tool as an alternative. It doesn't explicitly mention other flight tools like google_flights_round_trip, but the context is 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the tool's safety profile is covered. The description adds behavioral context beyond annotations: it explains that for cities it 'searches all airports in that city' and returns kgmid, which is not in the schema. It also discloses the output format. This enriches the behavioral picture, though it could mention potential multiple results or no-match scenarios.

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 with a bulleted list of return types, a clear required-parameter note, and a usage tip. It is concise, front-loads the purpose, and every sentence adds value. The note about common IATA codes is a useful addition without bloating the 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?

With no output schema, the description must explain return formats, which it does (IATA and kgmid). It also clarifies the required parameter and provides a usage example. For a simple two-parameter search tool, this is largely complete, though it doesn't cover edge cases like multiple matches or empty results. The overall complexity is low, so this is sufficient.

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

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

The schema description coverage is 100%, so both parameters (q and search_type) are already documented in the input schema. The description adds an example for q and clarifies the output behavior for cities, but these are largely redundant with the schema descriptions. The note about common IATA codes is a usage guideline rather than parameter semantics, so the description adds marginal value beyond the schema.

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

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

The description clearly states the tool searches for airports and cities to return identifiers for Google Flights tools. It specifies the exact outputs (IATA codes for airports, kgmid for cities) and gives concrete examples, making its purpose unmistakable and distinct from the sibling flight tools that consume these identifiers.

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

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

The description explicitly says when to use the tool: 'when you have a city name like 'New York' or 'Paris' and need to convert it to codes that the flight tools accept.' It also provides an exclusion by noting that common IATA codes like JFK can be used directly without this tool, giving clear guidance on alternatives.

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

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

Annotations already signal read-only, open-world, and non-destructive behavior. The description adds useful behavioral context beyond annotations by explaining the two-step search-then-booking-details flow and the requirement to preserve all original options on token follow-ups. It does not cover output shape or rate limits, but annotations carry the safety profile.

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

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

The description is compact and front-loaded, with a terse purpose sentence followed by clearly formatted workflow and routing notes. Every sentence earns its place and the structure makes the critical follow-up behavior immediately visible.

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 20-parameter search tool with no output schema, the description plus the detailed input schema covers the essential workflow, required fields, follow-up behavior, and sibling routing. It does not describe the result payload structure, but the first sentence identifies the main result categories and annotations cover side-effect safety.

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 coverage is 100%, so the baseline is 3. The description adds value by specifying that departure_id, arrival_id, and outbound_date are required on every call including token follow-ups, and by instructing the agent to preserve all original search options. It does not need to restate individual parameter semantics since the schema already documents them thoroughly.

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 ('Search') on a specific resource ('one-way Google Flights') and the general contents of results ('airline, time, price, and booking details'). It also distinguishes itself from the round-trip and calendar-one-way sibling tools at the end.

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 gives a clear workflow: first search, then repeat arguments with a booking_token to retrieve booking details, and it emphasizes that required parameters apply on every call. It names round-trip and calendar alternatives, though it does not provide explicit when-not-to-use exclusions or conditions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds valuable behavioral context: the multi-step token-based workflow and the instruction to preserve all original search options. It does not disclose error conditions or response format, but given the annotations, this is acceptable.

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: a concise purpose sentence, a bolded requirement line, a numbered workflow, and a final alternatives line. It is front-loaded with essential information and contains no filler. 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 complex tool with 22 parameters and a multi-step workflow, the description covers the required inputs, the token usage, and the routing to sibling tools. It does not explain output format, but that is not necessary given no output schema. The description 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 every parameter is documented. The description adds meaning by highlighting the required parameters for every call and explaining the roles of departure_token and booking_token in the workflow. It also emphasizes preserving options, which goes beyond the schema.

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

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

The description states a specific verb ('Search'), resource ('round-trip Google Flights'), and what it returns ('airline, time, price, and booking details'). It also explicitly names sibling alternatives (one-way, calendar) to differentiate itself. This clearly distinguishes it from related tools.

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

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

The description includes a numbered workflow (search outbound, then return, then booking) and explicitly names alternatives: 'One-way: google_flights_one_way. Flexible dates: google_flights_calendar_round_trip.' This gives clear when-to-use guidance and exclusions.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety and external-data aspects. The description adds the scope (worldwide) and the requirement of date parameters, but does not disclose any additional behavioral nuances (e.g., pagination via next_page_token or result variability). Since annotations carry the main burden, a 3 is appropriate.

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

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

The description is extremely concise: two sentences plus a compact list of required fields and two usage tips. It front-loads the primary purpose and avoids fluff, earning its place with no waste.

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 20 parameters and no output schema, the description effectively highlights the essentials (required params and key tips) while relying on the comprehensive schema for the rest. It lacks a full example of a typical call, but the schema plus description covers what an agent needs to make a valid request. A 4 reflects a near-complete guidance.

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

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

Schema coverage is 100%, so all parameters are documented. The description adds a few usage pointers (sort_by='lowest_price', children_ages format) that reinforce but do not extend beyond the schema's own descriptions. Baseline 3 applies when schema is complete and the description adds only marginal clarification.

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

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

The description clearly states a specific action ('Search for hotels') and a specific resource ('Google Hotels'), and specifies what it provides (pricing, ratings, amenities, availability). It distinguishes itself from sibling search tools like google_flights_* or google_maps_search by being explicitly about traditional hotel accommodations worldwide.

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 lists the required parameters (q, check_in_date, check_out_date) and provides a practical hint for using sort_by='lowest_price' and formatting children_ages. However, it does not explicitly compare to alternatives like google_vacation_rentals or state when not to use this tool, though the hotel-specific focus makes the context 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?

Annotations already indicate this is read-only and non-destructive. The description adds detail about what it returns (thumbnails, source pages, original URLs), which is useful. However, it does not mention rate limits, pagination behavior, or the meaning of the 'light' variant in the name, so it provides only moderate extra context beyond the annotations.

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

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

The description is two sentences and every piece of information earns its place: the search intent, the output, and the use case. No filler or repetition, front-loaded with the main action.

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 search tool with 7 parameters and a fully described schema, the description covers the purpose, output shape, and typical use. The only real gap is the unspecified 'light' naming and any limitations it might imply, which could matter for an agent deciding between multiple search tools. It still feels sufficiently complete for routine 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 100%, so the baseline is 3. The description does not delve into any parameter semantics beyond saying 'Search Google Images,' which aligns with the `q` parameter. It adds no new information about `gl`, `size`, `color`, etc., relying entirely on the schema.

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

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

The description clearly states the verb+resource: 'Search Google Images for photos and visual content.' It explicitly differentiates from sibling tools like google_search_light and bing_search by focusing on image search. The return format (thumbnails, source pages, original URLs) makes it unambiguous.

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

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

The phrase 'Useful for finding reference images, illustrations, and visual content' provides clear context for when to use this tool. It implies it is the right choice for visual search but does not explicitly compare with alternatives or give negative exclusions, so it falls short of a 5.

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

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

Annotations already establish read-only and non-destructive behavior, so the description only needs to add useful context. It adds that results are aggregated from multiple job boards and lists returned fields, but it does not disclose pagination behavior or variable result availability. This is acceptable for a safe read-only search but the behavioral disclosure is modest.

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 gives the purpose and output fields without any filler or repetition. It is appropriately sized for a search tool with a well-documented 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?

With no output schema, the description supplies the main return contract (titles, companies, locations, descriptions, apply links). Parameter semantics are fully covered by the schema, including pagination via next_page_token, leaving only minor gaps such as result-count or error behavior.

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

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

The schema covers all seven parameters with descriptions, so the parameter burden is already fully met. The tool description adds no parameter-specific semantics beyond the schema, which is fine given the 100% coverage 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?

States a specific verb-resource pair ('Search for job listings on Google Jobs') and enumerates the returned data (titles, company names, locations, descriptions, apply links). The vertical scope clearly separates it from generic siblings like bing_search, google_search_light, and other vertical search tools.

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

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

The description gives a clear usage context: use it when job listings are needed, and it is explicitly scoped to Google Jobs and aggregated boards. It does not name an alternative or provide an explicit when-not, so it falls just short of full 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 establish the safe read-only, open-world, non-destructive profile. The description adds the URL requirement and the kinds of results returned, which is useful. However, it does not disclose rate limits, auth needs, or result variability, and with idempotentHint=false, the description could clarify why results differ between calls. No contradiction with annotations.

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

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

Two tight sentences with the core capability front-loaded and zero filler. Every clause earns its place, and the capabilities list precedes the refinement detail. Appropriate size for the tool's complexity.

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?

No output schema exists, so the description carries some return-format responsibility. It covers what the tool does and the main capabilities, but omits exact_matches from the search types and does not specify the expected URL format. For a read-only tool with strong annotations, it is reasonably complete yet has the notable enum gap.

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

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

Schema coverage is 100%, so baseline is 3. The description adds helpful meaning for search_type and the text query, but it lists only 'all, visual_matches, and products' and omits 'exact_matches' — a valid enum value in the schema. This incomplete list actively detracts from what the schema already provides and could prevent an agent from using exact match detection.

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?

Specific verb ('Analyze images using Google Lens') plus a concrete resource and a clear list of outputs (visual matches, product identification, text extraction, exact match detection). This clearly distinguishes it from the many text-search siblings like google_search_light and google_images_light, since it is the only image-recognition 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 use case is implied ('Upload an image URL') and the refined search types give context, but there is no explicit when-to-use vs. alternatives, nor any exclusions. An agent must infer it is the right tool for image analysis rather than being told to prefer it over, say, google_images_light.

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

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

The description communicates a read-only operation consistent with the readOnlyHint, and it adds useful behavioral detail about the returned information (address, phone, hours, popular times). It does not mention failure modes or what happens if neither ID is valid, but the key behavior is well conveyed.

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 deliver purpose, prerequisite, and expected output with no redundancy or filler.

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

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

The description is sufficient for an agent to know when to call the toolestrategies: after a google_maps_search request, using one of the returned IDs `data_id` or `place_id`. It provides enough return information despite having no output schema, but it could be slightly more explicit about what happens when neither ID is supplied.

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

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

Schema coverage is 100%, and the description reinforces the dependency on google_maps_search IDs. However, it does not add significant meaning beyond the schema's own parameter descriptions, and the gl parameter's role is only covered by the schema.

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

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

The description clearly states the verb ('Get') and resource ('detailed information about a specific place'), and it distinguishes this tool from google_maps_search by requiring an ID from search results. This makes the tool's purpose and scope immediately clear.

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

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

The description explains the required precondition: a data_id or place_id obtained from google_maps_search. It clearly indicates when this tool should be used, though it does not explicitly name which sibling tools should be used instead when search results are not yet available.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds that results include names, addresses, ratings, reviews, and contact info, which is useful but not deep behavioral context (e.g., pagination behavior, rate limits). With annotations providing the safety profile, this is adequate but not exceptional.

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

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

Two concise sentences with zero filler. The purpose is front-loaded, and the follow-up guidance is placed at the end. 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 search tool with no output schema, the description covers the purpose, return fields, and the natural next step. It doesn't mention pagination behavior, but the schema documents the page parameter. Overall, an agent has enough to invoke it correctly and know what to do with 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% for all 3 parameters, so the schema already explains q, gl, and page. The description adds no additional parameter semantics beyond what the schema provides, 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 clearly states the verb 'Search' and the resource 'local businesses and places on Google Maps', distinguishing it from general web search and the sibling google_maps_place which is for detailed place info. It lists the return fields (names, addresses, ratings, reviews, contact info), making the purpose unambiguous.

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

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

It explicitly directs the agent to use google_maps_place with data_id or place_id from results for detailed place information, which is a clear when-to-use-next guidance. However, it doesn't explicitly contrast with other search tools like google_search_light for general web queries, so it's slightly incomplete but still useful.

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

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

The description adds value beyond the annotations by specifying the exact fields returned (titles, IDs, inventors, assignees, filing dates, abstracts). It does not contradict the readOnlyHint or openWorldHint, and it provides useful context about output without delving into rate limits or pagination, which is acceptable given the annotations.

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

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

The description is a single, front-loaded sentence that immediately states the action and resource, then lists the return fields with no filler. Every word contributes to understanding the tool's purpose and output.

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 search tool with fully documented parameters and annotations covering safety, the description is sufficient. It explains what the tool returns and the domain, and the schema covers parameter usage. It does not mention potential pagination or result limits, but these are not critical for a simple search tool.

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

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

Schema description coverage is 100%, so all eight parameters are already documented in the input schema. The description does not add any additional meaning or examples for parameters beyond what the schema provides, so it does not go above the baseline 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 states a specific verb ('Search'), a specific resource ('Google Patents'), and the scope ('patent documents and scholarly articles'). It also lists the return fields (titles, IDs, inventors, assignees, filing dates, abstracts), distinguishing it from general web search tools like google_search_light and from google_scholar by the patent focus.

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 patent searches and scholarly articles but does not explicitly compare to sibling tools like google_scholar or explain when to choose this over them. No exclusions or alternative recommendations are provided, so the guidance is only implied by the resource 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?

The description adds useful behavioral detail beyond the readOnlyHint annotation by specifying what the response contains: offers from multiple sellers, specifications, reviews, and pricing history. It also discloses the token dependency. It does not cover error cases or rate limits, but for a read-only lookup tool the key behavior is communicated.

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 three sentences with no filler. It front-loads the main purpose, then gives the prerequisite and the key return contents. 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 read-only tool with one required parameter and no output schema, the description is complete: it explains what the tool does, how to get the required token, and what the response will contain. The annotations cover safety, and the schema covers parameters, so 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?

Schema description coverage is 100%, so the parameters are already well documented. The description reinforces that product_token comes from google_shopping_search results, matching the schema, but adds no new semantic details for gl or location beyond what the schema already provides.

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: 'Get detailed product information from Google Shopping.' It clearly differentiates itself from the sibling google_shopping_search by requiring a product_token from that search, so an agent can understand this tool as the detail-fetching follow-up rather than a search 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 description explicitly states the prerequisite: the tool requires a product_token obtained from google_shopping_search results. This tells the agent when it is appropriate to call the tool, though it does not explicitly name alternative tools or state when not to use it.

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

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

The annotations already establish it as read-only and non-destructive, so the description only needs to add extra behavioral context. It does add output shape and result-count, yet it does not mention rate limits, pagination trade-offs, or how location and geolocation parameters affect rankings. This is adequate but not deeply 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 only two sentences, front-loads the action and resource, and adds only relevant output/use-case details. It is concise without sacrificing clarity.

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

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

For a read-only search tool with full schema coverage, the description provides enough to understand what results look like and why to use the tool. It could expand on practical quirks like location-based differences or pagination behavior, but those are mostly inferable from the schema and the tool's stated 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 description does not need to document every parameter. The one added semantic is that results include position/title/URL/snippet, which helps understand what the output means, but it does not enrich understanding of any individual parameter. 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 clearly says 'Get Google organic search results for SEO rank tracking' and lists returned fields (position, title, URL, snippet), which makes the tool's purpose specific. It does not explicitly compare to sibling tools such as google_search_light, but the SEO/rank-tracking framing differentiates it enough.

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 offers a clear use case ('Ideal for monitoring keyword rankings and SERP analysis') but never names alternatives or explicitly states when not to use it. The intended context is clear, though exclusion guidance and sibling pointers are missing.

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 and openWorldHint, so the safety profile is known. The description adds useful behavioral context by listing returned fields (titles, authors, publication info, citation counts, PDF links) and clarifying the cites/cluster modes, which goes beyond the annotations without contradicting them.

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

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

Three succinct sentences with no filler. The core purpose comes first, return content is stated next, and the cites/cluster/case-law guidance is packed into the final sentence 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 read-only search tool with 100% schema coverage and open-world annotations, the description is largely complete. It names the output fields and points to the correct alternative for case law; the only minor gap is that it does not describe pagination behavior, but num/page are already fully documented in the schema.

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

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

Schema description coverage is 100%, so the schema already documents all 7 parameters. The description mentions cites and cluster at a high level, but doesn't add meaningful parameter semantics beyond the schema descriptions; this is the expected baseline 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?

Description specifies a clear action (Search Google Scholar), a precise resource (academic papers, citations, scholarly articles), and differentiates from the sibling google_scholar_cases. It also distinguishes this tool's scholarly focus from patent and news-oriented 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?

Provides explicit guidance for special modes: 'Use cites parameter to find papers citing a specific work, or cluster to find all versions of a paper.' It also names an alternative tool for court opinions and case law, telling the agent exactly when not to use this tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so no need to repeat. The description adds value by specifying return contents (organic results, related searches, pagination) and the 'fast' nature, which are not covered by annotations. No contradictions.

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

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

Two sentences with zero fluff. Purpose, return summary, and usage condition are front-loaded and each sentence earns its place. Perfectly concise for the information conveyed.

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 search tool with full schema coverage and no output schema, the description gives a high-level return summary and usage context. It does not detail the output structure, but given the simplicity and annotations covering safety, it is sufficiently complete. Could mention rate limits or output format, but not critical.

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

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

Schema coverage is 100%, so all parameters are already documented in the input schema. The description only reinforces the requirement for 'q' and does not add extra semantic meaning beyond what the schema provides. 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?

States a specific verb+resource ('Perform fast Google web searches') and clarifies what is returned (organic results, related searches, pagination). The name 'light' and mention of 'advanced filtering not needed' help differentiate from more specialized search siblings like google_scholar or google_images_light, even without naming them 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?

Provides a clear usage condition: 'Suitable for quick information retrieval when advanced filtering is not needed.' This implies when to use it, but it does not explicitly name alternatives or exclusions. It also notes the required parameter, adding practical guidance. Slightly better than average but lacks explicit routing to 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 flag this as read-only and open-world; the description adds observable behavior: it returns listing-level pricing, seller, rating, and comparison data)Skip and indicates a follow-up path. No hidden side effects or destructive behavior need 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?

Three short front-loaded sentences cover scope, return type, and next step, with no repetition of schema content or filler.

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

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

For a tool with eight parameters and no output schema, the description provides adequate return-shape and follow-up guidance. Minor details like pagination behavior or regional result variations are left to the schema, which covers the parameter side.

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

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

The input schema already documents all parameter meanings fully (100% coverage), so the description adds no new parameter-level semantics. The product_token pointer is useful but not a parameter of this tool.

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 a specific verb + resource ('Search for products on Google Shopping'), states exactly what is returned (prices, sellers, ratings, comparison shopping data), and explicitly routes follow-up work to google_product with product_token.

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 gives clear context for using this tool and tells the agent when to switch to google_product for detailed results. It does not explicitly contrast with every sibling search tool, but the product-shopping scope is unambiguous enough.

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

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

The description's 'Search' and 'Provides pricing, ratings, amenities, and availability' align with annotations readOnlyHint=true and destructiveHint=false. It adds some behavioral context about the kind of results returned, but it does not disclose pagination behavior, data freshness, Google Hotels inventory caveats, or any rate-limiting details. No contradiction with annotations.

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

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

The description is a single front-loaded sentence that states the action first and then lists relevant output aspects and property types. There is no filler, and the property examples earn their place by reinforcing the vacation-rental scope.

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

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

Given 100% schema coverage for all 16 parameters, the agent has what it needs to construct a correct call. The description also covers the main output dimensions: pricing, ratings, amenities, and availability. A small gap is that no output schema exists and the description does not mention pagination tokens, though the schema itself documents next_page_token.

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% across 16 parameters, so the baseline is 3. The description does not add parameter-level meaning, but it does not need to since every parameter already has a clear description in the schema.

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

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

The description uses a specific verb and resource: 'Search for vacation rentals using Google Hotels.' It further clarifies scope by listing property types like apartments, villas, cabins, and houses, which helps distinguish it from general hotel search. However, it never explicitly contrasts itself with the sibling tool google_hotels, so full sibling differentiation is left to inference.

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 context is implied: the description indicates this tool is for vacation rental searches, and the property-type list hints at when it would apply. There is no explicit guidance about when to use this tool versus google_hotels or other search tools, and no alternatives are named.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the fact that it fetches public information and that post IDs are shortcodes, but does not disclose edge cases (e.g., private profiles, rate limits) or behavioral traits beyond what annotations provide. It adds minimal value beyond the annotations.

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

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

The description is two concise sentences with no redundant wording. The primary purpose is front-loaded, and the cross-reference to instagram_post is a useful addition without bloat.

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

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

For a simple read-only tool with one parameter and no output schema, the description is largely complete: it lists returned fields and explains the shortcode relationship. It could mention that the profile must be public, but that is implied by 'public profile information' and the annotations. Minor gaps like error handling are not critical for this 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 the username parameter is fully documented in the schema. The description does not add any additional semantic meaning about the parameter beyond what the schema provides, maintaining the baseline 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 explicitly states the tool fetches public profile information from Instagram, lists the returned fields (bio, counts, posts, etc.), and clearly distinguishes the resource from the sibling tiktok_profile by naming the platform. It is a specific verb+resource with no 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 gives clear guidance on how to use the returned post IDs (pass to instagram_post) but does not explicitly state when to choose this tool over alternatives like tiktok_profile. It implies usage for Instagram profile data but lacks explicit exclusions or when-not-to-use conditions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value by specifying the exact return fields (bio, counts, verification, etc.), which is not in the annotations. It does not mention rate limits or authentication, but for a public read-only fetch, the added field list justifies a 4.

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

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

The description is a single, efficient sentence that front-loads the action and resource, then lists the returned fields. Every clause earns its place; there is no redundancy or filler.

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

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

For a simple one-parameter, read-only tool with complete schema documentation and no output schema, the description is sufficiently complete. It states exactly what data will be returned, and the annotations cover the operational safety. No critical information an agent needs to invoke it correctly 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 single parameter 'username' is fully documented in the schema with format ('with or without @') and requiredness. The description does not add any additional parameter semantics beyond what the schema already provides, 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 clearly states the action ('Fetch') and the resource ('public profile information from TikTok'), and enumerates the specific data returned (bio, counts, likes, video count, verification, links). It is distinct from siblings like instagram_profile by explicitly naming TikTok, so an agent can distinguish it without 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 usage is implied by the description: use it when you need TikTok profile data. However, it does not explicitly contrast with alternatives such as instagram_profile or mention conditions when this tool is not appropriate. No when-not guidance is provided, so it falls at the 'implied usage' level.

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