SupaMarketers Data

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing. It does not mention that behavior is entirely determined by the 'operation' enum (a read/measurement tool), nor anything about auth, rate limits, or data freshness. A single marketing-flavored sentence is insufficient for a 12-operation tool with zero annotation coverage.

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

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

One short, front-loaded sentence with no waste, which is structurally fine. But brevity here comes at the cost of under-specification rather than genuine conciseness; the sentence does not earn its place as the sole guidance for a highly complex tool.

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

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

An output schema exists, so return values need not be explained, which helps. But for a tool with a nested payload, 12 operations, and no annotations, the description omits everything an agent needs to select an operation and invoke it correctly. It is far too thin for this complexity.

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

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

The single top-level parameter is a deeply nested payload with a 12-value operation enum, filters DSL, targets, keywords, and pagination, yet the description adds no parameter meaning whatsoever. A few nested fields (keyword, keywords, language, location, operation) carry short schema descriptions, but the operation enum values — the most consequential choice — are undocumented and the description does nothing to compensate.

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 domain ('AI-assisted search') and three measured dimensions (visibility, mentions, demand), which is more than a restatement of the name. However, it hides that this is a multi-operation dataset dispatcher covering 12 distinct operations (keyword-volume, mention-search, top-pages, history, etc.), and it never distinguishes itself from siblings like search-ads-data, keyword-data, or web-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?

There is no guidance on when to use this tool versus any of the ~34 siblings, nor which conditions map to which operation. An agent cannot infer from the description whether 'AI-assisted search visibility' is the right dataset for a given task. Nothing is stated about prerequisites or exclusions.

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

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

With no annotations, the description carries the full behavioral burden and delivers almost nothing: no indication of read-only nature, rate limits, pagination behavior (limit/offset), or how response_mode='compact' vs 'full' changes output. The only implicit signal is 'Compare', suggesting a read operation.

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

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

One short, front-loaded sentence with no waste. However, brevity here is a symptom of under-specification rather than disciplined editing, so it does not reach 5.

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 a deeply nested payload schema (4 operations, filters, ordering, pagination) and no annotations, the description is drastically incomplete. An agent cannot correctly invoke this tool from the description alone.

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

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

Schema description coverage is 0% and the description compensates for none of it. Critical parameters -- payload.operation (the dispatcher), platform, location, language, filters, order_by, response_mode -- are never mentioned. The single sentence does not explain a single parameter.

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

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

The description names the domain (app rankings, keywords, metrics, competitors) but reads as a list of possible features rather than a precise verb+resource. It fails to state that this is a single dispatcher tool with four operations, leaving the agent to infer that the 'operation' parameter selects the underlying behavior.

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

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

There is no guidance on when to use this tool versus alternatives. The four operation values (bulk-metrics, keywords-for-app, app-competitors, app-intersection) in the schema are not mapped to the feature list in the description, so an agent has no signal about which operation corresponds to which capability.

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

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

No annotations, so the description carries full burden and it does well: it discloses the catalog scope, the api_runnable gate, and the file-upload exclusion. It stops short of noting pagination, auth, or rate limits, but the key behavioral constraint for the agent's decision (which apps are runnable) is stated.

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

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

Three tightly packed sentences with zero filler, front-loading the primary purpose and then the mode-selection rule. Efficient and well-ordered.

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 an output schema exists, the description needn't explain returns; it instead covers the crucial cross-tool relationship (app-list → app-run) and the runnability constraint. Nothing essential is missing 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 0% at the top level, so the description must compensate and it does: it defines slug (single app + input_schema), query (filter), and the summary mode without slug. It adds meaningful semantics beyond the raw nested schema.

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

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

States a specific verb+resource ('List the SupaMarketers Apps') and immediately defines the two modes (summary vs single-app with input_schema). This clearly distinguishes it from siblings like app-run and app-status.

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?

Explicit routing: call without slug for a list, with slug to get input_schema 'needed before app-run'. It also names the precondition for running (api_runnable=true) and excludes file-upload apps. This is textbook when-to-use guidance.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that media files are viewable/downloadable on the website run history page, require login, expire after 30 days, and that the link is included in the response, but it omits whether the tool itself requires authentication, its read-only nature, or any rate/side-effect constraints.

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 front-loaded and appropriately sized. The first sentence states the core purpose and return contents, and the second sentence adds important media-access context without unnecessary 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?

Given that an output schema exists, the description need not explain return values in detail. It covers the key behavioral nuance around media link expiry and login, though it could more explicitly relate this tool to app-status and state whether only succeeded runs are valid inputs.

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

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

The description adds no meaning about the required payload or run_no parameter. The schema contains a nested run_no description ('Run number returned by app-run'), but the reported schema description coverage is 0% and the description does not compensate by explaining the parameter's role or format.

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

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

The description clearly states a specific verb and resource: fetch the result of a succeeded run. It also enumerates return contents (summary, markdown report, media info), which helps distinguish it from a generic status endpoint, though it does not explicitly contrast itself with sibling tools like app-status.

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

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

Usage is implied by 'result of a succeeded run,' which suggests calling it after app-run succeeds, but the description does not explicitly say when to use this versus app-status or app-run. No exclusions or alternative-routing guidance are provided.

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

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

