Dataify MCP

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

The description's 'submit a Builder task' matches the annotations (readOnlyHint=false, destructiveHint=true, idempotentHint=false), so no contradiction, and it adds the fixed collector identifier. However it does not elaborate on what the destructive write actually does (creates a task record), what authentication is required, or that execution is asynchronous, leaving most behavioral detail to the annotations alone.

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?

It is front-loaded and only two sentences, but the first sentence is padded with near-synonym keyword lists ('Airbnb房产信息、Airbnb房源信息、Airbnb房源搜索、Airbnb product、Airbnb homes') that repeat the same concept and add length without new meaning.

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

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

For a non-idempotent, destructive task-submission tool with no output schema, the description conveys the essential purpose but omits what the call returns (e.g., a task id) and how it relates to the task-status/result siblings (scraper_task_status, scraper_task_result), which the agent needs to complete the workflow.

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 fully documents country, file_name, and searchurl. The description adds only the fixed collector id tying searchurl to 'airbnb_product_by-searchurl', which is marginal value over the structured fields; 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 second sentence gives a specific verb+resource: '提交 Airbnb房产信息采集 Builder 任务' (submit an Airbnb property-collection Builder task) with a fixed collector id, which clearly distinguishes it from data-returning product siblings like zillow_product or amazon_product. The first sentence, however, is largely a keyword/trigger list rather than a statement of purpose, diluting the clarity.

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

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

It explicitly states trigger conditions ('当用户需要 Airbnb房产信息…与采集、抓取、爬取、获取、提取等动词组合时触发'), giving the agent a clear selection context. It names no alternatives or exclusions, so it stops short of the 5 tier, but the when-to-use guidance is concrete.

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=false, destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description adds almost nothing beyond them: it does not explain that this is an asynchronous job submission requiring later polling via scraper_task_status/scraper_task_result, nor what side effects or costs the destructive write entails.

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 first sentence is a long, repetitive keyword-stuffing block ('Amazon 全球产品详情、Amazon 全球商品详情、Amazon 全球产品信息、全球商品信息...') that duplicates concepts and buries the actual purpose. The useful statement about submitting a Builder task and the four modes is deferred to the second sentence instead of being front-loaded.

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

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

There is no output schema, and with 12 parameters and 4 operating modes this is a fairly complex tool. The description covers purpose and modes adequately and the schema carries all parameter detail, but it omits the async task workflow (submit here, then check scraper_task_status / scraper_task_result), which is the key context an agent needs to use the tool end-to-end.

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 per-parameter descriptions are rich (documenting which spider_id each param applies to, defaults, formats). The description adds no parameter-level meaning beyond what the schema already provides, 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 second sentence states a concrete verb+resource: submit an Amazon global product-detail collection Builder task, and enumerates the four supported spider modes (by-url, by-category-url, by-keywords, by-keywords-brand). It is clear what the tool does, but it never differentiates itself from the sibling amazon_product / amazon_product_list tools, so the 'global' scope is left for the agent to infer.

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 first sentence provides trigger conditions (product detail/info, URL, category URL, keyword search combined with verbs like collect/scrape/crawl/fetch), which is a form of when-to-use guidance. However, it is essentially a keyword-matching list with no exclusions and no mention of alternatives (e.g. when to prefer amazon_product or the scraper_task_* follow-ups), so usage is only implied rather than decided.

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 destructiveHint=true, readOnlyHint=false, openWorldHint=true and idempotentHint=false, so the agent knows this is a state-changing submission. The description adds that it submits a Builder task and reuses one tool for five modes, but says nothing about cost, rate limits, or what the submission produces beyond that. No contradiction with 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?

Two sentences, front-loading the trigger keywords before the actual function statement. The opening trigger-keyword list is heavily redundant and buries the concrete 'submits an Amazon product-detail Builder task' statement in second position.

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 12-parameter, mode-switching tool with no output schema, the description covers the enumeration of modes but does not explain the required spider_id-driven dispatch or how parameters couple to each mode. The 100%-covered input schema compensates substantially, so the description is adequate but not self-sufficient.

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

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

Schema description coverage is 100%, so the schema already documents all 12 parameters including the enum and mode mappings. The description names the same five modes as the schema enum, adding no syntax, format, or dependency detail beyond what is structured. Baseline 3 is correct 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 states a specific verb+resource: submitting an Amazon product-detail collection (Builder) task, and enumerates the five supported collection modes (by-asin, by-url, by-keywords, by-category-url, by-best-sellers). This lets an agent identify it as the Amazon product scraper, though it never distinguishes it from siblings like amazon_product_list, amazon_global_product, or amazon_seller.

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 trigger conditions ('when the user needs Amazon product details, ASIN, product URL, keyword search...'), which is implied usage context. However there is no explicit when-to-use-this-vs-alternatives guidance and no exclusions against the many sibling product scrapers.

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

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

Annotations declare destructiveHint=true, readOnlyHint=false, idempotentHint=false, and openWorldHint=true, but the description adds almost no behavioral context on top of them. It states a Builder task is submitted yet never explains the async nature, what is returned (task id?), that repeated calls are non-idempotent, or why the operation is flagged destructive for what is just data collection.

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?

It is front-loaded with the trigger phrase, but the opening sentence is keyword-stuffed with near-synonymous phrases (Amazon 产品列表 / 商品列表 / 搜索结果列表 / 关键词商品列表) rather than stating the purpose once cleanly. The second sentence is efficient.

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

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

For an asynchronous task-submission tool with no output schema, the description should say that a task is created and results are retrieved later (e.g., via scraper_task_status / scraper_task_result). It implies a Builder task but omits the follow-up workflow, leaving an agent unsure what comes back.

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 (keyword, domain, file_name, page_turning) is already documented in the schema, including defaults and the page-turning semantics. The description adds no 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 states a specific verb+resource: it submits an Amazon product-list collection Builder task with a fixed collector identifier. However, it does not differentiate itself from the very similar siblings amazon_product, amazon_global_product, and amazon_product_list, so an agent cannot easily tell which one applies.

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 explicit trigger conditions (product-list / search-result / keyword-product-list requests combined with collect/scrape/crawl/fetch verbs), which is clear usage context. It stops short of naming when-not conditions or an alternative sibling to prefer in edge cases.

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

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

The annotations already declare readOnlyHint=false, destructiveHint=true, openWorldHint=true and idempotentHint=false, so the safety profile is covered. The description adds that this is an asynchronous Builder task submission with a fixed collector ID, which is useful beyond the annotations, but it never says what the task produces or how results are retrieved.

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 sentence about submitting the Builder task is front-loadable and clear, but the first sentence is a long enumeration of synonyms (采集、抓取、爬取、获取、提取) that inflates size without adding routing precision beyond a couple of keywords.

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 task-submission tool with no output schema, the description omits the crucial workflow fact that it only enqueues work and that results must be fetched via siblings such as scraper_task_status / scraper_task_result. With destructiveHint=true and no output schema, this leaves the agent without the follow-up path it needs.

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% (url and file_name both documented inline with required/default notes), so the schema carries the parameter meaning. The description adds nothing about parameters except the fixed collector identifier, 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+resource: submits a collection Builder task for Amazon seller info, with the collector fixed as amazon_seller_by-url. It is clearly distinguishable from siblings like amazon_product or amazon_comment by resource, though it spends much of its length on trigger-word enumeration rather than the action itself.

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 explicit trigger conditions (user needs Amazon seller info combined with collection verbs such as 采集/抓取/获取), which is usable context. However, it names no alternatives and no when-not conditions, so the agent still has to infer why it would pick this over the other amazon_* 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 cover the safety profile (readOnlyHint=false, destructiveHint=true, openWorldHint=true, idempotentHint=false), so the description is not the sole carrier of behavior. Still, it adds nothing beyond the trigger — no mention of caching semantics, rate limits, quotas, or what the scrape actually returns, all of which matter for a 14-parameter open-world scraper.

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

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

One front-loaded sentence that leads with the core action and then enumerates filter capabilities. No filler, though the long condition list borders on restating parameter names from the 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?