With no annotations, the description carries the full burden and does well: it discloses credit charging, automatic refund on failure, immediate return with run_no, and a 1-35 minute async duration. It stops short of stating auth/permission requirements or whether repeated calls are idempotent, so a small gap remains.

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

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

Three short sentences, front-loaded with what the tool does, followed by cost/return behavior and the handoff chain. No filler and every clause carries actionable 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 an async job-start tool with an output schema and nested objects, the description covers cost, refund behavior, return timing, and the entire poll/result workflow. Missing only edge cases such as insufficient credits or duplicate-run handling.

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 for the top-level parameter is 0%, but the description compensates by pointing to app-list(slug=...) as the source of the exact input fields and by framing inputs as keyed by field id. It does not explain locale or brand_context_id behavior, which the nested schema covers.

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

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

States a specific verb+resource ('Start one SupaMarketers App run') and immediately scopes it as an async job producer rather than a result fetcher. It names the sibling tools it hands off to (app-status, app-result, app-list), so an agent can place it in the workflow without opening any schema.

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

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

Explicitly describes the follow-up sequence: poll app-status, then fetch app-result, and get input fields from app-list(slug=...). The routing condition is stated, not implied, and the sibling alternatives are named with their respective roles.

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

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

No annotations are present, so the description carries the full burden, and it does well: it enumerates the six possible statuses and discloses that failed runs are refunded automatically, which is non-obvious behavior an agent/user would want. It stops short of stating polling cadence, how long 'queued' typically lasts, or whether terminal states are final.

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

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

Three short sentences, front-loaded with the action, then the status vocabulary, then the next-step routing. No filler and nothing buried.

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

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

An output schema exists, so return-value explanation is not required. The description covers the lifecycle vocabulary, the refund side effect, and the follow-up call. Only polling/timing expectations are left unstated, a minor gap for a status-check 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?

There is only one parameter and the nested schema property already documents it ('Run number returned by app-run'). The description reinforces the app-run provenance of the value but adds no syntax beyond that, which is acceptable for a single-param tool.

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

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

States a specific verb and resource ('Check the status of a run') and immediately anchors it to the sibling that creates the run ('started with app-run'). An agent can distinguish this from app-run and app-result without opening any schema.

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

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

Explicitly routes the agent: poll this after app-run, and once the status is 'succeeded', fetch app-result. The failed/canceled/expired terminal outcomes are named, so the agent knows when not to keep polling and when to branch.

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

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

No annotations are provided, so the description carries the full burden. It only implies read-only via "Retrieve"; it says nothing about auth requirements, rate limits, pagination (limit/offset exist), response_mode behavior, or what each operation actually returns.

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 front-loaded sentence with no filler, which is structurally clean. For a tool with a nested payload, five operations, and a dozen fields, however, this brevity reflects under-specification rather than genuine conciseness.

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

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

The tool is complex (nested object, 12+ properties, five operations, operation-dependent requirements), and an output schema exists so return values need not be described. Still, the description gives no operational guidance for such a complex surface, leaving an agent unable to map intents to operations or know which fields are required.

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 effectively 0% for the top-level payload and for most nested fields (operation, platform, collection, response_mode, filters, order_by are undocumented). The single sentence does not explain the payload wrapper, the operation enum values, or how required fields vary by operation, so it fails to compensate for the low coverage.

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

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

The description gives a clear verb ("Retrieve") and resource ("app store") and enumerates four content types (search, listing, details, reviews) that loosely map to the operation enum. It does not differentiate this tool from siblings like app-list, app-intelligence, or app-result, nor mention the platform switch, 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?

There is no when-to-use guidance, no conditions selecting one operation over another, and no reference to any of the many sibling data tools (app-list, app-intelligence, competitor-data, etc.). The agent must infer everything about when this tool is the right pick.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it largely fails. It does not state whether the operation is read-only (implied but unstated), whether it needs authentication or credits, how rate limits behave, or that behavior varies drastically across the 21 operations. A single generic sentence cannot cover a tool whose behavior is this operation-dependent.

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

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

One short sentence is technically concise and front-loaded, but here brevity is under-specification rather than economy. For a tool of this complexity the single line leaves the majority of the contract unstated, so the terseness does not earn 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?

Although an output schema exists (so return values need not be explained), the description is far too thin for a tool with a nested payload, 21 operations, a filter DSL, and no annotations. An agent cannot determine which operation to pick, what filters are valid, or what the pagination defaults mean without reading the raw schema. The description does not bridge that 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 0% and the single 'payload' parameter contains a deeply nested object with 21 enum operations, a rich filter DSL, pagination, date ranges, ordering, and a response_mode toggle. The description's mention of 'links, referring sources, history, intersections' loosely hints at a few operation names but explains none of them and says nothing about filters, targets, ordering, pagination, or response_mode. It does not compensate for the coverage gap.

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

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

The description names the resource (links/backlinks) and gestures at sub-domains ('referring sources, history, intersections'), which loosely maps onto several values in the operation enum. However, 'Analyze' is a generic verb and nothing here distinguishes it from sibling tools like domain-intelligence or competitor-data. It states a purpose without making the tool's specific scope identifiable.

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

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

There is no guidance on when to use this tool versus the 30+ siblings, nor any exclusion or precondition stated. The agent must infer usage entirely from the tool name and the operation enum. No when/when-not information is present.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Retrieve' implies a read, which is the only behavioral fact it conveys; it says nothing about the six operation modes, pagination limits (limit max 1000, offset max 10000), platform defaulting to amazon, or what the compact vs full response modes change.

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 single sentence is front-loaded and wastes no words, which is good, but for a tool with six operations and a deeply nested payload one bare sentence is under-specified rather than concise. It does not mislead, but it is far too small for the surface area it must cover.

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 a nested object payload, six enum-driven operations, and no annotations, the description is materially incomplete: it never tells the agent how to choose an operation or shape the payload. The existence of an output schema excuses it from documenting return values, but everything else an agent needs is missing.

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

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

Schema description coverage is reported at 0%, and the description adds nothing about parameters at all. The only parameter the description even indirectly touches is the product/seller domain; it never explains the required nested 'operation' field or the structure of the payload object, leaving the caller to reverse-engineer a 14-property nested schema.

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

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

Contains a specific verb (Retrieve) and resource (product and seller discovery data from shopping platforms), so the domain is identifiable. However it hides that the tool is a single gateway for six distinct operations (product-search, product-details, product-reviews, seller-search, seller-details, seller-ad-url), and it does nothing to distinguish itself from siblings like product-intelligence or search-ads-data.

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

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

There is no guidance on when to use this tool versus the many overlapping siblings (product-intelligence, market-data, trend-data). No mention that the caller must pick an operation, so an agent has no routing signal beyond the schema enum.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Compare' suggests a read-like operation, but it does not disclose authentication requirements, rate limits, whether data is read-only, how operations differ, or what the required payload operation field does.

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, but for a tool with 12 operations and a nested payload schema this is under-specification rather than useful conciseness. The sentence is front-loaded but omits information an agent needs to decide how to invoke the tool.

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

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

The output schema exists, so return values need not be explained, but the description still omits the multi-operation nature, the required payload wrapper, and the required operation selector. For a tool of this complexity, the one-line description is not complete enough to support confident selection and invocation.

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

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

The description mentions no parameters at all, even though the single required top-level payload contains a required operation enum and many nested fields. Context reports schema description coverage at 0%, so the description should compensate but adds no parameter meaning beyond what the schema itself defines.

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 resource area ('organic competitors, rankings, pages, estimated traffic') and a broad verb ('Compare'), so the general domain is clear. However, it does not reflect that this is a multi-operation tool with 12 distinct operations, and it does not differentiate from siblings such as keyword-data, domain-intelligence, or market-data.

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

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

There is no explicit when-to-use guidance, no when-not-to-use guidance, and no named alternative among the many sibling data tools. The description only implies that it is for competitor comparison, leaving the agent to infer operation selection entirely from the schema.

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

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

No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about the six operation modes, read-only nature, rate limits, pagination, or what 'response_mode' compact vs full means. Only the verb 'search/aggregate' weakly implies a read operation.

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

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

One short sentence with no waste, but the brevity comes at the cost of under-specification rather than tight expression. It is not front-loaded with anything actionable.

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?

An output schema exists, so return shape needn't be explained, but for a tool with a complex nested payload, six operations, and zero annotations, the description leaves the agent without the operational context needed to invoke it correctly.

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

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

The single top-level parameter is a deeply nested payload with ~16 fields and six-valued operation enum, and schema description coverage is 0%. The description never mentions 'payload' or any operation, so it contributes essentially no meaning beyond the structured 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?

States a verb ('search and aggregate') and a broad resource ('public content, sentiment, and trends'), but the scope is fuzzy and it never distinguishes itself from overlapping siblings like trend-data, keyword-data, or the social-* search tools. It reads more like a category label than a distinct operation.

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

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

No when-to-use guidance, no prerequisites, and no mention of which sibling to prefer for a given task. With 33 siblings that include several trend and social-search tools, this omission forces the agent to guess.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it says almost nothing: no indication that these are read-only lookups, no note on pagination (limit/offset are in the schema but unexplained), no rate-limit, no response_mode implications. 'Inspect' weakly implies a read, which is the only behavioral signal present.

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

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

One short sentence with no waste, but this is under-specification rather than conciseness. A tool with six operations, nested filter objects, and 20+ fields needs far more text before brevity becomes a virtue.

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 a nested schema with an operation enum, filter grammar, pagination, and no annotations, the description omits essentially everything the agent needs. The existence of an output schema excuses it from describing return values, but not from explaining operations and inputs.

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

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

Schema description coverage is 0% and the description adds nothing about any parameter. Critically, the six-value 'operation' enum — the single field that determines what the tool does — is completely unexplained, as are the nested 'filters' grammar, pagination, and date range fields. An agent cannot choose an operation or construct a valid payload from the description.

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 verb ('Inspect') and two resource areas ('domain technologies', 'registration intelligence'), which is more than a tautology. However, it never names the six distinct operations the tool actually exposes (technology-summary, whois, domains-by-technology, etc.), so an agent cannot tell what a call to this tool really produces. It also fails to distinguish itself from the many sibling '*-intelligence' and '*-data' tools.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives among the large sibling set (app-intelligence, product-intelligence, backlink-data, etc.). The agent is left to infer that this is for domain/tech lookups purely from the name.

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

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

With no annotations, the description carries the full burden, yet it only implies single-image output and mentions 'commercial-grade' (a usage-rights hint). It omits cost, latency, moderation/content-policy behavior, output format or size, and auth requirements for a paid generation endpoint.

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

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