For a 14-parameter scraping tool with no output schema, the description omits operational context an agent would want: pagination behavior via first/count, the json output modes, and caching/statistics implications of no_cache. The schema carries these, but the description does not tie them into a usable mental model.

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 rich per-parameter documentation (age presets, color enum values, license codes, json output modes). The description only lists filter categories that the schema already explains in more detail, so it adds no semantic value beyond the baseline.

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

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

The description states a clear verb+resource combination: search image results via Bing Images, plus the filter dimensions supported (size, color, type, aspect, face, age, license). However, it makes no attempt to distinguish itself from obvious siblings such as google_images or bing_search, which is a notable omission in this tool set.

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 trigger conditions ('when the user needs to search images or filter them'), which is implied usage guidance. But it never says when to prefer this over google_images, nor when Bing Images is inappropriate, 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 declare readOnlyHint=false, destructiveHint=true, openWorldHint=true, idempotentHint=false, so the safety profile is carried by structured fields. The description adds nothing about caching caveats (no_cache), quota/rate limits, auth needs, or that destructiveHint=true despite a read-looking search. Big gap for a tool whose annotations flag it as destructive.

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 efficient trigger sentence with no padding, front-loaded with the resource keywords. It is appropriately sized, though it is one long enumeration rather than structured guidance.

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

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

With 8 parameters, 100% schema coverage, no output schema, and no-annotations gap on behavior, the description should at least explain pagination and place_id lookup interplay or when not to use it. It is far too thin 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 the burden is already met by the schema. The description only echoes parameter names (place_id, pagination) without adding syntax or format details, so it is 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 states a specific resource (Bing Maps results, place search, locations, place_id, paginated data) with a clear trigger verb, so an agent knows roughly what it fetches. It does not differentiate from the sibling google_maps, which the same style of query would also serve.

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 trigger clause '当用户需要查询...时触发' implies usage context, but gives no explicit when-to-use versus google_maps/google_local, and no exclusions. Usage is only implied, which is the minimum viable level.

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=false, openWorldHint=true, idempotentHint=false and destructiveHint=true, and the description adds nothing behavioral on top of them. It says nothing about caching (the schema exposes no_cache), output format, auth needs, or why a news query carries a destructive hint. Silence is not contradiction, but the description contributes no behavioral value.

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?

It is a single sentence with no filler, but it is somewhat run-on and redundant ('查询新闻搜索结果' restated as '获取新闻内容'). It is adequately compact but not tight or well front-loaded.

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

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

For a nine-parameter tool with no output schema, the description is thin: it should at least sketch what news content is returned (fields, structure, pagination via first/count). The schema itself is fully documented, so the core calling mechanics are covered, but the description leaves the return contract unexplained.

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 nine parameters thoroughly. The description loosely echoes the categories (keyword, region, language, date sort, safe filter) that map to q, cc, mkt, qft and safeSearch but adds no syntax, format, or default information beyond the schema, which is the 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?

The description names a specific verb (查询/query) and resource (Bing News 新闻搜索结果), and lists the dimensions it covers (keyword, region, language, date sorting, safe filtering). This is clear enough that the agent knows it is a Bing news search, but it offers no differentiation from siblings like bing_search or google_news.

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 is framed as a trigger clause (当用户需要...时触发), which supplies context for when to use it, but there are no when-not conditions and no named alternatives. The 'when' is essentially 'when you need news,' which is redundant with the tool name and does not route between competing news/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 exist (readOnlyHint=false, destructiveHint=true, idempotentHint=false, openWorldHint=true), but the description adds no behavioral context beyond the trigger. It does not explain the non-read-only/destructive annotation, the 5-minute cache behavior (only in the schema), auth requirements, or rate limits, leaving the surprising 'destructive' flag unexplained for what reads like a read-only search.

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

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

It is a single sentence, so it is compact and front-loads the core purpose. However, the trailing facet list largely duplicates the parameter schema and reads as a run-on, so not every clause 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 11 parameters, 100% schema coverage, and annotations present, the structured fields carry most of the burden. The description is minimally adequate but omits anything about output format (the json parameter), pagination semantics, or the nature of results, leaving it thin for a tool with this many knobs and no output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description lists facets that loosely map to several of the 11 parameters (location, lat/lon, cc, mkt, safeSearch, first, filters), but adds no syntax, format, or default information beyond what the schema already documents.

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

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

The description names a specific verb and resource ('通过 Bing 搜索公开网页信息' / search public web information via Bing) and enumerates the facets it supports (location, lat/lon, country, language, safe filtering, pagination, advanced filters). It is clear about what the tool does, but it offers no differentiation from siblings such as google_search, duckduckgo_search, or yandex_search.

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 whole statement is framed as a trigger condition ('当用户需要...时触发'), which gives explicit when-to-use context. However, it names no exclusions and no alternative engines, so an agent cannot tell from the text why it should choose this over google_search or duckduckgo_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?

Annotations declare readOnlyHint=false and destructiveHint=true, but the description describes a read-only query operation ('查询商品...'), directly contradicting the destructive annotation. The description also omits any mention of caching, authentication, or side effects, leaving a major behavioral gap.

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

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

The description is a single, front-loaded sentence that gets to the point quickly. However, it lists several overlapping concepts ('查询商品、购物搜索结果、商品列表'), which is somewhat redundant.

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

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

For a tool with seven parameters, no output schema, and annotations that suggest destructive behavior, the description is far too thin. It does not explain return values, caching implications, or why it is marked destructive, leaving the agent without crucial context.

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

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

Schema description coverage is 100%, so all seven parameters are fully documented in the schema. The description only mentions offset and filters generically, adding no new semantic detail 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 states a specific verb (查询) and resource (Bing Shopping 商品/购物数据), making the tool's function clear. It distinguishes itself from general search tools by naming Bing Shopping, though it does not explicitly contrast with sibling shopping tools like google_shopping.

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 a trigger condition ('当用户需要...时触发'), which indicates when to use the tool. However, it offers no guidance on when not to use it or how it compares to alternatives like bing_search or 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?

The annotations declare readOnlyHint=false and destructiveHint=true, yet the description describes a pure retrieval operation (搜索视频结果 / 筛选视频) with no destructive semantics. The description also omits anything beyond the schema — cost/credits, the 5-minute cache behavior, output format, pagination — so the behavioral profile is left contradictory rather than clarified.

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

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

A single sentence, front-loaded with the primary action (searching Bing Videos) followed by the filter facets; nothing is padded or redundant. The facet list is dense but each item earns its place by mapping to real parameters.

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 12 parameters but a fully-documented schema and existing annotations, most calling information is carried by structured fields, so the terse trigger sentence is minimally adequate. However, for a scraper tool with no output schema, the description says nothing about the returned result shape, credit consumption, or caching, leaving real gaps.

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

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

Schema description coverage is 100%, with all 12 parameters (q, cc, mkt, date, json, first, price, length, setlang, no_cache, resolution, source_site) documented including allowed values in the schema itself. The description only restates the filter categories at a high level, adding no syntax or default information 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 (Bing Videos 的视频结果) and enumerates the filterable facets, so an agent can tell it apart from bing_images/bing_news/google_videos at a glance. It is framed as a trigger condition rather than an action statement, and it never names a sibling to differentiate against, which keeps 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 entire sentence is a when-to-use clause: use this when the user wants video results from Bing Videos or wants to constrain results by duration, date, resolution, source site, price, country or language. There is no when-not guidance and no explicit alternative (e.g. youtube_video, google_videos), which is what separates it from a 5.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=false, so the bar is lowered. The description adds that it submits an async Builder task with a fixed collector ID, which is consistent with the write annotation. It does not explain what is destructive, auth requirements, rate limits, or how results are later retrieved (sibling scraper_task_result/status), leaving meaningful 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?

The trigger list is verbose and redundant — 酒店信息, 酒店详情, hotel information, hotel list and five near-synonymous action verbs all express the same intent. The action statement is front-loaded enough, but the keyword padding dilutes the signal.

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

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

There is no output schema, and this is an async task-submission tool with destructive/idempotent-false annotations. The description states the task and collector ID but omits the workflow an agent needs (that results come from a separate task-result tool) and any caution about the destructive write. Adequate but incomplete.

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

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