A single front-loaded sentence with no filler; the key constraints (one image, optional references) are stated up front and 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?

The existence of an output schema excuses it from describing return values, but for a generation tool with a nested payload and an opaque 'reference_image_keys' array, the agent is left without guidance on obtaining keys, aspect-ratio tradeoffs, or operational constraints. The definition is too thin 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 0%, so parameter meaning must come from the description. It clarifies that the prompt is the input and that reference images are optional, but never mentions aspect_ratio or explains what a 'reference_image_key' is or how to obtain one. Partial compensation only.

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 ('Generate ... image') plus the distinguishing scope modifier 'one' and 'commercial-grade', which sets it apart from the sibling video-generation and from any batch tool. It does not name an alternative explicitly, but the purpose is unambiguous without opening the schema.

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

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

There is no when-to-use guidance, no prerequisite (e.g., where reference_image_keys come from), and no exclusion criteria or named alternative. The agent can infer image generation from the name, but the description adds no routing information.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: no read-only confirmation, no pagination/limit behavior, no rate limits, no auth or cost profile, no note on what response_mode compact vs full changes. A single vague sentence is inadequate for a multi-operation research tool.

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

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

It is a single short sentence with no preamble, so it is structurally clean and front-loaded. However it is under-specified rather than genuinely concise, trading away needed detail for brevity.

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

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

For a tool with 12 operations, nested filter/order objects, and an output schema, the description is far too thin. It never explains the operations, the compact/full response modes, or how keyword vs keywords are chosen, leaving significant gaps even though return values are covered by the output schema.

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

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

The description adds no parameter meaning at all. While the nested schema does carry descriptions for operation, keyword, keywords, language, location, and target, the top-level payload and remaining fields (filters, order_by, date ranges, include_clickstream_data) are undocumented, so the description does not compensate for the stated coverage gap.

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

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

The verb 'research' is vague, but the resource is clearly keyword data and the description enumerates the sub-capabilities (demand, ideas, difficulty, intent, history) which roughly map to the 12-operation enum. It does not differentiate this tool from keyword-adjacent siblings such as trend-data or search-ads-data, leaving the agent to guess at boundaries.

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

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

There is no explicit when-to-use, when-not-to-use, or alternative-tool guidance. With 12 operations available under a single payload, the description gives no hint of which operation suits which research goal, which is the primary selection problem an agent faces 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?

No annotations are provided, so the description carries the full behavioral burden, yet it only implies a read operation ('Retrieve') and discloses nothing about pagination (limit/offset defaults), rate limits, or result shape. For a tool wrapping 12 distinct operations, this is a substantial transparency 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 short sentence that is front-loaded and free of filler. It is efficient, though its brevity is a symptom of under-specification rather than disciplined scoping.

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 an output schema present, return values need not be explained, but a tool exposing 12 operations and a deep nested payload demands far more than one sentence. Nothing tells the agent how the operation enum, filters, or platform targeting interact, leaving the definition materially incomplete.

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

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

Schema description coverage is 0%, so the description is expected to compensate for the very complex nested payload, but it adds nothing about operation, filters, targets, platform, or language semantics. The only partial relief comes from a handful of inline schema descriptions (operation, target, keyword, language, location), not from the description text.

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 clear verb ('Retrieve') and enumerates the resource domains (local business, hotel, review, reputation data), which an agent can map to the four operation families in the enum. It is clear on its own but does no explicit sibling differentiation (e.g., vs. social-google-maps-search or competitor-data), 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?

There is no when-to-use guidance, no mention of the 12 available operations, and no alternatives named. An agent cannot tell from the description which operation to select or when to prefer this tool over a sibling.

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

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

No annotations are provided, so the description must carry the full behavioral burden, but it only says 'Analyze.' It does not disclose whether the tool is read-only, what permissions are needed, how the five operation modes behave, or any rate limits. This is insufficient for a complex nested-operation tool.

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

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

The single sentence is technically concise and front-loaded, but it is far too sparse for a tool with five operations and a deeply nested payload. It omits structure and critical details rather than being efficiently informative. The brevity here reflects under-specification, not good concision.

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

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

Given the complex nested input schema, multiple operation enum values, and no annotations, the description is critically incomplete. It does not explain the operations, parameter meanings, or when the tool should be selected. An output schema exists, so return values need less explanation, but the description still fails to cover the essential input and usage context.

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

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

The description adds no meaning beyond the input schema and does not mention the required payload, operation, or any of the nested filtering and pagination parameters. Schema description coverage is reported as 0%, so the description needed to compensate and fails to do so. An agent cannot infer parameter usage from the description alone.

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

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

The description gives a broad verb ('Analyze') and vague objects ('search categories and market-level demand'), but it does not name the specific operations or data types the tool returns. It fails to distinguish the tool from siblings such as keyword-data, trend-data, or domain-intelligence. The purpose is slightly more than a tautology, but still too vague for reliable selection.

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

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

There is no guidance on when to use this tool versus the many sibling tools, nor any mention of prerequisites or alternatives. The description provides no context about which operations or scenarios it supports. An agent has no basis to choose this tool over keyword-data, trend-data, or others.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state cost, processing time, credit consumption, whether media_key must reference an already-uploaded asset, or the read-only nature of the operation, leaving key behavioral traits undisclosed.

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

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

A single front-loaded sentence with no filler; the purpose is stated immediately. It is tight and well-structured, though it could carry slightly more operational detail without bloat.

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

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

For a tool with a nested payload, an enum, default values, and no annotations or output schema detail on parameters, the description is too thin. While an output schema exists (so return values need not be described), the input semantics and behavioral context are largely missing.

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

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

Schema description coverage is 0% and the payload is a nested object. The description's mention of 'shot script or ad-pattern breakdown' loosely maps to the analysis_kind enum, but media_key, focus, and target_duration_seconds (with its 3-15s constraint) are entirely unexplained in either the schema or the description.

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 (Analyze) and resource (reference video or image) with a named output (shot script or ad-pattern breakdown), which differentiates it from generation siblings like video-generation and image-generation. It does not explicitly contrast with content-analysis, so it falls just short of a 5.

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

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

The phrase 'for generation workflows' implies this is a pre-processing step before generation, giving implied usage. However, it names no alternatives and gives no explicit when-not conditions (e.g., when to use content-analysis instead).

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

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

With no annotations, the description carries the full burden but only states output formats. It does not disclose read-only behavior, authentication requirements, rate limits, timeout behavior, error handling, or what happens when extraction fails.

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 with zero wasted words. It states the verb, resource, and output formats immediately.

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 a nested required payload with seven properties and zero schema descriptions, the description is far too thin. Although an output schema exists and return values need not be explained, the input behavior and option semantics remain largely undocumented.

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

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

Schema description coverage is 0%, so the description must compensate. It only references the output_format enum values (markdown/html/text) and leaves the required url plus include_links, include_images, timeout_seconds, include_metadata, and main_content_only undocumented.

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 ('Extract'), resource ('one page'), and output formats ('markdown/html/text'). The word 'one' implicitly distinguishes it from the sibling page-extract-batch, though it does not name the alternative explicitly.

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

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

No guidance is given on when to use this tool versus alternatives, prerequisites, or when not to use it. The scope 'one page' is the only contextual clue.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only discloses the 20-page cap. It says nothing about authentication, rate limits, partial-failure behavior, or how concurrent URLs are processed — significant gaps for a batch operation.

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 wasted words. It is efficient, though arguably too terse given how much about the tool is left unspecified.

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?

An output schema exists so return values need not be explained, but with zero annotation coverage, zero schema description coverage, and a nested payload object, the description is far too thin. It omits parameter meaning and operational constraints an agent needs to invoke it correctly.

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

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

Schema description coverage is 0% and the single parameter is a nested payload object. The description restates the max-20 limit (which the schema already encodes via maxItems) but says nothing about the urls, formats, or only_main_content sub-parameters, leaving them undocumented.

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 (extract) and resource (pages) plus the batching scope ('up to 20 pages in one batch job'). This implicitly distinguishes it from the single-page sibling page-extract via 'batch', though it never names that sibling explicitly.

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

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

Gives no when-to-use guidance and never mentions the single-page alternative page-extract. The only implied guidance is 'batch' vs single, which the agent must infer from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: no mention that behavior is entirely driven by the nested 'operation' field, no note on pagination defaults, response_mode semantics, or permission/data-source requirements. Only the words 'ranks' and 'demand' hint at read-only analytics, and even that is inference.

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

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

It is a single tight sentence, so it is not bloated, but the brevity is under-specification rather than economy. For a six-operation tool the one-liner leaves the agent guessing.

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 a complex nested schema, an output schema present, no annotations, and 0% parameter coverage, the description is far too thin. It does not explain the operation-dispatch model, parameter expectations, or any behavioral constraint, so the agent must reverse-engineer everything from the JSON 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?

Reported schema description coverage is 0% against a large nested payload (operation, filters, keyword/keywords, language, location, order_by, product_id(s), limit, offset, response_mode). The description adds no meaning for any parameter — it does not explain that 'operation' selects the dataset, or clarify keyword vs keywords, language-as-code, or response_mode.

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 generic verb ('Analyze') and the domain ('product') with loose topical hints (keywords, ranks, demand, competitors), but never names the six discrete operations the tool actually dispatches (keyword-intersection, bulk-search-volume, related-keywords, ranked-keywords, rank-overview, product-competitors). An agent cannot tell from the text how this differs from siblings like keyword-data or competitor-data.

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

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

There is no indication of when to pick this tool over the many sibling data tools (keyword-data, competitor-data, market-data, app-intelligence), nor which operation to select for a given goal. Usage is only implied by the operation enum buried in the schema.

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

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

With no annotations, the description carries the full behavioral burden. It implies a read-only retrieval operation, but gives no information about authentication needs, rate limits, response behavior, or how the required nested payload affects execution.

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 single sentence is front-loaded and not verbose, but it is under-specified for a tool with five operations and a large nested payload. Its brevity reflects missing information rather than efficient concision.

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

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

The tool is complex, with a nested payload, multiple operation types, many optional parameters, and no annotations. The description does not cover any of that complexity or tell the agent how to invoke it correctly; only the output schema is pre-provided.

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

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

Schema description coverage is 0% for the top-level parameter, and the description adds no meaning beyond 'data.' It does not mention the required payload object, the operation enum, filters, pagination, or any other parameter constraints.

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

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