Schema description coverage is 100%, so both parameters are already documented, making 3 the baseline. The description only echoes the collector identifier tied to the url parameter and adds no format or validation nuance 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 second sentence names a specific verb+resource: submitting a Booking hotel information collection Builder task with a fixed collector identifier. It distinguishes the tool as Booking-specific against siblings like google_hotels. It falls short of 5 because the primary action is buried behind a trigger-phrase list and it doesn't clarify list-vs-detail scope.

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

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

The first sentence explicitly states the triggering condition — when the user needs Booking hotel information/detail/list paired with verbs like 采集/抓取/爬取/获取/提取. This gives clear context for when to use it. However, it names no alternatives (e.g., google_hotels or other scraper tools) and offers no exclusion criteria, so it stops at 'when' without 'when not'.

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 destructiveHint=true, openWorldHint=true and non-idempotent, so the safety profile is partly covered. The description adds that this is a task-submission tool (Builder task), but does not explain what makes it destructive, cost/rate behavior, or that results must be retrieved asynchronously - gaps given the destructive flag.

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 first sentence is heavy keyword stuffing (a string of comma-separated 'ChatGPT 答案/回答内容/回答文本/引用来源链接' variants) that does not earn its length. The substantive purpose only appears in the second sentence, so the definition is not well front-loaded.

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

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

For a task-submission tool with four params, no output schema and a destructive annotation, the description explains modes but omits what happens after submission - e.g. that the task is queued and results are fetched via scraper_task_status/scraper_task_result. Adequate but incomplete.

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

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

Schema coverage is 100%, so the schema already documents spider_id, chatgpt_url, search_terms and file_name, including which mode each maps to. The description mostly restates that same mode-to-parameter mapping, adding little 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 gives a concrete verb+resource: it submits a ChatGPT-answer collection Builder task and names the two supported modes (chatgpt_answer_by-keywords, chatgpt_answer_by-url). It is distinguishable from siblings like google_ai_mode, though it never explicitly contrasts them.

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

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

The opening trigger clause sets clear context for when to invoke (user wants ChatGPT answers/citation links/model version combined with collect/scrape/extract verbs), and it routes between the keyword vs URL modes. It offers no explicit when-not-to-use or sibling alternatives.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=false, openWorldHint=true, so the safety profile is covered. The description adds that this 'submits a Builder task,' which is consistent with a non-idempotent write rather than a synchronous read. It does not disclose what the task produces, whether credentials/keys are required, or any rate limits — meaningful gaps for a job-submission tool, but the annotation bar is lower here.

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 trigger enumeration is redundant ('Crunchbase 信息、Crunchbase 公司信息、Crunchbase 企业信息、Crunchbase company') and pads the front. The action statement follows, so it is reasonably front-loaded, but several near-synonymous phrases do not fully earn their 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 no output schema, the description should carry the return/lifecycle burden, but it only says a task is submitted. It never states that a task id is returned and that results are retrieved via sibling tools like scraper_task_status/scraper_task_result. For a task-submission tool this is an incomplete but not fatal omission.

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

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

Schema description coverage is 100%, so the schema already documents url, keyword, file_name and the spider_id enum mapping. The description reinforces the two modes (by-url vs by-keywords), matching spider_id, but adds no syntax or format meaning beyond the schema. Baseline 3 applies 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 second sentence states a specific verb and resource: '复用一个工具提交 Crunchbase 公司信息采集 Builder 任务' (submit a Crunchbase company-info collection Builder task). It also names the two supported modes (by-url, by-keywords), which pin down the scope. Differentiation from the many source-specific siblings is implicit through the Crunchbase/company naming 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?

The first sentence gives an explicit trigger condition: use when the user needs Crunchbase company info combined with verbs like 采集/抓取/爬取/获取/提取. It also presents the two modes as the routing choice. There are no explicit 'do-not-use' exclusions or named alternative tools, but the usage 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 declare readOnlyHint=false and destructiveHint=true, yet the description frames the tool purely as a read/search operation ('搜索公开网页信息', '获取搜索结果'), creating an inconsistency with the destructive hint. Beyond that mismatch the description adds no behavioral context such as credit consumption, rate limits, or privacy-mode semantics despite the 'privacy search' mention.

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?

It is a single short sentence with the trigger front-loaded, but it lists overlapping concepts ('隐私搜索结果、网页结果或搜索摘要') that repeat the same idea rather than adding distinct information.

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

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

For a 9-parameter tool with two enums, no output schema, and a large sibling set of competing search tools, the description leaves critical gaps: it never explains the output-format behavior controlled by 'json', the search_assist/m exclusivity, or how to choose it over sibling search 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% and the schema richly documents all 9 parameters (date filter, region, output format, safe search, pagination, caching). The description contributes nothing 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?

The description states a specific verb+resource: searching public web information via DuckDuckGo and retrieving privacy/web results or search summaries. Naming DuckDuckGo implicitly distinguishes it from siblings like google_search, bing_search, and yandex_search, though it never makes that contrast explicit.

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

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