The description states a verb ('Retrieve') and a broad resource ('search advertising and audience demand data'), but the resource is vague and overlaps with many siblings such as keyword-data, market-data, and competitor-data. It does not identify which operation or dataset is being accessed.

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

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

The description gives no guidance on when to use this tool versus alternatives, and it names no sibling tools or conditions. It provides only a generic purpose statement.

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

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

No annotations are supplied, so the description carries the full behavioral burden, and it discloses almost nothing: no mention that it is a read-only retrieval, no pagination/limit behavior, no engine or device scoping, no indication that the payload selects among nine distinct datasets. 'Retrieve' weakly implies read-only, but that is the only signal.

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 eight-word sentence with no wasted clauses, but its brevity comes from under-specification rather than tight writing. It is front-loaded but too thin for the tool's complexity.

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

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

An output schema exists so return values need not be explained, but for a tool with a required nested payload, nine operations, a filter DSL, and pagination options, this one-line description leaves an agent without enough to invoke it correctly.

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

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

Schema description coverage is effectively 0% at the top level (a handful of nested fields carry their own descriptions), and the description adds no meaning about the payload wrapper, the operation enum, the filters DSL, or ordering. Given the low coverage the description should have compensated and does not.

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 verb ('Retrieve') and a resource ('structured search result pages') but 'search features' is vague and the definition never distinguishes this tool from the many sibling search tools (web-search, ai-search-data, social-*-search, search-ads-data). An agent cannot tell from this text which search surface this covers.

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

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

There is no statement of when to use this tool versus the large sibling set, no prerequisites, and no mention of the nine operations (organic, maps, news, images, etc.) that determine its behavior. Only the tool name implies usage.

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

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

No annotations are provided, so the description carries the full behavioral burden and delivers none of it. It doesn't disclose whether crawling is long-running or async, whether it respects robots.txt or requires auth, rate limits, or whether an audit mutates state. Only the verb 'crawl' faintly hints at scope/expense.

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 single sentence is front-loaded and free of filler, which is good. But it is undersized for a tool with 17 distinct operations and a deeply nested payload schema, so the brevity comes at the cost of missing essential detail rather than being appropriately economical.

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 high-complexity tool with no annotations and a nested multi-field payload, one sentence is far too thin. The existing output schema reduces the need to describe return values, but nothing in the description helps the agent select an operation or understand crawl scope, so the definition is incomplete for its 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 0% (only the operation enum has an inline description), and the description adds nothing about any parameter. Critical nested fields like filters, order_by, page_url, max_crawl_pages, enable_javascript, and response_mode are left entirely to the raw schema, and the 17 operation semantics are undocumented.

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 clear verb pair (crawl/inspect) and resource (website) with a stated goal (technical and content issues). However, it offers no differentiation from heavily overlapping siblings such as site-map, page-extract, content-analysis, and domain-intelligence, so an agent cannot tell which tool to pick from the description alone.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no pointer to alternatives. The 17-value operation enum (summary, pages, links, lighthouse, screenshot, etc.) is never explained, so the agent gets no help deciding which operation addresses its 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?

No annotations exist, so the description carries the full behavioral burden, and it discloses almost nothing: it implies a read-only listing but never mentions whether it fetches the domain's sitemap.xml, crawls links, is rate-limited, or respects robots. The parameter-driven behaviors (sitemap_mode include/skip/only, subdomain expansion, query-parameter collapsing, 1000-URL cap) are entirely invisible.

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 with no wasted words, but the terseness here reflects under-specification rather than discipline: a tool with six nested options and an enum gets no structural elaboration despite ample room.

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?

An output schema exists so return values need no explanation, but a tool with a required wrapper object, a mode enum, and subdomain/query-normalization flags needs far more than one sentence. An agent could not correctly set sitemap_mode or predict result scope from this description alone.

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

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

Schema description coverage is 0%, so the description must compensate, but it only gestures at 'domain' and 'site URLs' — loosely hinting at the url field and sitemap semantics. The six nested payload options, especially the sitemap_mode enum and include_subdomains/ignore_query_parameters toggles that materially change the result set, are never explained anywhere.

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 concrete verb+resource: 'List site URLs for a domain.' An agent can tell this produces a URL inventory rather than a full audit (site-audit) or a page fetch (page-extract). However, it does not explicitly contrast itself with the closest siblings, 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?

There is no when-to-use guidance, no prerequisites, and no named alternative. The description never says why an agent would choose site-map over site-audit, page-extract, or search-results, leaving selection entirely to inference from the name.

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

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

With no annotations, the description carries the full behavioral burden. It implies a read/collection operation and that only public group content is returned, which is useful, but it omits auth requirements, rate limits, whether collection is synchronous, and pagination 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 efficient sentence with the key constraint (public Facebook Group posts) front-loaded. No padding or redundancy, though it is arguably too terse given the tool's complexity.

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

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

An output schema exists so return values need not be described, which helps. But for a nested, five-field collection tool with zero annotations, the description leaves the 'approved URLs' precondition and the operational behavior unexplained, making it only minimally adequate.

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

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

Schema description coverage is 100%, so the schema itself documents the nested payload fields. The description only adds 'approved URLs', mapping loosely to the urls array, and offers no meaning for limit, offset, results_limit, or only_posts_newer_than beyond what the schema already conveys.

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 ('Collect') and resource ('public Facebook Group posts'), and the platform implicitly distinguishes it from social-reddit-search and social-linkedin-search. However, 'approved URLs' is left undefined, so the exact input contract is not fully clear from the purpose statement 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?

The description gives no when-to-use guidance, no conditions that select this tool over its social-* siblings, and no explanation of what makes a URL 'approved'. The only hint at a precondition ('approved URLs') is stated without elaboration.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only public search, but does not disclose authentication requirements, rate limits, pagination behavior, or how results are scoped. The nested payload also receives no behavioral 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?

The description is a single front-loaded sentence with no filler or redundancy. For a focused search tool, this is appropriately sized and immediately communicates the core operation.

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

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

The tool has a rich nested schema and an output schema, so the description need not explain parameters or return values. However, it lacks usage guidance and sibling differentiation, leaving an agent to infer when this Google Maps search is preferable to related local-business or social 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 reported as 100%, so the structured schema is expected to document parameters effectively. The description adds a small amount of meaning by mapping 'category' and 'location' to search_terms and location_query, but it does not explain optional parameters like limit, offset, max_places, or skip_closed_places.

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

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

The description gives a specific verb and resource: 'Search public Google Maps business listings' by category and location. This is clear and distinct from generic web search or social network searches, but it does not explicitly differentiate from the sibling tool 'local-business-data', which may cover similar 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?

There is no guidance on when to use this tool versus alternatives such as local-business-data or other social-* search tools. The description states what it searches but not when it is the right choice or what its limitations are.

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

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

With no annotations, the description must carry the behavioral burden, and it does disclose the auth model (no credentials/cookies required) and that only public profiles are returned. However it omits rate limits, result caps, and any note on the nested payload's pagination behavior (offset/limit/max_items/take_pages), leaving real 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?

A single front-loaded sentence with no filler, which is efficient. It is arguably under-specified rather than concise, but as a structure it is clean and immediately readable.

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

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

An output schema exists, so return values need not be explained. Yet for a tool with a nested 6-parameter payload and zero annotations, the description is thin: no usage routing, no pagination semantics, and no mention of result scope limits, leaving the agent to infer behavior from the schema alone.

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 reported at 100%, so the schema already documents the nested payload parameters, and the baseline is 3. The description adds no parameter-level meaning (e.g., how query maps to LinkedIn search or how take_pages interacts with limit/max_items), so it does not rise above 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?