The whole text is a 'trigger when the user needs...' phrasing but gives no conditions, prerequisites, or when-NOT-to-use guidance. It never tells the agent when to prefer DuckDuckGo over the many other search siblings (google_search, bing_search, yandex_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?

Annotations already declare readOnlyHint=false, destructiveHint=true, openWorldHint=true, so the mutation profile is covered structurally. The description adds the useful fact that this submits an asynchronous 'Builder 任务' rather than returning data directly, which reconciles the non-read-only hint, but it omits task lifecycle, auth prerequisites, rate limits, and any side effects.

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

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

Trigger conditions are front-loaded, which is good, but the opening enumerates near-synonyms ('ebay 信息、eBay 商品信息、eBay 产品信息、eBay 类别商品、eBay 店铺商品') that add bulk without information. The mode list duplicates the enum already in the 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?

Without an output schema, the description should explain what the caller gets back (e.g., a task ID for later polling via scraper_task_status). It describes input modes and extraction targets but is silent on return values and follow-up task handling, leaving a gap for a task-submission 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 the schema already documents url, count, keywords, file_name, and the spider_id enum with per-mode defaults. The description merely restates the four spider modes and extraction scope, adding no syntax, format, or default semantics beyond the schema; 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 resource (eBay product/listing data) and the action (extract + submit a collection Builder task), listing concrete data types (price ranges, seller details, auction records, stock, reviews, shipping). It is clearly an eBay-specific scraper, but it never names or contrasts sibling scrapers (amazon_product, walmart_product, google_shopping_info), so differentiation is left to the domain 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?

Gives the trigger condition explicitly: eBay info combined with collect/scrape/crawl/get/extract verbs. This is solid when-to-use guidance, but it offers no when-not-to-use or alternative routing (e.g., when to prefer a search tool vs. this Builder task).

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

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

Annotations declare destructiveHint=true, openWorldHint=true, and readOnlyHint=false, but the description never explains that this launches a long-running Builder task, whether it returns a task id or immediate results, or what state it mutates. The one concrete fact offered, the fixed collector identifier, is the only behavioral 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 a single long run-on sentence overloaded with synonym lists in two languages (评论, comments, 采集, 抓取, 爬取, 获取, 提取) intended for keyword matching rather than reading. It is verbose and not front-loaded with the core purpose.

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

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

For a destructive, non-idempotent task-submission tool with no output schema, the description omits what happens after submission, how results are retrieved (siblings scraper_task_status/result exist), and how it differs from the Facebook post scraper. The schema covers parameters, but the operational picture is incomplete.

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

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

Schema description coverage is 100%, so every parameter including url, comments_sort, limit_records, and get_all_replies is already documented with defaults and enums. The description adds no parameter-level meaning of its own, which is the expected baseline 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 states it triggers on Facebook post comment scraping and submits a Builder task, so the resource (Facebook comments) is identifiable. But the phrasing is trigger-oriented and keyword-stuffed rather than a clean verb+resource statement, and it never distinguishes this tool from the sibling facebook_post or the other *_comment tools beyond the platform 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?

It implies when to invoke (user needs Facebook post comments combined with collect/scrape verbs) and names the fixed collector id, which is useful implementation detail. However, there is no explicit when-not-to-use or guidance against the sibling facebook_post scraper, so routing between them is left to inference.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=true and openWorldHint=true, so the mutating, non-idempotent, open-world nature is covered. The description adds only that this is an asynchronous Builder task submission, without saying what side effects occur, whether auth/quota applies, or how the resulting task is tracked.

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?

Front-loaded with the trigger condition, but the first sentence is a stuffed keyword list (Facebook 活动 / Facebook 活动信息 / Facebook event / 活动列表 / 活动搜索结果) that largely repeats itself before the actionable 'submit a Builder task' statement appears.

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 description is the only place to explain that this returns a task handle rather than event data, and to link to scraper_task_status / scraper_task_result for polling. It implies async submission but leaves that essential follow-up workflow unstated.

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% – url, file_name default, and the spider_id enum are all documented in the schema itself. The description merely repeats the two spider_id values and adds no format or selection semantics beyond what is already there, so baseline 3 applies.

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

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

States a specific verb+resource: submits a Facebook event collection Builder task, and names the two supported spider modes. This clearly separates it from siblings like facebook_post, facebook_comment, and facebook_profile. It stops short of 5 only because the trigger-keyword enumeration adds length without sharpening the distinction further.

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?

Gives explicit trigger conditions (user wants Facebook events / event lists / event search results combined with collect/scrape/fetch verbs), which is real when-to-use guidance. It does not state when NOT to use it, nor how to choose between the two spider_id modes (the schema carries that instruction).

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 destructive=true, readOnly=false, openWorld=true, and idempotent=false, so the safety profile is covered. The description adds that this submits a Builder task with a fixed collector ID, but it does not explain authentication needs, async behavior, rate limits, or what happens after submission.

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, front-loaded with trigger conditions followed by the action and fixed collector identifier. The synonym list aids routing, and there is no extraneous content.

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

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

There is no output schema, so the description should explain what the tool returns. It states a Builder task is submitted but does not mention that a task ID or status result is returned, nor does it reference sibling tools such as scraper_task_status or scraper_task_result for retrieving results. This is a meaningful gap for a task-submission 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 both url and file_name are fully documented in the schema. The description adds nothing about parameter syntax or format beyond naming the fixed collector ID, making the baseline 3 appropriate.

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

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

The description states a specific action (submit a Facebook post collection Builder task) and resource (Facebook posts), and fixes the collector identifier to facebook_post_by-posts-url. It clearly distinguishes this from sibling tools like facebook_comment or facebook_profile by focusing on posts, though it does not explicitly name 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?

It gives explicit trigger conditions: when the user needs Facebook post information combined with collection/scraping/extraction verbs. This is clear usage context, but there is no guidance on when not to use it or which alternative tools to consider.

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 readOnly=false, destructive=true, idempotent=false, and openWorld=true, so the safety profile is covered. The description adds that this is an async Builder task submission (提交...任务), which is useful context, but it never explains the task lifecycle, that results must be fetched later, or what the destructive hint actually means in practice.

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?

It is only two sentences and front-loaded with a purpose statement, but the first sentence is a long keyword-enumeration block (个人主页/个人资料/profile/信息 + five verbs) that is repetitive rather than informative for an agent. The useful content is a single sentence; the rest is 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?

No output schema exists, and the description does not say that this returns a task handle whose result must be retrieved via siblings such as scraper_task_result or scraper_task_status. For a task-submission tool with destructive/openWorld annotations, that missing lifecycle context is a meaningful 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 description coverage is 100% and both parameters are documented in the schema, including the url non-empty requirement and the file_name default. The description only restates the fixed collector identifier and adds no format or syntax detail beyond the schema, so baseline 3 applies.

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

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

The second sentence states a specific action (提交/submit) and resource (Facebook 个人主页采集 Builder 任务) with a fixed collector ID, which lets an agent identify it against siblings like facebook_post or facebook_comment. However, the first sentence is keyword-trigger routing text rather than a purpose statement, so the actual purpose is buried and requires the reader to parse past it.

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 trigger condition (user needs FB profile info combined with collect/scrape/crawl/fetch verbs), which implies when to use it. But it names no alternatives and provides no when-not-to-use guidance, e.g. that it should not be used for posts, comments, or events, despite many facebook_* siblings existing.

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=false, destructiveHint=true, openWorldHint=true, and idempotentHint=false, so the mutation profile is disclosed structurally. The description adds that it submits a Builder task (consistent with a write), but does not explain that results must be polled via the scraper_task_* siblings, nor what the task submission returns. The destructiveHint=true claim is not really clarified by the description either.

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

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

The trigger clause is front-loaded, which helps selection, but the opening is a repetitive keyword dump ('Github仓库信息、GitHub 仓库信息、Github repository…'). The purpose ('复用一个工具提交…任务') is buried after a long trigger list, so structure is functional but not tight.

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 scraper submission with 100% schema coverage and annotations that carry the safety profile, the description covers the essential purpose and mode selection, so an agent has what it needs to invoke it. The main omission is the downstream workflow (that the submitted task returns an ID and results are fetched via scraper_task_status/result), but no output schema exists to cover that either.

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 (url, repo_url, search_url, max_num, page_turning, file_name, spider_id) is already documented in the schema, including which spider mode each serves. The description echoes the three modes but adds no syntax, format, or constraint detail beyond what the schema provides, so baseline 3 applies.

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

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

The description states that the tool submits a Github repository collection Builder task and names the three supported modes (by-repo-url, by-search-url, by-url), so the verb and resource are identifiable. It leans heavily on trigger keywords rather than crisp functional prose, but an agent still understands it is the GitHub-repo scraper entry point distinct from other site scrapers.

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 the condition that triggers the tool (user needs Github repository info combined with collect/scrape/fetch/extract verbs) and lists the three spider modes, which provides implied usage guidance. However, it never states when NOT to use it, offers no explicit alternative sibling, and gives no rule for choosing between the three spider_ids beyond naming them.

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

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

Annotations declare readOnlyHint=false, destructiveHint=true, openWorldHint=true and idempotentHint=false, and the description's 'submits a Builder task' is consistent with a non-read operation that creates state. It does not disclose the async task lifecycle (returned task id, need to poll scraper_task_status / fetch via scraper_task_result), nor auth or rate-limit behavior, which is the main added-context gap. 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 opening trigger sentence lists near-synonyms redundantly ('Glassdoor 招聘信息、职位信息、job listings、招聘搜索链接'), and the actual purpose only appears in the second sentence. The informative content is there but it is not front-loaded and contains avoidable repetition.

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

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

For a 6-parameter task-submission tool with no output schema and 100% schema coverage, the description plus schema cover the inputs well, including which mode uses url vs keyword/location. The remaining omission is the post-submission lifecycle (how to retrieve results via the scraper_task_* siblings), which an agent would need to chain the call correctly.

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

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

Schema description coverage is 100% and every parameter, including the spider_id enum and each mode's required fields, is fully documented in the schema. The description only restates the three mode names already present in the enum, adding no format or dependency detail 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?

The second sentence gives a concrete verb+resource: it submits a Glassdoor job-listings Builder task and enumerates the three supported spider modes. An agent can distinguish it from generic search siblings, though the first sentence is mostly trigger-keyword padding rather than purpose. Clear but noisy.

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 states trigger conditions (user wants Glassdoor job listings plus verbs like collect/scrape/fetch) and the schema tells the caller to pick the spider_id mode that matches the user's intent. However, it never names alternatives such as google_jobs or linkedin_job_listings_information, nor when NOT to use this tool, so routing among siblings is left to inference.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, openWorldHint=true, idempotentHint=false, and the description adds no behavioral context on top of them. It says nothing about the caching behavior implied by no_cache, the output modes implied by json, rate limits, or auth. Notably it is silent on the destructiveHint=true annotation, which is surprising for a search tool and would benefit from explanation.

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

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

A single, compact sentence with no filler or repetition. It is front-loaded with the trigger condition, though the trigger phrasing is slightly indirect compared to a direct 'this tool does X' statement.

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, open-world scraper tool with no output schema, the description does not convey what is returned, how Google AI Mode results differ from a plain google_search result, or how the json output modes affect the response. The schema documents inputs well, but the description leaves the agent without enough context to choose this tool confidently among ~80 siblings.

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 (q, gl, hl, json, uule, location, no_cache) is already fully documented in the schema. The description only loosely gestures at location/country/language control, adding no syntax or constraint detail beyond what the schema provides. 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 names a specific verb and resource: obtaining AI search results via Google AI Mode, and controlling them by location/country/language. It is written as a trigger condition rather than a direct statement of function, and it never distinguishes itself from the many overlapping siblings (google_search, chatgpt_answer, bing_search, duckduckgo_search, yandex_search).

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 when-to-trigger condition ('when the user needs AI search results via Google AI Mode'), which is implied usage guidance. However, the second clause about location/country/language applies to nearly every search sibling and does not tell the agent when to pick this tool over google_search or chatgpt_answer. No exclusions or 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?

The description implies a read-only retrieval of search results ('查询...搜索结果'), while the annotations declare readOnlyHint=false and destructiveHint=true. That is a direct conflict in the safety profile an agent would act on. Even setting the conflict aside, the description adds no behavioral context (caching, billing, rate limits, output shape) beyond what the schema already states.

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

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

A single front-loaded sentence with no padding. It is appropriately terse for a search-scraper tool, though it errs toward under-specification rather than rich structure.

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 100% schema coverage and no output schema, the description's main remaining job is to convey what comes back (scraped Google Finance data, format governed by the json parameter) and how it differs from sibling search tools. It covers only the trigger, leaving return semantics and sibling routing to inference.

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 five parameters (q, hl, json, window, no_cache) in detail. The description adds nothing beyond the domain keywords, so the 3 baseline for schema-covered parameters 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 names a specific domain and resource set (Google Finance stocks, indices, funds, market quotes, financial assets, securities), so an agent can tell it apart from generic siblings like google_search or google_news. It is framed as a trigger condition rather than an action statement, but the verb+resource ('查询 ... 搜索结果') is still recoverable.

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 an explicit trigger ('当用户需要查询...时触发'), which is real usage context, but offers no exclusions or alternatives — nothing tells the agent when google_search, google_news, or a product scraper would be a better pick. Usage is implied by the finance keyword list alone.

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

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

Annotations already declare openWorldHint=true and destructiveHint=true, so the safety profile is partly covered externally. The description itself adds no behavioral context at all — nothing about caching (no_cache), the latency cost of deep_search, token-based multi-step flows, or credit consumption. For a 32-parameter scraper with non-trivial side effects, this is a meaningful 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?

A single, front-loaded sentence with zero filler. It is efficient, though for a 32-parameter tool with a multi-step booking workflow the extreme brevity borders on under-specification rather than optimal conciseness.

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

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

This is a complex tool — 32 params, no output schema, round-trip/multi-city flows involving departure_token and multi_city_json — yet the description is one trigger clause. It omits the two-step selection workflow and cost/latency trade-offs that an agent needs to call it correctly, so it is not complete for the tool's 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% and every one of the 32 parameters carries its own inline description, so the schema does the heavy lifting. The tool description supplies no additional parameter meaning, which matches the baseline 3 for fully documented schemas.

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

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

The description names a specific verb and resource (查询 Google Flights 航班信息/机票价格) and enumerates the concrete query dimensions it supports (round-trip/one-way/multi-city, cabin, airlines, stops, baggage, emissions). It clearly distinguishes this from sibling search tools. However, it is framed as a trigger condition rather than a purpose statement and does not explicitly differentiate itself from e.g. google_hotels or google_search.

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 entire sentence is a when-to-trigger condition, so usage context is implied and reasonably clear. It never states when NOT to use it, nor names an alternative tool, and it omits key prerequisites such as needing a departure_id/outbound_date before it is 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 frames the tool purely as a read/query operation, while the annotations declare readOnlyHint=false and destructiveHint=true. That is a direct conflict about the tool's side effects, and the description adds no compensating behavioral context (caching via no_cache, pagination via next_page_token, or result-shape info) that would clarify the real 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?

A single front-loaded trigger sentence with no filler; the enumeration of facets is scannable. It is slightly redundant in re-listing concepts (dates, ratings, amenities) that the schema documents exhaustively, but nothing is wasted.

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 27-parameter search tool with no output schema, an agent can still call it correctly thanks to full schema documentation, but the description says nothing about pagination flow, caching semantics, or vacation-rental-vs-hotel mode switching. Adequate, 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% across all 27 parameters, so the schema already explains q, dates, amenities, filters, no_cache, next_page_token, etc. in detail. The description contributes no parameter-level meaning beyond the general list of queryable facets, 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 names a specific resource (Google Hotels) and enumerates what the tool surfaces — search results, prices, check-in/check-out dates, ratings, amenities, property types and filters — so an agent knows this is the hotel-search scraper. It never contrasts itself with the neighboring lodging tools (booking_hotellist, airbnb_product), so differentiation must be inferred 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?

It supplies a trigger condition ('when the user needs to query...'), which is the minimum viable routing guidance. There is no when-not guidance, no mention of prerequisites (check-in/check-out dates are required), and no pointer to sibling lodging tools that might be preferred.

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

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

Annotations already declare openWorldHint=true and a destructive/idempotent profile, but the description adds no behavioral context of its own — nothing about caching (no_cache), cost (ai_overview billing), or pagination semantics that the schema hints at. For a 28-parameter scraper it should say more than 'triggered when'.

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

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

A single front-loaded sentence with no filler, which is appropriately sized for a trigger statement. It is efficient, though the extreme brevity is partly what leaves the definition thin elsewhere.

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

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

Against 28 parameters, a required query, no output schema, and a defaulted tbm=isch mode, the description is far too sparse. It omits return format (json=1..4), pagination (start), device targeting, and cost implications — an agent would have to reverse-engineer all of that from 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 28 parameters are fully documented in the schema itself. The description only loosely echoes the filter dimensions (size, color, type, copyright) that map to tbs/cr/lr, adding no syntax or default guidance beyond what the schema provides — 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?

The description names a specific verb and resource: searching image results via Google Images, plus the filterable attributes (size, color, type, copyright, location, language). It is clear what the tool does, but it never distinguishes itself from siblings like bing_images or google_lens, which could also surface imagery.

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?

Framed entirely as a trigger condition, it states when to reach for this tool (image search or filtered image search). It gives clear positive context but no exclusions and names no alternative, so an agent choosing between google_images, bing_images, and google_lens gets no routing help.

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

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

Annotations declare destructiveHint=true, readOnlyHint=false, openWorldHint=true and idempotentHint=false, which is a non-obvious profile for a search-style tool, yet the description adds no behavioral context at all — no cost, caching, rate-limit, or result-count information (the 5-minute cache and the 10-results-per-page limit live only in the schema text). With annotations shouldering the safety profile, the description still contributes essentially nothing beyond 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?

A single front-loaded sentence that leads with the platform and the core action, then enumerates the supported retrieval modes. The enumeration is somewhat list-like but every clause maps to a real capability, so there is little 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?

For a 13-parameter tool with no output schema, the description covers only the retrieval intent and leaves pagination context, output-format implications of the json parameter, cache behavior, and the location/uule mutual exclusion entirely to the schema. The schema is thorough enough that the tool remains callable, but the description is thinner than a tool of this complexity warrants.

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 all 13 parameters, so the schema already explains q, gl, hl, uds, json, lrad, uule, chips, ltype, location, no_cache, google_domain, and next_page_token. The description's mention of location, radius, remote work and filters loosely maps to location/lrad/ltype/chips but adds no syntax or format detail, 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 names a specific platform and resource ('通过 Google Jobs 查询招聘职位、岗位列表'), plus the secondary capability of fetching next-page results, so the agent can tell it is a job-listing retrieval tool. It does not differentiate against overlapping siblings such as glassdoor_joblistings, linkedin_job_listings_information, or indeed_companies_info, so it stops 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 '当用户需要…时触发' framing gives an implied trigger condition (job search, job lists, next page, filtering by location/radius/remote), which is enough to route a job-related request here. However, it offers no when-not guidance, no prerequisites, and never names an alternative job source, so the agent must infer selection on its own.

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=false, destructiveHint=true, openWorldHint=true and idempotentHint=false, so the safety profile is covered structurally. The description adds no behavioral context at all: nothing about caching (the no_cache param exists), rate limits, auth, or the fact that results are scraped/collected output. It does not contradict the annotations, but it contributes nothing beyond 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?

A single compact sentence with no filler and the resource (Google Lens, image URL) front-loaded. It is efficient, though the trigger-clause phrasing and the enumerated enum values make it feel more like a routing hint than a description.

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

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

With 8 parameters, no output schema, and a scraped/open-world result set, the description should say something about what comes back (JSON vs HTML via the json param, cached vs fresh results, pagination/volume). It covers none of this, so an agent knows when to call it but little about what to expect or how to shape the call.

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 8 parameters, so the schema already documents url, q, hl, country, safe, json, no_cache and the type enum in detail. The description only echoes the type values (visual matches, product matches, exact matches, about this image), duplicating the enum rather than adding syntax or usage constraints. Baseline 3 applies 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 names a specific resource (Google Lens) and operation (identify image content from an image URL, find visual/product/exact matches, 'about this image'), so an agent can tell what the tool does. It never differentiates itself from the many other image/search siblings (google_images, bing_images, yandex_search), and it is framed as a trigger clause rather than a tool description, so it stops 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 whole sentence is a usage condition ('trigger when the user needs to...') and it enumerates the five intent scenarios that map to the type enum, which is genuine when-to-use context. However, it offers no exclusions and never names an alternative sibling (e.g. google_images or bing_images) for plain image search, leaving the boundary implicit.

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

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

The description characterizes the tool as a query/search operation, implying a read-only action, while the annotations declare readOnlyHint=false and destructiveHint=true. This is a direct contradiction, so the score is 1 and the contradiction is flagged.

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 trigger condition and scope without any waste. It is appropriately sized for a trigger statement.

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 11 parameters and no output schema, the description is minimal and relies entirely on the schema for invocation details. It provides enough to select the tool but does not cover return values or other behavioral aspects, making it just 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 the baseline is 3. The description adds no parameter-level meaning beyond what the schema already provides, so it does not exceed the baseline.

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

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

The description specifies a clear verb (查询) and resource (Google 本地搜索结果, 附近商家, 地点列表, 本地服务, 基于位置的本地结果). It does not differentiate from closely related siblings such as google_maps or google_map_details, so it falls 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?

It provides explicit trigger conditions: '当用户需要查询...时触发' and lists several scenarios. However, it offers no when-not guidance or named alternatives, so it is not a full 5.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety profile is covered structurally. The description adds that this submits an asynchronous Builder task (implying later retrieval) and the fixed collector id, but says nothing about how the task is tracked, reversibility, rate limits, or how to fetch results.

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 trigger clause is front-loaded, then the action follows, which is a sensible order. However, the first sentence is keyword-stuffed with near-synonyms (评论信息/评论/reviews/商家评论) and verb lists, which pads the text without adding routing precision.

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 the return, yet it never says a task is created whose results must be fetched via the scraper_task_result / scraper_task_status siblings. For an async task-submission tool in a large sibling set, that pipeline handoff is a meaningful omission.

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

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

Schema description coverage is 100%, so every parameter (url, file_name, days_limit) is already documented with defaults and semantics. The description adds only the collector identifier binding (google_comment_by-url) and no extra meaning for the input fields, 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 states a concrete action (submit a Google Map comment collection Builder task) and a resource (Google Maps reviews/comments), plus the fixed collector identifier google_comment_by-url. It is clearly differentiated from other Google tools by scoping to comments/reviews, though it never names the closest siblings (google_map_details, google_maps) to disambiguate.

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 an explicit trigger condition: use when the user needs Google Maps review data combined with collection verbs (采集/抓取/爬取/获取/提取). That is a clear 'when to use' rule, but there is no 'when not to use' and no alternative tool is named, leaving the boundary with google_maps / google_map_details to inference.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, openWorldHint=true and idempotentHint=false, so the write/side-effecting profile is covered. The description adds that work is submitted as a 'Builder task' (asynchronous job) rather than returning data inline, but omits how/when results become available and whether submission consumes quota.

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, front-loaded with the triggering conditions and then the capability with mode names. It is compact and wastes little space, though the opening keyword enumeration is a style choice that trades readability for trigger coverage.

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 10-parameter, no-output-schema task-submission tool, the description covers what is submitted and the four modes, but says nothing about the async lifecycle or that results must be fetched via scraper_task_status/scraper_task_result. That retrieval path is a meaningful omission for an agent trying to complete a workflow.

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

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

Schema description coverage is 100%, so each of the 10 parameters is already documented with its mode association and defaults. The description's enumeration of the four spider modes only restates what spider_id's enum and per-parameter descriptions already convey, adding no syntax or constraint detail 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?

It states a concrete action (submit a Google Maps details collection task) and enumerates the four collection modes (by-url, by-cid, by-location, by-placeid), which distinguishes it from siblings like google_maps or google_map_comment. The opening trigger list is keyword-stuffed rather than a clean statement of purpose, and it never explicitly contrasts itself with the other Google Maps 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?

The trigger clause (when a user needs Google Maps info combined with scrape/crawl/fetch verbs) and the instruction to select a mode matching user intent give implied usage guidance. However, no alternative tool is named as the right choice in other situations, and there is no when-not-to-use guidance versus google_maps or google_local.

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

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

Annotations declare readOnlyHint=false and destructiveHint=true, i.e. a state-mutating, destructive operation, while the description frames the tool purely as a retrieval/query ('查询', '获取地图数据'). The description adds no behavioral context (cost, quotas, caching, side effects) and its read framing opposes the destructive annotation, so this is an annotation contradiction.

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

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

A single sentence with no filler, front-loaded as a trigger condition, which is the right shape for a dispatch-style description. It is a somewhat long enumeration of trigger keywords, but nothing is redundant.

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

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

For an 18-parameter tool with no output schema and heavy parameter interdependencies, a trigger-only description leaves the agent with the schema as its sole guide. The schema is complete so the call itself is executable, but the description contributes nothing about scope boundaries, output shape or the free-vs-billed cache behaviour that matters operationally.

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% — all 18 parameters, including the ll/lat/lon/location/z/m interplay, enums and defaults, are fully documented in the schema. The description only alludes to lat/lon, place ID, CID and zoom without adding any format or constraint detail 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?

States a clear verb+resource: '查询 Google Maps 地点、商家、本地位置、地图搜索结果' and retrieval by lat/lon, place ID, CID, zoom range. This distinguishes it from bing_maps and the generic search siblings, but it does not differentiate it from Google-Maps-adjacent siblings like google_local, google_map_details and google_map_comment, whose scope it overlaps almost entirely.

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 whole description is a trigger clause ('当用户需要...时触发'), which gives implicit usage context but no explicit when-to-use vs when-not-to-use and names no alternative tool. An agent must still guess whether google_local or google_map_details is the better pick for a 'local places' request.

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 portrays a pure retrieval of news results, yet annotations declare readOnlyHint=false, destructiveHint=true and idempotentHint=false, so the stated semantics directly contradict the declared behavior profile. Even setting the conflict aside, the text discloses nothing about caching, search-credit consumption (hinted at only in the no_cache parameter), rate limits or result format.

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

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

It is a single well-formed sentence with the trigger condition front-loaded and no filler. It is terse, but nothing in it is redundant or padding — the shortfall is under-specification rather than verbosity.

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 11-parameter tool with no output schema and annotations that actively mislead, the description covers only the trigger condition. It says nothing about the cost/credit implications of uncached searches, the JSON/HTML output options, or how the token parameters relate to the required q query, leaving significant gaps for correct invocation.

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

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

Schema description coverage is 100%, so all 11 parameters are already documented in the schema — including the easily confused topic_token, section_token, story_token and publication_token. The description's enumeration of "keyword, topic, publication, section, story" loosely parallels those parameters but does not name them or explain precedence between q and the tokens, so it stays at the schema-driven baseline.

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

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

The description names a concrete verb (query/get) and a concrete resource (Google News results and the news content behind a keyword, topic, publication, section or story). That is specific enough to know what the tool does, but it draws no boundary against obvious siblings such as bing_news, google_search or google_ai_mode, so the agent cannot tell from the text alone why this rather than another news source should be chosen.

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 sentence is framed as a trigger condition — use it when the user wants Google News results or news content for a keyword, topic, publication, section or story — which is real when-to-use context mapping onto the token parameters. It contains no when-not-to-use guidance and never names an alternative among the ~70 sibling search 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 the safety profile (destructiveHint=true, openWorldHint=true, idempotentHint=false), which is unusual for a search tool. The description adds no behavioral context at all: no mention of the 5-minute caching that no_cache controls, no rate/statistics implications, and no note on what a query returns. For a 19-parameter tool this is a thin 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?

A single front-loaded sentence with no filler or repetition. It is efficiently sized, though the brevity borders on under-specification for a tool of this 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?

Given 19 parameters, no output schema, and a mutation-flagged annotation set, the description is far too sparse. It says nothing about pagination behavior, caching semantics, or result shape, leaving the agent to reconstruct the calling contract entirely from 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% with 19 fully documented parameters, including formats for after/before, dups, json, and enumerated type values. The description contributes 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?

The description names a specific verb (查询/query) and resource (Google Patents 专利) and enumerates the data types returned (标题、发明人、申请人、专利号、专利文献数据). This clearly identifies the tool's domain. It stops short of differentiating from the sibling google_scholar, which is relevant since the tool itself can surface Scholar results via the scholar param.

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 phrasing '当用户需要...时触发' functions as an implied trigger condition, which gives some when-to-use signal. However, it offers no exclusions, no prerequisites, and no routing advice versus alternatives like google_scholar or google_search, so an agent must infer the boundary itself.

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 frames the tool purely as a read/retrieval operation ('查询', '获取' lists and details), yet the annotations declare readOnlyHint=false and destructiveHint=true. This is a direct conflict between the described behavior and the declared behavior, with no explanation of what is actually mutated.

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

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

A single front-loaded sentence with no filler, cleanly sized. It is concise, though brevity here comes partly from under-specification rather than disciplined editing.

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 12-parameter scraping tool with no output schema and a contradictory destructive annotation, one sentence is far too thin. Nothing explains the pagination-token family, the chart/section mutual exclusions, the JSON/HTML output modes, or the destructiveHint flag an agent would need to reconcile.

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 12 parameters are all richly documented in the schema itself. The description adds no parameter-level meaning (no mention of q, gl, hl, tokens, chart, or output format), 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 clear verb and resource: querying Google Play apps, games, and store search results to obtain lists, details, or related data. However, it draws no boundary against the closely named siblings google_play_store_information and google_play_store_reviews, so an agent cannot tell from the description alone which of the three to pick.

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 'trigger when the user needs to...' phrasing gives an implied usage context but never states when NOT to use it or which sibling handles app details/reviews instead. The mutual-exclusion rules among chart/token params exist only in the schema, not as guidance here.

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 destructiveHint=true, readOnlyHint=false, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description usefully adds that this is an asynchronous task submission with a fixed collector identifier, but it never says results must be retrieved later (e.g. via scraper_task_status/scraper_task_result) or that repeated calls create new tasks, which is the missing behavioral context.

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

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

Two sentences, front-loaded with the trigger condition before the mechanism, so the routing information comes first. The first sentence is a long bilingual enumeration of near-synonymous keyword variants, which is mildly repetitive but not empty 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 no output schema, the description should carry more of the workflow burden; it explains task submission but not what the call returns (task id/handle) or the follow-up tool needed to fetch results, despite scraper_task_status and scraper_task_result being available siblings. It is adequate for invoking the tool but incomplete for using it end-to-end.

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 app_url and file_name are already documented in the schema; baseline 3 applies. The only added value is tying the collector identifier to the app_url input, which is marginal and does not explain format or override behavior 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 names both the verb (submit a collection/Builder task) and the exact resource (Google Play store information, fixed collector id google-play-store_information_by-url), so an agent knows precisely what happens on invocation. It does not, however, distinguish itself from adjacent siblings such as google_play or google_play_store_reviews, which occupy the same topical space.

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 trigger condition ('when the user needs Google Play store/app information combined with collect/scrape/fetch verbs'), which is implied usage guidance rather than explicit routing. No alternative tool is named for the case of, e.g., wanting reviews or a Play listing without a task submission, so the agent must infer boundaries from the sibling list.

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=false, destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds that a Builder task is submitted and the collector ID is fixed, but it omits the critical async behavior (that results must be retrieved via scraper_task_status/result), which matters given the non-idempotent, destructive flags.

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 opening trigger list enumerates five near-synonyms of 'Google Play reviews' plus five verbs, which is repetitive keyword stuffing rather than information. The functional sentence (Builder task, collector ID) is useful but buried after the trigger enumeration.

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 task-submission tool with no output schema and destructive/non-idempotent annotations, the description should explain the async lifecycle (task creation, then polling for results) and what the returned handle represents. That is entirely missing, leaving a significant gap for correct invocation in a multi-step flow.

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 both app_url and file_name are fully documented in the schema itself. The description adds only that the collector is google-play-store_reviews_by-url; it provides no extra syntax or format detail beyond the schema. 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 action (submit a Builder task to collect Google Play store reviews) and names the fixed collector identifier, which distinguishes it from sibling google_play_store_information. The resource (reviews) is clear, though the front-loaded trigger-keyword list muddies the verb rather than sharpening it.

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?

Gives trigger conditions (user needs reviews combined with collect/scrape/crawl/fetch/extract verbs), which is implied when-to-use guidance. However, it never states when NOT to use it or names alternatives such as google_play_store_information or google_play, so routing against siblings is left to inference.

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

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

The description frames this purely as a query ('查询') operation, i.e. a read of academic results, while the annotations declare readOnlyHint=false and destructiveHint=true. That is a direct inconsistency in the observable behavior an agent would expect, and the description adds no behavioral context (caching via no_cache, rate limits, scraping semantics) to offset it.

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

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

A single, front-loaded trigger sentence with no filler, which is efficient. Its brevity is the main limitation for such a complex tool rather than verbosity, but structurally it is clean and wastes nothing.

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 17-parameter tool with no output schema, the description never explains return format/volume, pagination expectations despite start/num existing, or the interaction of mutually exclusive params (cluster vs q+cites). One trigger sentence is too thin to be complete for this complexity.

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

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

Schema description coverage is 100%, so all 17 parameters (q, hl, lr, num, cites, cluster, start, etc.) are already fully documented in the schema. The description adds no parameter-level meaning beyond what the schema provides, 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 names a specific resource (Google Scholar) and its queryable entities (academic papers, authors, citations, publications, search results), so an agent can tell it targets scholarly search rather than general web search. It does not explicitly differentiate from siblings like google_search or google_patents, but the resource is 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 gives a trigger condition ('当用户需要查询 Google Scholar 学术论文…时触发'), which implies when to use it. However, it offers no exclusions or named alternatives (e.g. use google_search for general pages, google_patents for patents), leaving the agent to infer routing decisions.

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 the full safety profile (readOnlyHint=false, destructiveHint=true, openWorldHint=true, idempotentHint=false), yet the description adds no behavioral context of its own: nothing on billing/response consumption, caching, rate limits, or why a search is flagged destructive. Caching and cost details exist only inside individual parameter descriptions, not here.

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

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

A single front-loaded sentence with no filler or repetition — the trigger condition comes first and the capability list follows. It is dense but every clause maps to real functionality, so nothing needs cutting.

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 18-parameter, open-world search tool with no output schema, the schema-rich parameters plus annotations cover most invocation needs, but the description says nothing about pagination (start), output-format selection (json), or cost implications, and gives no routing among the large family of sibling search 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% across all 18 parameters, including enums, defaults, and mutually exclusive pairs (uule vs location/lat/lon), so the schema carries the semantics. The description only generically alludes to country/language/location/device/time control and adds no syntax or format detail beyond the schema, which is the baseline-3 case.

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 conveys a search of public web pages via Google, with capability categories (country, language, location, device, time filters), so the resource is identifiable. However it is phrased as a trigger condition rather than a functional statement ('当用户需要...时触发'), and it never distinguishes this from the many sibling search tools (bing_search, duckduckgo_search, yandex_search), leaving the core verb and scope only implied.

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 does give a when-to-trigger condition covering general web lookups and filter control, which is a form of usage context. But it offers no when-not-to-use guidance and names no alternative, so an agent gets no help deciding between this, bing_search, or the vertical Google tools (google_news, google_images) for the same query.

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

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

Annotations declare readOnlyHint=false, destructiveHint=true and openWorldHint=true, and the description adds no behavioral context at all — nothing about cost/credits, caching (only the no_cache parameter documents that), rate limits, or pagination behaviour. With a destructive annotation on a query tool, the agent would benefit from clarification, and the description supplies none.

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

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

A single, front-loaded sentence with no filler or repetition. The long enumeration of features is slightly list-heavy but each item corresponds to a real capability, so nothing feels wasted.

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 16-parameter tool with no output schema and a destructive annotation, the description covers only trigger conditions. The schema compensates fully for parameter meaning, but return-format expectations, caching/cost implications and pagination are left to the schema or undocumented, leaving meaningful gaps.

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

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

Schema description coverage is 100% and the schema itself documents every parameter in detail, including cross-parameter rules (shoprs vs q, overrides of shoprs filters, uule vs location). The description adds no parameter meaning 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?

Names a specific resource (Google Shopping 商品搜索结果) and enumerates the abilities: prices, promotions, free shipping, small-business items, price ranges and filters. That is clear enough to identify the tool, but it never contrasts itself with near siblings such as google_shopping_info or bing_shopping, so an agent has no textual basis for choosing between them.

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

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

The sentence is written entirely as a trigger condition, listing concrete situations in which to call it (price lookup, promotions, free shipping, small business, price-range/sort/filter retrieval). This is solid when-to-use guidance, but there are no exclusions or named alternatives when another shopping/search sibling would fit better.

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=false, destructiveHint=true, openWorldHint=true and idempotentHint=false, so the safety profile is covered structurally. The description adds one genuinely useful behavioral fact beyond that: the call submits a Builder task with a fixed collector id, implying an asynchronous job rather than an inline result. It does not say whether submission is repeatable, what the task does to previously collected data, or what is returned.

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, but the first is a padded trigger-word list that duplicates the tool name and title without adding selection value, while the second carries all the real information. Front-loading the actual operation would have made this much tighter.

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

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

There is no output schema, and the agent is not told that submission yields a task handle that must be polled or fetched via the scraper_task_status / scraper_task_result siblings. For a task-submission tool in a large scraper family, that missing downstream step is a real gap in an otherwise simple two-parameter tool.

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

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

Schema description coverage is 100%, so both parameters (keyword, file_name) are already documented including the default and the non-empty requirement. The description adds only the fixed collector identifier, which is marginal context rather than new parameter semantics, 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 second sentence names a concrete verb and resource ('提交 Google 购物信息采集 Builder 任务') and pins the collector id, which tells an agent this submits a scraper task rather than returning product data. However, the opening sentence is essentially a trigger-word expansion of the tool name (Google 购物信息/商品信息/商品数据 + 采集/抓取/爬取), and it never distinguishes this tool from the sibling google_shopping or scraper_serp_products.

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 trigger condition (user wants Google Shopping data combined with collect/scrape/crawl verbs), but that condition is just a restatement of the tool name's own keywords, not a genuine decision rule. It names no alternatives and no when-not-to-use case, even though google_shopping and bing_shopping sit in the same sibling set.

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

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

Annotations exist (readOnlyHint=false, destructiveHint=true, openWorldHint=true, idempotentHint=false), so the bar is lower, but the description adds no behavioral context at all: nothing about 5-minute result caching, the no_cache bypass, quota/cost implications, or how data_type changes the returned shape. There is also an unresolved tension between the read-oriented verb 查询 and annotations declaring destructiveHint=true, which the description never clarifies.

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 short sentence, front-loaded with the trigger condition and enumerating the data categories. Nothing is wasted, though for a 13-parameter tool the extreme brevity means the sentence cannot also carry operational detail.

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

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

This is a high-complexity tool (13 params, 3 enums, multiple output formats via json=1/2/3/4, a data_type enum that fundamentally changes results, and region only valid for certain data types), with no output schema. The description covers none of this and only states a trigger condition, so an agent would have to reverse-engineer behavior entirely from 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% across all 13 parameters, so the schema already documents q, hl, tz, cat, geo, date, json, gprop, region, no_cache, data_type, csv and include_low_search_volume. The description adds no parameter-level meaning beyond what the schema provides. Baseline 3 applies when the schema carries the full 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 names the specific resource and scope: Google Trends trend data, keyword popularity, regional trends, related topics and related queries. An agent can tell this is the Google Trends data tool rather than a generic search tool. It stops short of distinguishing itself from adjacent siblings such as google_search, google_news or google_finance, which also surface trend-like information.

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 entire description is a trigger condition ('当用户需要查询...时触发'), which does imply when to reach for the tool, but it offers no when-not guidance and never names an alternative sibling. With ~80 sibling tools in the catalog, the absence of routing guidance against google_search/google_news is a real gap. Usage is implied rather than explicitly delineated.

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

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

Annotations declare destructiveHint=true, readOnlyHint=false and openWorldHint=true, but the description offers no behavioral context at all — nothing about credit consumption, the 5-minute cache that the schema mentions, rate limits, or why a search operation carries a destructive hint. With such a loaded annotation profile, the description should have carried more explanatory weight.

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

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

A single compact sentence with the purpose front-loaded before the qualifying dimensions. No padding or repetition, though it is somewhat list-like in its enumeration of parameters rather than prioritizing the most important selection cues.

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 14-parameter tool with no output schema, the description is thin: it omits result format/pagination behavior and the cost/credit implications hinted at by the destructive annotation and cache parameter. It is adequate as a trigger statement but not complete enough to call this tool confidently.

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

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

Schema description coverage is 100% with 14 fully documented parameters, so the schema does the heavy lifting and baseline 3 applies. The description only broadly gestures at 'region, language, location, safe filtering, time conditions' without adding syntax, format, or interaction detail (e.g., the uule/location mutual exclusion) beyond what the schema already states.

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

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

The description states a specific verb+resource combination ('通过 Google Videos 搜索视频结果') and enumerates the scoping dimensions it supports (region, language, location, safe filter, time). It is clearly distinguishable as a video-SERP tool, though it never contrasts itself with siblings such as bing_videos or youtube_video, so it falls 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?

It gives trigger conditions ('当用户需要...时触发') and lists the situational dimensions, which is more than implied usage but stops short of explicit when-not guidance. No alternative tool is named for video searches (e.g., bing_videos for Bing, youtube_video for YouTube-native content), leaving the routing decision to inference.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds one useful fact beyond that — that this submits an asynchronous Builder task rather than returning data directly — but says nothing about permissions, rate limits, or what the destructive/non-idempotent behavior actually implies. 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 trigger-keyword preamble ('Indeed 公司信息、Indeed companies info、Indeed 公司列表...') is repetitive padding before the real purpose sentence. The genuinely informative content — the task submission and the four modes — is comparatively short and buried behind it.

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

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

There is no output schema, and for a task-submission tool the description omits the downstream workflow (that the result is later retrieved via scraper_task_status/scraper_task_result). With 7 parameters and four distinct modes, an agent has enough to call it, but not enough to understand the end-to-end flow.

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 each parameter's own description states which spider_id mode it applies to and whether it is required. The description only re-lists the spider_id values, which are already in the enum, so it adds essentially nothing over the schema. 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 second sentence states a specific verb+resource: it submits an Indeed company-info collection 'Builder' task, and enumerates the four supported spider modes. This clearly separates it from sibling company tools like linkedin_company_information or crunchbase_company. The first sentence is keyword-stuffed trigger text that adds noise rather than clarity, keeping it out of 5 territory.

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 trigger conditions ('when the user needs Indeed company info... with verbs like collect/scrape/fetch'), which is a usable when-to-use signal. However it names no alternatives and no when-not-to-use, so an agent cannot tell why it should pick this over linkedin_company_information or a generic web scraper.

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