States a specific verb and resource ('Search public LinkedIn company profiles'), which is clear and actionable. It distinguishes itself from the sibling family implicitly by naming LinkedIn, but never names or contrasts with the closest alternatives (social-facebook-search, social-google-maps-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?

There is no statement of when to use this tool versus the many sibling social/search tools. The phrase 'without credentials or cookies' hints at an access model but does not tell the agent under what conditions this is the right choice over web-search or social-*-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?

No annotations are provided, so the description carries the full behavioral burden. It hints that only public data is touched (a mild read-only signal), but discloses nothing about auth requirements, rate limits, or what happens when queries/subreddits/urls are combined.

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. It is efficient, though the brevity contributes to the vagueness noted in other dimensions.

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?

An output schema exists, so return values need not be described, and the 100% coverage schema handles the nested parameters. The description adequately frames the tool's scope but omits how the discovery, rules, and thread-evidence aspects relate to each other for a fairly complex 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 nested payload schema already documents all eight sub-fields with types, enums, defaults, and bounds. The description adds no parameter meaning beyond the schema, meriting 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?

States a specific verb (Research) and enumerates the resources it touches (public Reddit communities, rules, posts, comments), which maps to the payload's discovery/rules/thread fields. It does not, however, distinguish itself from the sibling social-reddit-search or social-reddit-voc-search tools.

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

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

The phrase 'for community selection and participation planning' implies a use context, but there is no explicit when-to-use guidance and no naming of alternative tools like social-reddit-search. Usage 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that only public subreddits are searched, but does not mention authentication requirements, rate limits, pagination, default sorting behavior, or what the results contain.

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

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

The description is a single, front-loaded sentence with no wasted words. It is concise, though its brevity contributes to the lack of operational detail for a complex nested input 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?

An output schema exists, so return values need not be explained. However, the input schema is nested and complex with zero property descriptions, and the tool description supplies no guidance on required parameters, filtering options, or behavioral limits, leaving the agent under-informed 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 0%, and the description mentions no parameters at all. The nested payload includes queries, subreddits, sort, limit, timeframe, and other fields, but the description provides no semantic guidance for any of them.

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

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

The description states a specific verb ('Search') and resource ('Reddit posts and comments') with a scope ('across public subreddits'). It distinguishes the tool from general web search, but does not differentiate it from close siblings like social-reddit-community-research or social-reddit-voc-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 description gives no explicit guidance on when to use this tool versus alternatives such as social-reddit-community-research or social-reddit-voc-search. Usage is only implied by the word 'Search' and the public-subreddit scope.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it is a single sentence. It does not state that this is a read-only harvest, whether it is rate-limited or billed, how pagination/offset interacts with the caps, or how the subreddit-count modes behave. Only the schema description hints at some of this, not the tool description.

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 well-formed sentence, front-loaded with the action and resource, with no filler. It is arguably too terse for a ten-parameter tool, but there is no wasted language.

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?

An output schema exists, so return values need not be explained, and the rich nested schema covers parameters. Still, for a multi-mode harvest tool with zero annotations, the description omits the behavioral envelope (read-only nature, caps, mode semantics), 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%, and the nested payload schema fully documents queries, subreddits, date window, and caps, so the schema does the heavy lifting. The description adds no parameter-level meaning beyond that, which is the expected baseline of 3.

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

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

Clear specific verb+resource: 'Harvest Reddit posts and per-post comments,' plus the intended purpose (voice-of-customer analysis). It implies differentiation from social-reddit-search by harvesting comments as first-class evidence, but never names or contrasts a sibling explicitly.

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

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

Usage context is implied by 'for voice-of-customer analysis,' which tells the agent this is the VOC-oriented Reddit harvest. However, no when-to-use/when-not guidance and no mention of the near-identical siblings (social-reddit-search, social-reddit-community-research), leaving the agent to infer which Reddit tool to pick.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Measure' weakly implies a read-only lookup, but nothing states rate limits, quota costs, whether results are cached, or how pagination/response_mode behave. For a complex nested-payload tool with zero annotation coverage this is a significant 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, which is structurally clean. But it is under-specified rather than concise for a tool with nested filters, six operations, and pagination controls, so brevity here costs more than it saves.

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

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

The tool is high-complexity (nested payload, filter DSL, order_by, pagination, six operations) and the one-sentence description covers none of it. An output schema exists so return values need not be described, but operation selection, time_range defaults, and response_mode semantics are absent.

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?

Only one top-level parameter exists (payload) with 0% schema description coverage, and the nested 'operation' enum of six values is completely unaddressed by the description. The words 'time, region, and demographics' loosely gesture at time_range, location, and the demographics operation, but add no syntax, defaults, or selection logic beyond what the schema already encodes.

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 ('Measure') and resource ('keyword interest') and enumerates the three analytical dimensions: time, region, and demographics. However, it never differentiates itself from the sibling keyword-data tool, so an agent must infer that this tool is the trend/time-series view rather than the volume/metrics view.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the keyword-data sibling that plausibly covers overlapping ground. The agent gets no signal about which of the six operation modes to pick or when this tool is the wrong choice.

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

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

With no annotations, the description carries the full behavioral burden and falls short: it says nothing about whether this is a long-running/async job, cost or rate limits, audio behavior by default (generate_audio defaults true), or what the reference keys must point to. It only restates the capability.

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 waste. It is efficient, though efficient to the point of under-specification for a generative tool.

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

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

An output schema exists, so return values need not be explained, but a generative tool with a nested object, 0% schema coverage and no annotations requires far more than one sentence about behavior, async semantics and optional inputs.

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

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

Schema description coverage is 0% on a nested payload with six sub-properties. The description mentions the prompt, reference images and reference video but omits aspect_ratio, generate_audio, and reference_audio_key, and gives no format hints for the reference keys.

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 (Generate) and resource (short video clip) with the driving input (a prompt). It implicitly separates itself from image-generation by naming video, but it does not explicitly name or differentiate against that sibling.

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

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

No guidance on when to prefer this over image-generation or media-analysis, no prerequisites, no indication of typical runtime or async behavior. The agent is left to infer usage entirely from the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only vaguely states 'normalized results'. It says nothing about rate limits, caching, query length constraints, or how include_content changes behavior. Only the output schema offsets the return-format 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 no padding or repetition. However, the terseness borders on under-specification for a tool with this much nested structure rather than true economy of 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?

An output schema removes the need to describe returns, but for a search tool with nine undocumented nested parameters, no annotations, and many competing siblings, the definition is far too thin about when and how to call it.

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

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

Schema description coverage is 0%, so the description should compensate, but it explains none of the nine nested payload fields (topic, time_range, include_domains, exclude_domains, include_content, etc.). Parameter names are largely self-descriptive, but semantics like default value meaning and mutual include/exclude behavior are undocumented.

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 (Search) and resource (the public web) plus an output trait (normalized results). It is distinguishable from social-* search siblings and page-extract, but it never names or contrasts with the closest alternatives like search-results or ai-search-data.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives despite a large sibling set of competing search tools. The agent is left to infer everything about routing.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Public' hints that no private/auth-scoped data is returned and 'Retrieve' implies read-only, which is worth some credit, but rate limits, pagination ceilings (limit max 1000, offset max 10000), and the effect of response_mode are never disclosed.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though for a tool with this much nested complexity the brevity edges toward 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?

An output schema exists, so return values need not be explained, but this is a multi-operation tool with nested filter and ordering objects whose semantics, pagination behavior, and per-operation input requirements are entirely absent. An agent cannot reliably choose an operation or construct a filters/order_by payload from this description.

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?

Top-level schema description coverage is 0%, and the description explains none of the substantive parameters: filters (a complex anyOf/operator structure), order_by, limit/offset, response_mode, and video_id are undocumented in both the description and, largely, the schema. Only keyword/language/location carry inline descriptions, so the description fails to compensate for the coverage gap.

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

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

States a specific verb ('Retrieve') and resource ('public video') and enumerates the four data types covered (search, details, subtitles, comments), which maps directly to the operation enum. It does not differentiate itself from siblings like media-analysis or the social-* search tools, 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?

No guidance on when to choose this tool over siblings, nor which of the four operations to select for a given intent. The operation enum label ('Which dataset operation to run') gives no selection criteria, so the agent must infer everything.

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