AIsa SEO & AI Visibility

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

Annotations already declare destructiveHint=true and openWorldHint=true, so safety is covered. The description adds valuable behavior: independence of items (one failure doesn't cancel others) and per-call billing. These are not derivable from annotations and help the agent set expectations.

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

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

Three short sentences with zero filler. The action and limit are front-loaded. The phrase 'tool-router's batch_use' is redundant since it restates the tool name, but it's a minor flaw. Overall it is concise and well-structured.

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

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

With annotations covering destructive behavior and an output schema presumably describing results, the description covers the key operational aspects: concurrency limit, independence, and billing. It doesn't mention error reporting formats, but those likely live in the output schema. It is sufficiently complete for a batch tool.

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

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

Schema description coverage is 100%, so the schema fully documents each parameter. The description adds no parameter-specific details. The calls parameter's description already explains the structure and batching context, so the baseline of 3 applies; the description doesn't need 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 clear action (execute) and resource (operations) with a concrete limit (up to 20) and concurrency. It doesn't explicitly name the sibling 'use' for single operations, but the distinction is clear enough from the concurrency and limit. The redundancy of 'tool-router's batch_use' is minor.

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 the sibling 'use' tool. The schema note about 'steps at the same execution_level of a plan go in one batch' is helpful, but it lives in the schema, not the description. The description only implies batching via concurrency but doesn't state when to choose it over the single-operation alternative.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds valuable non-obvious context by disclosing the $0.02 per-call billing and that 4xx/5xx responses are not charged.

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

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

Two tight sentences deliver the core behavior and the billing caveat with no filler. The main purpose is front-loaded and every clause adds information.

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

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

For a simple read-only tool with only two required parameters, an output schema, and rich annotations, the description is complete: it states the returned metrics, target/date scope, and cost behavior. Nothing essential is missing for an agent 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 100%, so both 'target' and 'date' are already fully documented in the schema. The description restates these concepts without adding new format, default, or edge-case details, so the baseline of 3 applies.

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

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

The description names a specific verb ('Return'), a specific resource (Ahrefs Domain Rating and Ahrefs Rank), and the exact scope (target domain, given date). It clearly differentiates from siblings like get_semrush_domain_overview and get_similarweb_ranking by calling out the Ahrefs-specific metric.

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 choose this tool over the many sibling SEO/metric tools, nor does it mention exclusions or alternatives. The use case is only implied by the Ahrefs-specific naming.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, so the description's burden is lighter. It adds meaningful behavioral context: the $0.18 per successful call charge and that 4xx/5xx errors are not billed, which informs cost-aware invocation beyond what annotations provide.

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

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

Two tight sentences with no filler. The first sentence leads with the action and enumerates the returned metrics; the second adds the billing caveat. Every clause earns its place.

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

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

For a simple read-only, two-parameter lookup with an output schema, the description covers the essentials: the action, parameters, and cost behavior. The 4xx/5xx note partially addresses error responses, though a brief mention of invalid-target behavior would make it fully complete.

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

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

Schema description coverage is 100%, and both required parameters (target, date) are already documented with formats and examples. The description restates 'target domain' and 'given date' but adds no new semantic detail beyond the schema.

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

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

The description clearly states 'Return core Site Explorer metrics' for a target domain and enumerates the exact metrics (organic/paid keyword counts, top-3 keyword count, organic traffic, traffic value), making the resource and scope precise. However, it does not explicitly contrast with sibling tools like get_ahrefs_domain_rating, 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?

No guidance is given about when to choose this tool over alternatives; it doesn't mention any sibling, exclusion criterion, or prerequisite. The only extra context is billing, which is not usage direction, leaving selection to inference.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so safety is covered. The description adds one piece of real context — that the site must already have been scanned, implying the task id refers to a completed Task POST — but says nothing about result freshness, pagination, or failure states of an incomplete task.

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

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

Two sentences, but the lead-in 'Using this function, you can' is pure filler before the actual content arrives, and 'drill down into exact on-page issues' overstates what a summary endpoint returns. The second sentence carries the real value and should have led.

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 and read-only annotations, return values and safety need no explanation here. What is missing is sibling routing among the many get_*/post_* OnPage tools, which is the main open question an agent would have when selecting this 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 one parameter with 100% schema description coverage, and the schema already explains that 'id' is the task identifier obtained from the Task POST response. The description adds nothing about the id, so the baseline 3 for full schema coverage applies.

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

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

The description states a recognizable verb+resource: retrieving overall on-page information for a website that has been scanned. It frames the result as a summary view that precedes the detail tools, which gives it an identity distinct from the post_* detail endpoints. It does not, however, explicitly distinguish itself from the generic sibling get_details.

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

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

It implies a workflow — call this first to learn which functions to use for detailed data on each issue — which is genuinely useful routing context. But it never names an alternative tool or states an explicit when-not condition, so the guidance stays at the implied level rather than actionable selection criteria.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful context: it is free, stops before any spend, and explains how price.model varies (quoted, list, dynamic, composed). It also clarifies that suggested_max_price_usd has headroom. This goes beyond the annotation flags and gives the agent a clear model of what happens.

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 moderately long but well structured: it opens with the core purpose, then explains the price model in a dedicated paragraph. No redundancy or filler. It front-loads the most critical information (contract fields) and then gives necessary detail about price semantics. Slightly dense but not overly verbose.

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 an output schema, so return values need no description. The description covers the key behavioral aspects (no spend, pricing models, max_price headroom) and clarifies edge cases like routes without a price. For a read-only informational tool, this is complete enough for an agent to use it correctly.

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

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

Schema description coverage is 100%, so parameters are already documented. The description adds some nuance, such as how arguments affect pricing and that required parameters may be needed before a price can be quoted. It also clarifies with_quote's purpose (one round trip, spends nothing). These are useful but not essential given the schema's completeness.

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 purpose: returning the full contract of one or more operations, including schemas, read_only, side_effects, price, and known_pitfalls. It clearly distinguishes this from executing operations (use, batch_use) and from discovery (search, list_categories). The verb 'get' and the noun 'details' align with the title, and the first sentence is explicit.

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

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

The description implies the tool is used to assess an operation before spending (e.g., 'A quote authenticates like a call but stops before any spend'), and the schema says 'One operation_id from search', hinting at a flow. However, it never explicitly states when to choose this over siblings like use or search, nor does it give exclusions. The guidance is implied, not stated.

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

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

Beyond annotations declaring the call safe/read-only, the description adds important behavioral context: the $0.30 billing per successful call, no charge for 4xx/5xx responses, and semicolon-delimited response format. This is exactly the kind of non-obvious behavior an agent needs before invoking.

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 sentences with no filler: the core purpose and output fields come first, then cost/billing caveat, then response format. Every sentence earns its place and the most important operational detail (cost) is included without bloating.

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 single-argument read-only tool with rich annotations and an output schema, the description covers output contents, billing behavior, error-charge behavior, and response format. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100% and the single parameter target is already clearly documented with format and an example. The description adds no deeper parameter semantics, but the schema carries the full burden adequately, so baseline 3 is appropriate.

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

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

States a specific verb ('Return') and resource ('backlink profile summary for a root domain') and enumerates the exact fields returned. The description clearly distinguishes this from domain-overview or competitor tools in the sibling list, even without naming alternatives.

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

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

There is no guidance on when to choose this tool over alternatives such as get_semrush_domain_overview or get_ahrefs_domain_rating. The description defines what the tool does but does not state usage conditions, exclusions, or preferred alternative scenarios.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds valuable behavioral context: cost per row ($0.09), row limit (up to 20), header exclusion, error handling (4xx/5xx not charged), and response format (semicolon-delimited text). These details go beyond annotations and inform the agent about side effects and output parsing. This is a strong addition, though it doesn't mention pagination (but the limit is clear).

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

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

The description is two sentences with no wasted words. It front-loads the core purpose, then adds cost and format details. Every piece of information earns its place, and the structure is logical: what, then cost, then response format. This is highly concise and well-structured.

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

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

Given that an output schema exists, return values are already structured. The description covers purpose, cost, row limit, and response format. Combined with annotations (read-only, idempotent) and the input schema, an agent has enough to call the tool correctly. The only gap is explicit sibling differentiation, but that falls under usage guidelines rather than completeness. It is quite complete for a simple retrieval tool.

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

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

Schema description coverage is 100%, so both parameters (domain and database) are fully documented with examples. The description adds no additional parameter semantics—it doesn't elaborate on format or constraints beyond what the schema provides. Per the rubric, when schema coverage is high, the baseline is 3, and the description doesn't need 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 clearly states the tool returns keywords a domain ranks for in Google organic, with specific fields (position, volume, CPC, URL). This is a specific resource and action, but it doesn't explicitly contrast with siblings like get_semrush_domain_overview or get_semrush_organic_results. The purpose is evident and distinct, but lacks explicit differentiation.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. There is no mention of conditions or exclusions relative to sibling tools. Usage is implied by the tool's name and purpose, but the description doesn't state 'use this for X instead of Y'. Since it's a straightforward retrieval, the lack of explicit guidance is acceptable but not ideal.

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

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

Annotations already mark the tool as readOnly, idempotent, and non-destructive, and the description adds genuinely useful behavioral context: it is billed $0.09 per successful call, 4xx/5xx responses are not charged, and the response is semicolon-delimited text. These are non-obvious facts an agent needs before calling.

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

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

Three short sentences with no filler: the core purpose is front-loaded, followed by billing terms and response format. Every sentence earns its place.

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

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

With a rich output schema, strong annotations, and an output schema present, the description covers the remaining operational context: cost, error billing behavior, and response format. Nothing required to safely call the tool correctly is missing.

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

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

Schema description coverage is 100%, with domain and database already documented with examples and a default. The description restates the regional-database idea but does not add parameter-level meaning or constraints beyond what the schema provides, so the baseline 3 is appropriate.

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

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

The description uses a specific verb ('Return'), a clear resource ('organic search overview for a domain'), and enumerates the exact metrics returned. This lets an agent distinguish it from sibling tools like get_semrush_backlinks_overview or get_semrush_keyword_overview.

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

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

The intended use case is implied: retrieving domain-level organic search metrics for a given regional database. However, there is no explicit when-to-use guidance or exclusions compared to sibling SEMrush or Ahrefs tools, so the agent must infer 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?

Annotations already mark the tool as read-only, open-world, and idempotent, so the additional value comes from the per-row billing, 20-row cap, 4xx/5xx non-charge disclosure, and semicolon-delimited-text response format. It adds real operational behavior without contradicting the annotations.

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

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

The description is three compact sentences: purpose first, then billing, then response format. Each sentence earns its place and there is no filler or duplicated schema content, though the cost sentence is dense and could stand out more.

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 output schema exists and the parameter set is simple, the description covers the core purpose, cost, limits, and response format, which are the main contextual gaps. It does not address when to choose Semrush over DataForSEO alternatives, but the tool's unique resource-specific behavior is sufficiently captured.

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

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

Schema description coverage is 100%, and the schema already documents the semicolon separator, 20-keyword limit, and database default. The description contributes the connection between row billing and returned data rows, but no additional parameter-level semantics 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?

The first sentence clearly identifies the tool as returning Semrush's keyword difficulty index, with an explicit metric scale and batch capability. It distinguishes from domain-level or competitor tools because of the specific metric and name, though it doesn't name alternative tools such as the DataForSEO bulk keyword difficulty sibling.

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

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

The description gives no scenario-based guidance such as when to choose this tool versus a sibling like post_dataforseo_labs_google_bulk_keyword_difficulty_live or get_semrush_keyword_overview. The dollar cost per row and error charging are operational context, not selection guidance.

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

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

Annotations already declare readOnly/openWorld/idempotent/not-destructive, and the description adds valuable context beyond them: the per-call billing cost ($0.09, with 4xx/5xx not charged) and the semicolon-delimited response format. No contradiction with the annotations.

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

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

Three tight sentences with zero filler. Purpose is front-loaded first, followed by billing disclosure and response format — each sentence earns its place and nothing is redundant.

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

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

For a simple 2-parameter read-only tool with a full output schema and comprehensive annotations, the description covers purpose, cost, and format. The only thing missing is routing guidance to related siblings, but the tool's simplicity and structured fields carry the rest.

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

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

Schema coverage is 100%, so the schema already documents both phrase and database parameters with examples. The description only reinforces this with 'keyword phrase in a given regional database', adding marginal value beyond the schema 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?

States a specific verb (Return) + resource (search metrics for a keyword phrase) + scope (regional database), and enumerates the exact metrics returned (volume, CPC, competition, results). This distinguishes it from siblings like get_semrush_backlinks_overview and get_semrush_domain_overview without needing to open their schemas.

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

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

Provides no guidance on when to choose this tool over alternatives. Siblings get_semrush_organic_competitors, get_similarweb_keywords, and get_similarweb_keyword_competitors overlap in keyword topics, yet the description never tells an agent which to prefer or under what conditions. This is a clear gap.

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

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

The description adds substantial behavioral context beyond the annotations: per-row billing, a 20-row cap, no charges for 4xx/5xx responses, and semicolon-delimited text output. These details are not present in any structured field and are critical for cost-aware invocation.

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

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

Three short sentences, each earning its place: purpose, cost/limits, and response format. It is front-loaded with the core purpose and contains no filler or repetition.

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

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

For a low-complexity tool with two primitive required parameters and an output schema, the description covers everything an agent needs: what it returns, cost constraints, row limits, and response formatting. Nothing essential is missing.

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

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

Schema coverage is 100%, with both `domain` and `database` having descriptions and examples. The description does not add parameter-level meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly identifies the resource ('domains competing with a target') and the context ('Google organic search'), which distinguishes it from SEMrush backlinks, domain overview, and Similarweb tools. However, it lacks an explicit verb like 'Returns' or 'Lists,' 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 intended use case is implied: use this when you need domains competing with a target in Google organic search. But the description never explicitly states when to prefer this over sibling tools such as get_similarweb_keyword_competitors or get_semrush_domain_overview, and gives no exclusion criteria.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering safety and idempotence. The description adds valuable behavioral details: pricing per row ($0.09, up to 20 rows, header excluded), that 4xx/5xx errors are not charged, and that the response is semicolon-delimited text. These go beyond the annotations and are relevant for cost and parsing decisions. It does not mention error handling or rate limits, but the disclosed traits are sufficient for a read-only 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?

The description is three concise sentences: the first states the core purpose, the second explains pricing, and the third describes the response format. It is front-loaded with the essential function and packs all critical operational details with no waste. Every sentence earns its place.

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

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

The tool is simple (2 params, 1 required) and has an output schema, so return structure is covered. The description adds the pricing model and response format, which are not in the schema or annotations. It does not explicitly mention edge cases like empty results or rate limits, but for a straightforward read-only lookup, the provided details are sufficient for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters ('phrase' and 'database'). The description does not add any additional parameter-specific semantics, such as format nuances or examples beyond what the schema provides. Per the rubric, a high-coverage schema earns a baseline of 3, and the description adds no extra value here.

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

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

The description clearly states the tool returns 'Domains and URLs currently ranking in Google organic results for a keyword,' specifying the verb, resource, and scope. It is distinct from siblings like get_semrush_domain_organic_keywords (which returns keywords for a domain) and get_semrush_organic_competitors (which returns competitors), so an agent can differentiate based on the keyword-centric focus.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. It does not mention that this is the keyword-to-domain lookup as opposed to domain-to-keyword tools, nor does it suggest any conditions for selection. The only context is the tool's name, which implies usage but is not explicit.

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

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

The description adds significant behavioral context beyond the annotations: billing at $0.36 per row, a 20-row limit, non-charging of 4xx/5xx errors, and semicolon-delimited response format. This covers cost, error handling, and output structure, which the annotations (readOnly, openWorld, idempotent) do not address. No contradiction with annotations.

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

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

The description is two sentences: the first states purpose concisely, and the second front-loads billing and response format. Every word earns its place; there is no fluff or repetition. It is well-structured for quick agent parsing.

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 presence of an output schema, return values are covered. The description adds billing, row limits, error handling, and response format, which are essential for correct invocation. However, it lacks any mention of when to prefer this over siblings, and it doesn't note any prerequisites (e.g., API key or target validation). Still, for a read-only data fetch, it is largely complete.

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

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

The input schema already provides 100% coverage for both parameters (target and target_type) with examples and descriptions. The tool description adds no additional parameter-specific semantics beyond restating 'target' generically. Per the baseline rule, 3 is appropriate when schema fully documents parameters.

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

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

The description states a clear verb and resource: 'Referring domains linking to a target, aggregated by domain.' It specifies the aggregation level, distinguishing it from other backlink tools that might list individual backlinks. However, it doesn't explicitly name any sibling tool for differentiation, so it's clear but not maximally distinguishing.

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

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

The description provides no guidance on when to use this tool versus alternatives like get_semrush_backlinks_overview or post_dataforseo_backlinks_referring_domains_live. It only describes what it does, leaving the agent to infer context from the name and sibling list. No exclusions or alternative recommendations are given.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral context beyond annotations: the tool is free, requires no key, and can direct users to a category-specific endpoint that lists tools directly rather than through search.

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

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

The description is moderately detailed but every sentence adds useful information: output scope, cost/auth, sibling differentiation, and endpoint usage. It is slightly longer than strictly necessary but remains well-structured and front-loaded with the core purpose.

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

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

For a zero-parameter, read-only tool with an output schema and safety annotations, the description is complete. It covers what the tool returns, the free/no-key access model, and provides the category endpoint for specialized use, leaving no essential gap for an agent to call it correctly.

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

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

The tool has zero parameters, so the baseline is 4. The description includes a <category> placeholder only in the endpoint examples, not as a tool parameter, which is appropriate supplementary guidance rather than a parameter-semantics 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 clearly states what the tool does: it presents the AIsa catalogue at a glance, including categories, servers, tool counts, and a dedicated category endpoint. It also distinguishes itself from search by explaining that the endpoint lists tools directly instead of via 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 provides clear usage context: use list_categories for a catalogue overview, and use the provided endpoint when you only need one category. It explicitly contrasts with search ('instead of via search') and notes tool-router has no equivalent, although it does not exhaustively cover all sibling alternatives.

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

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

The description implies a safe read operation ('retrieve structured responses'), but annotations declare readOnlyHint=false and destructiveHint=true. It also omits live-generation cost implications, open-world web search behavior, and non-idempotency.

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 clear sentence with no wasted words, and the purpose is front-loaded. It is extremely thin, but it is not bloated or poorly structured.

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

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

For a complex live ChatGPT generation tool with a nested request array, destructive/open-world annotations, and many sibling endpoints, the description is too minimal. The output schema covers returns, but selection guidance, prerequisites, and behavioral caveats 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?

The description adds no meaning beyond 'input parameters'. Although nested schema fields have rich descriptions, the sole top-level required parameter (body) is undocumented in both the description and the schema's top-level coverage, so the description fails to compensate for the request-construction complexity.

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: retrieve structured responses from a ChatGPT model. However, it does not distinguish this tool from sibling LLM response endpoints for Claude, Gemini, or Perplexity beyond naming ChatGPT, nor from the ChatGPT scraper endpoints.

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

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

Provides no explicit when-to-use, when-not-to-use, prerequisites, or alternatives. The phrase 'based on the input parameters' only restates that the tool takes parameters.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true and openWorldHint=true, so the description's only job is to add context beyond that. It adds none: no mention that this is a billed/consumptive live call, no latency or quota expectations, no note that web_search and use_reasoning materially change cost and required max_output_tokens. The word 'retrieve' sits awkwardly against destructiveHint=true and openWorldHint=true, though it does not explicitly claim a read-only 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 sentence with the endpoint concept front-loaded, so nothing is padded. However 'based on the input parameters' is pure filler that consumes the back half of the sentence without informing the reader.

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 large nested request body, model-specific feature flags (web_search, use_reasoning, message_chain) and real cost implications, one generic sentence is inadequate. An output schema exists so return values need not be described, but the missing billing/consumption and model-listing prerequisites leave the definition under-specified.

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 0% for the single top-level 'body' parameter, and the description does nothing to compensate — it never explains that body is an array of request objects that are executed together, nor does it characterize model_name, user_prompt or the mutual exclusions. The nested schema fields are in fact richly documented, but an agent gets no help from the description on the top-level wrapper, which is the actual 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 a concrete verb ('retrieve') and resource ('structured responses from a specific Claude model'), which is enough to tell it apart from the GPT/Gemini/Perplexity response siblings that appear in the namespace. It stops short of explicitly stating the sibling relationship or that the model must be chosen from a separate Models endpoint, but the core purpose is unambiguous.

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

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

There is no guidance on when to use this live endpoint versus the sibling 'live' variants for other model families, versus the corresponding models-listing endpoint, or versus batch_use. The trailing clause 'based on the input parameters' carries 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?

Annotations already declare openWorldHint=true, destructiveHint=true, and idempotentHint=false, so the safety profile is covered by structured data. The description adds nothing beyond that: no cost implications (the web_search schema note mentions pricing), no rate limits, no auth requirements, and no statement of what 'live' implies versus batch.

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

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

A single front-loaded sentence with no filler, which is appropriately terse. It is arguably under-specified rather than bloated, but as pure conciseness it is clean.

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 complex nested request body (prompt, model_name, message_chain, temperature, reasoning, token limits) and a POST with destructive/non-idempotent annotations. One generic sentence is not enough to orient an agent; output schema existence excuses explaining return values, but nothing else about this multi-field request is covered.

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% – the sole parameter 'body' is an array of request objects with no description at the parameter level. The description says only 'based on the input parameters,' which adds no meaning; it never explains that body accepts a list of prompts/tasks. The nested item fields are richly documented in the schema, but the description itself does not compensate for the top-level 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 a specific verb and resource ('retrieve structured responses from a specific Gemini AI model'), so the agent knows this is a generation/retrieval call against Gemini. It implicitly distinguishes itself from the ChatGPT/Claude/Perplexity live-response siblings by naming Gemini, but never explicitly contrasts them or explains the live-vs-scraper distinction.

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 exclusions, and no mention of the alternatives (the ChatGPT/Claude/Perplexity live-response endpoints or the Gemini models endpoint). The only routing hint ('you can receive the list of available LLM models by making a separate request...') lives in the nested schema, not the description.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and openWorldHint=true, so the agent knows this is a non-idempotent live call. The description adds nothing about cost/credit consumption, rate limits, or what makes a 'live' call different; it only describes the data semantics, not the tool's behavior. The read-flavored word 'provides' is mildly at odds with the destructive hint but does not rise to a contradiction.

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

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

A single front-loaded sentence with no filler or repetition. It is efficiently sized, though the brevity comes at the cost of substance rather than being a model of tight completeness.

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 array body, no parameter guidance, and a crowded sibling set of similar live endpoints, one sentence is insufficient. The existence of an output schema excuses it from explaining return values, but it still needs to say how to call it and when to prefer it over batch_use or other live variants.

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 body parameter is not explained at all in the description, and the measured schema description coverage is 0%. The description never mentions the keywords array, the location_name/location_code or language_name/language_code requirement, or the 1000-keyword limit, leaving the description to add no parameter meaning.

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

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

The description states a specific verb and resource: it 'provides search volume data for your target keywords' and clarifies the data is estimated AI-tool usage, distinguishing it from generic SEO volume tools. It does not differentiate itself from the many sibling 'live' AI endpoints or from batch_use, 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 mention of prerequisites (location/language requirement), and no comparison to alternatives such as batch_use or the other live AI endpoints. The agent must infer usage entirely 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?

Beyond the annotations, the description discloses significant operational behavior: the endpoint is 'roughly eight times the flat rate billed', target type errors are rejected, and a rejected request 'still returns HTTP 200' with outcome in tasks[0].status_code. This is rich, non-obvious context that helps an agent interpret failures and cost.

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

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

The description is dense but well-structured, front-loading the core purpose and then adding cost, type constraints, response envelope, and sibling routing. Every major clause earns its place; minor noise like 'Measured at 7.0 KB' and emoji formatting slightly reduces polish but does not hurt comprehension.

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 live aggregate endpoint, the description covers the key operational facts: response envelope, HTTP behavior, cost, target format, filter source, and sibling alternatives. Since an output schema exists and the input schema documents the remaining body fields, 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?

The description adds critical parameter semantics not in the schema: target must be an array of objects with domain or keyword objects, and it gives exact rejection messages for invalid forms. It also points to the available-filters endpoint for filter fields. The schema already documents most nested fields, so the description does not need to repeat 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 opens with a specific outcome: 'How often assistants mention your target, as totals rather than individual answers', naming both the resource and the distinction from detailed mentions. It then explicitly differentiates the tool from sibling endpoints, so an agent can identify it without opening schemas.

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

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

The description gives clear routing guidance: this is 'the headline visibility number', while post_dataforseo_ai_llm_mentions_search_live 'shows the answers behind it' and cross_metrics_live 'compares several targets at once'. It implies aggregate-total usage rather than detail retrieval, though it does not explicitly state when not to use it.

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

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

Annotations declare destructiveHint=true and readOnlyHint=false, but the description adds substantial behavioral context: the endpoint is 'among the most expensive endpoints in this provider' with a measured cost, the `target` field rejects bare strings and arrays of strings, a rejected request still returns HTTP 200, and pagination uses `search_after_token` not `offset` past the first pages. This goes far beyond what annotations provide.

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 dense but front-loaded with the core purpose, then covers cost, target format, envelope, and sibling routing. Every sentence adds value. It is longer than ideal, but the length is justified by the high-stakes cost warning and the non-obvious `target` format. The structure is logical: purpose → return → cost → parameter warning → envelope → alternative.

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

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

Given the tool's complexity (1 body parameter with many nested fields), the description covers the essential operational facts: cost, target format, envelope parsing, pagination, and the sibling for counts. The output schema exists, so return values need not be enumerated. The description is complete enough for an agent to call this correctly and avoid the most common pitfalls.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain the critical `target` parameter shape ('array of objects, each `{"domain": "..."}` or `{"keyword": "..."}`') and the filter source. However, it does not enumerate the other parameters (limit, offset, platform, language_code, etc.), leaving the agent to read the schema for those. The description adds meaning for the most error-prone parameter but not all.

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

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

The description opens with a specific verb and resource: 'The individual answers in which an assistant mentioned your target.' It clearly distinguishes this from the sibling `post_dataforseo_ai_llm_mentions_aggregated_metrics_live` by stating 'For counts rather than the mentions themselves use...' This is a precise, non-tautological statement of what the tool returns.

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

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

The description explicitly names the alternative for counts (`post_dataforseo_ai_llm_mentions_aggregated_metrics_live`) and states the condition for choosing it. It also warns about the `target` parameter format, the envelope structure, and the pagination behavior. This is explicit when/when-not guidance.

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

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

The description adds meaningful non-obvious behavior: response size, cost magnitude, rejection still returning HTTP 200, and the required array-of-objects target shape. It does not contradict the annotations, though it does not explicitly address the destructiveHint=true annotation beyond the cost warning.

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 dense but front-loaded with the core purpose and cost warning. Some phrases are decorative ('the list to pitch') and the `total` / `items` mention is cryptic, but nearly every sentence adds practical 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?

It covers the response envelope, error semantics, response size, cost, and sibling routing, and an output schema exists for return-value details. It does not mention pagination or rate limits, but those are not critical given the schema and the explicit warning about cost.

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 helps with the trickiest part of the body parameter: `target` must be an array of `{domain}` or `{keyword}` objects, and filter fields are sourced from another tool. However, most parameter details already live in the schema, and the description does not compensate for the reported 0% top-level schema coverage beyond target shape and filter references.

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 precise resource ('domains assistants cite most') and ties it to the title's 'Top Domains'. It also differentiates from the sibling top-pages endpoint in the final sentence.

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

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

It explicitly says this is 'the list to pitch' and directs page-level queries to post_dataforseo_ai_llm_mentions_top_pages_live. The cost warning also helps an agent decide whether this endpoint is appropriate for casual use.

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

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

Annotations declare readOnlyHint=false, destructiveHint=true, and openWorldHint=true, indicating a potentially disruptive write-like operation with external effects. The description says 'retrieve structured responses,' which might suggest a read-only operation, creating a mild tension, though 'live' and 'post' in the name suggest generation. The description adds no context on cost, side effects, rate limits, or authentication. With annotations present, the bar is lower, but the description still misses important behavioral context for a destructive, open-world call.

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

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

The description is a single sentence that is front-loaded and free of filler. It could be slightly more informative, but it is appropriately sized for a tool whose parameters are well-documented in the schema.

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

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

Given the tool's complexity (LLM generation with many optional parameters), the presence of an output schema (which covers return values), and the destructive/open-world annotations, the description is too thin. It does not mention that this is a paid, potentially rate-limited API call, nor does it help the agent select among sibling LLM endpoints. The description is incomplete for an agent to invoke correctly without inspecting the schema and annotations.

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

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

The input schema has 0% description coverage at the top level (body array), but the nested items have full descriptions for each parameter (tag, top_p, model_name, temperature, user_prompt, message_chain, system_message, max_output_tokens, web_search_country_iso_code). The description adds no parameter semantics beyond what the schema provides. According to the rules, when schema description coverage is high for actual parameters, baseline is 3; here the top-level coverage metric is 0% but effective nested coverage is high, so 3 is appropriate.

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

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

The description states a specific verb (retrieve) and resource (structured responses from Perplexity AI model), which is clear enough on its own. However, it does not differentiate from sibling tools like post_dataforseo_ai_chat_gpt_llm_responses_live or post_dataforseo_ai_claude_llm_responses_live, which have near-identical descriptions. The agent must infer the distinction from the name alone.

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

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

The description provides no guidance on when to use this tool versus the sibling LLM response endpoints (ChatGPT, Claude, Gemini). It does not mention alternatives, preconditions, or exclusions. The agent is left to infer from model naming in 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?

The description implies a read-only data retrieval operation ('provide you with a detailed overview'), while the annotations declare destructiveHint=true and readOnlyHint=false. This is a direct contradiction that would mislead an agent about the tool's safety profile, and the description adds no other behavioral context such as authentication or rate limits.

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

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

The description is a single front-loaded sentence with no wasted clauses. It could be slightly tighter, but it is appropriately sized for its content.

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

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

Given the endpoint's rich parameter set and its placement among many similar siblings, the description is incomplete: it omits usage guidance, parameter details, and fails to reconcile the read-oriented wording with destructive annotations. Although an output schema exists, the description does not provide enough context to select or invoke the tool confidently.

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

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

The context reports 0% schema description coverage for the top-level parameter, so the description is expected to compensate. It only vaguely refers to the 'specified website' and does not explain the required body structure, target format, or any of the nested filter/sort options.

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 (provide overview) and resource (anchors used when linking to the specified website with backlink data), making the tool's purpose clear. However, it does not distinguish this endpoint from the many sibling backlink endpoints, 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 guidance on when to use this tool versus alternatives, nor any prerequisites, exclusions, or context about selecting it among the numerous sibling backlinks endpoints. It merely states what the endpoint returns.

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

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

The description implies a read-only retrieval ('provide you with a list of backlinks'), but annotations declare readOnlyHint=false and destructiveHint=true. This is a direct contradiction; the description fails to disclose any destructive behavior and instead suggests a safe 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?

A single, front-loaded sentence with no wasted words. It efficiently conveys the core purpose, though its brevity comes at the cost of detail covered elsewhere.

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

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

The core purpose is clear and the rich input schema plus output schema cover most operational details. However, the description does not mention that the body accepts multiple targets (array), nor does it distinguish from sibling tools, and the annotation contradiction adds confusion.

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?

With schema description coverage at 0% for the top-level 'body' parameter, the description should compensate but does not. It only vaguely references 'the specified domain, subdomain, or webpage' without clarifying the body array, filters, pagination, or any of the rich nested parameters documented in the schema.

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

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

The description states a specific verb (provide a list) and resource (backlinks) with scope (domain, subdomain, or webpage). However, it does not differentiate from siblings like bulk_backlinks_live or anchors_live, leaving the agent to infer which backlinks endpoint fits best.

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, nor any prerequisites or exclusions. The description only states what it does, not when it is the right choice.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety profile is largely covered by structured data. The description adds nothing beyond the return content: no live-vs-task semantics, no billing/credit implications, no latency or rate context for a POST live 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?

One sentence, front-loaded with the resource and the payload contents, with no filler. It is efficient, though it could have spent one more clause on disambiguating it from the sibling intersection endpoints.

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, and the description adequately says what is returned. What is missing is the operational context an agent needs to invoke a live POST endpoint confidently: cost, auth, and how it differs from the near-identical sibling 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?

The single top-level parameter is the request body, and the description adds no parameter guidance of its own. However, the nested schema carries detailed per-field descriptions (target, limit, offset, filters, order_by, rank_scale, etc.), so the schema does the heavy lifting and the baseline of 3 applies.

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

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

States a specific verb and resource ('provide you with a list of competitors that share some part of the backlink profile with a target website') and even names the returned fields (backlink intersections, rank). Clear purpose, but it does not distinguish itself from close siblings like post_dataforseo_backlinks_domain_intersection_live or get_semrush_backlink_competitors.

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 when to prefer this over the intersection or referring-domains endpoints, and no prerequisites (credentials, cost, target formatting expectations). The agent is left to infer selection 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?

The description presents a read-only data retrieval endpoint ('provide you with historical backlinks data'), but annotations declare readOnlyHint=false and destructiveHint=true. This is a direct contradiction, and the description adds no behavioral context such as cost, authentication, or side effects.

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

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

Two tightly written sentences with no wasted words. The main capability and time scope are front-loaded, making the definition easy to scan.

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, for a tool annotated as destructive and non-read-only, the description omits any disclosure of costs, side effects, or usage constraints, and it does not help distinguish this endpoint from its many siblings.

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

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

Schema description coverage is reported as 0%, so the description must compensate. It mentions a 'given domain' and a 'specific time period,' but does not explain the required target format, date_from/date_to constraints, rank_scale, or tag semantics, leaving most parameter meaning 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 resource and scope: historical backlinks data back to 2019, with metrics like backlinks, new/lost backlinks, and referring domains. It is clear what the tool does, though it does not explicitly differentiate itself from sibling history/timeseries tools.

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

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

The description gives no explicit when-to-use guidance, alternatives, or exclusions. It only implies historical data retrieval through the phrase 'historical backlinks data back to the beginning of 2019,' leaving the agent to infer when to choose this over other live backlinks endpoints.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true, and non-idempotent, which is the counterintuitive part an agent most needs warned about. The description adds nothing beyond that profile — no mention that this is a live, credit-consuming request or how the body array is processed.

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 an endpoint of this complexity the brevity edges toward under-specification rather than elegant 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?

With 10+ nested request fields and an output schema handling return values, the description should still cover usage context and the array-wrapped body shape. As written, an agent learns nothing about request structure, routing versus siblings, or operational cost.

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 `body` wrapper parameter is undocumented in the description, so the agent gets no signal that input must be an array of task objects rather than flat fields. The nested schema fields (target, filters, order_by, rank_scale, etc.) are thoroughly described in the schema itself, which partially compensates.

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 ('provide') and resource ('referring domains') scoped to 'the target you specify', so the core purpose is clear. However, it does no sibling differentiation, which matters here because several siblings (post_dataforseo_backlinks_bulk_referring_domains_live, referring_networks_live, get_semrush_referring_domains) cover closely adjacent ground.

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, and no mention of alternatives among the ~30 sibling tools. The agent must infer from the name alone whether this is the right tool versus the bulk or network variants.

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

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

The description frames the endpoint as a passive data retrieval ('provide you with an overview of backlinks data'), implying a safe read, while the annotations declare readOnlyHint=false and destructiveHint=true. That is a direct mismatch in the direction opposite the canonical contradiction case, so the agent receives conflicting signals about side effects. No additional behavioral context (cost, request-body batching, effect of limit/status parameters) is supplied beyond the annotations.

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

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

One sentence with no filler and the scope is front-loaded, which is structurally clean. But for a tool whose request body is a batched array with eight configurable fields, a single generic sentence reads as 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?

An output schema and annotations exist, so return-value explanation is not required. Even so, for a complex, high-fan-out POST endpoint the description omits what an agent most needs: when to prefer it over sibling endpoints and whether the call is a read or has side effects. Given the sibling density and the annotation tension, the description is not complete enough.

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 contributes zero parameter information, and the top-level schema coverage metric is 0% (the single 'body' array parameter carries no description). However, the nested item properties (target, tag, rank_scale, backlinks_filters, include_subdomains, internal_list_limit, backlinks_status_type, etc.) are individually and thoroughly documented in the schema, so the agent is not actually left guessing. Baseline 3 is appropriate where the schema does the heavy lifting.

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

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

The sentence names a resource ('backlinks data') and a scope ('a given domain, subdomain, or webpage'), so the agent knows the subject matter. But the verb is soft ('will provide you with an overview') and there is no differentiation from the roughly two dozen sibling backlink endpoints (referring_domains, anchors, timeseries_summary, domain_pages_summary, competitors, etc.). An agent cannot tell from this text why it should call this tool rather than a sibling summary variant.

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, no exclusions, and no named alternative. The only hint of applicability is the implicit 'use this for an overview of a target's backlinks,' which is inferred from the purpose rather than stated. In a family of 25+ similar backlink tools, the absence of routing guidance is a real gap.

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

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

The annotations declare destructiveHint=true, readOnlyHint=false, and openWorldHint=true, but the description frames the tool as simply providing citation data, implying a safe read operation. It gives no warning about destructive behavior or side effects, directly contradicting the destructive annotation.

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. However, it is too terse for a complex POST endpoint with many nested parameters and filters, making the brevity feel under-specified rather than optimally concise.

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

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

An output schema exists, so return values need not be described. But for a complex content-search endpoint with a required request body, pagination, filtering, and destructive annotations, the description omits all usage, behavioral, and parameter context needed 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?

The sole top-level parameter is a body array with 0% top-level schema description coverage. The description mentions only "target keyword" and does not explain the body array structure, required keyword/offset_token alternatives, filters, pagination, or other nested fields, leaving the parameter largely uncontextualized by 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 states a specific action and resource: it provides detailed citation data for a target keyword. It is clear enough to understand the tool's core purpose, but it does not distinguish this endpoint from related DataForSEO content-analysis siblings such as sentiment analysis or content summary.

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 instead of alternatives, no prerequisites, and no exclusions. The agent has no indication of appropriate contexts or limits beyond the terse 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?

The description frames the tool purely as a data provider ('will provide you with sentiment analysis data'), implying a read operation, while the annotations declare readOnlyHint=false and destructiveHint=true. That mismatch misleads the agent about side effects, and the description adds nothing about auth, cost, or per-request limits.

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

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

Two sentences, front-loaded with the purpose, so it is compact. However the trailing docs link with a '?bash' fragment is low-value filler that occupies half the description without adding usable guidance.

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

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

An output schema exists, so return values need not be explained, and the core purpose is conveyed. But for a live, billed, open-world API call the definition omits usage context, cost/latency expectations, and any reconciliation of its read-oriented wording with the destructive annotation.

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 only the 'target keyword' and adds no information about the single top-level body parameter or its nested fields, despite the reported 0% schema-description coverage at the parameter level. It does not compensate for the coverage gap even though the nested schema itself is fairly detailed.

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: returns sentiment analysis data for citations matching a target keyword. It is clearly distinguishable from siblings like post_dataforseo_content_search_live and post_dataforseo_content_summary_live, though it never explicitly names those alternatives.

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

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

There is no guidance on when to choose this sentiment endpoint versus the content search or content summary endpoints, nor any prerequisites (credentials, live-call cost, rate limits). The only pointer is an external docs URL, which pushes the decision burden onto the agent.

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

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

Annotations declare destructiveHint=true and readOnlyHint=false, but the description says nothing about mutation, side effects, rate limits, or auth needs. The phrase 'provide you with an overview' passively implies retrieval without confirming or clarifying the annotated write/destructive profile, so the description adds no behavioral context beyond the structured fields.

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 efficiently structured, though the brevity edges toward under-specification rather than tight 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?

For a tool with a complex nested array-of-objects body and many filtering options, the description omits when-to-use, parameter shape, and any behavioral nuance. The presence of an output schema excuses it from explaining returns, but it remains too thin given the input 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?

Top-level schema description coverage is 0% — the sole 'body' parameter is undocumented at that level (though nested items are richly described). The description contributes no parameter meaning (e.g., that body is an array of per-keyword task objects) and so 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?

The description states a resource and action ('overview of citation data available for the target keyword'), which is more specific than the title alone. However, it does not distinguish this tool from siblings like post_dataforseo_content_search_live or post_dataforseo_content_sentiment_analysis_live, leaving the agent to infer what makes a 'summary' unique.

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 endpoint versus the many sibling content/analysis tools, nor any prerequisites or exclusions. The agent gets no routing help at all.

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

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

Annotations already declare openWorldHint and destructiveHint, but the description adds nothing about the live/real-time nature of the endpoint, rate limits, or what the response contains. It does not contradict the annotations, but it also fails to add behavioral context beyond the one-line purpose statement.

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 'Using this endpoint you will' preamble is boilerplate that could be trimmed.

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 the description still omits any usage context for a POST endpoint family with many near-identical siblings, and provides no parameter guidance despite 0% schema coverage on the body wrapper. Not sufficient for an agent to invoke confidently.

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

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

Schema description coverage is 0% for the top-level body, and the description only implicitly references a domain ('a particular domain'), adding no syntax, format, or batching semantics for the required array-wrapped target field. The single required parameter is effectively undocumented in 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 and resource: 'get a list of technologies used in a particular domain.' An agent can understand what the tool returns. However, it does not distinguish itself from close siblings such as post_dataforseo_domains_tech_domains_by_technology_live or post_dataforseo_domains_tech_summary_live, leaving the 'for_domain' vs 'by_technology' distinction to be inferred from the name alone.

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

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

The description contains no when-to-use guidance, no exclusions, and no reference to any alternative sibling tool. With a dense family of tech-related endpoints (aggregation, summary, technology_stats, domains_by_technology), the absence of routing guidance is a real gap.

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

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

The description frames the tool purely as a read that 'will provide you with Whois data,' while annotations declare readOnlyHint=false and destructiveHint=true. An agent reading the description would infer a safe lookup, so the description and the structured safety metadata give conflicting signals (it also says nothing about billing/cost, which is the likely real reason for the destructive hint).

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

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

Two sentences, cleanly front-loaded with the core purpose. The second sentence ('Using this endpoint you will be able to get all these data...') merely restates the first and could be dropped without information loss.

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

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

An output schema exists, so return values need not be explained, and the live-endpoint nature is implied by the name. Still missing for a credit-consuming POST endpoint are cost/billing implications, pagination expectations for large result sets, and any hint about the type of query/filters accepted, all of which an agent would need to call it confidently.

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

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

Schema description coverage is reported as 0% (only the top-level body array is exposed as a parameter), so the description is the only chance to explain inputs, and it instead defers entirely with 'the parameters you specify in the request.' Filters, limit/offset, order_by, and offset_token are never mentioned, so no compensation for the coverage gap occurs.

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

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

The description names a specific resource (Whois data for domains) and enumerates the enrichment fields returned (backlink stats, ranking and traffic from organic and paid search), so an agent knows what the endpoint yields. It does not, however, distinguish this tool from its many domains_* siblings (e.g., get_dataforseo_domains_whois_available_filters or the tech_* live endpoints), which is the difference between a 4 and 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 use this live endpoint versus setup/filter endpoints such as get_dataforseo_domains_whois_available_filters or batch_use, and no prerequisites are stated. The only usage statement is the tautological 'for the domains matching the parameters you specify in the request,' which tells the agent nothing about selection.

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

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

Annotations declare openWorldHint=true, destructiveHint=true, idempotentHint=false, and readOnlyHint=false, yet the description adds nothing about cost, latency, authentication, or what a 'live' call actually mutates or consumes. Since the provider claims a destructive, non-idempotent profile for what reads like a data-retrieval operation, the description needed to clarify the side effects and does not — an agent gets no insight into the payoff or risk of calling it.

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

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

Two full sentences are devoted to a legacy AdWords-to-Google-Ads migration notice, which is relevant to API users but pushes the actual purpose into the middle of the paragraph. The description is not bloated overall, but it is not front-loaded with the tool's function.

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 input schema covers the nested fields well. What is missing for a live POST endpoint with a destructive annotation is any note about it being a synchronous, credit-consuming call and what it affects, leaving the behavioral picture 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?

The single top-level parameter (body) has no schema description, so the description must compensate and does so minimally by stating 'Set up to 20 keywords in the keywords array.' The nested fields are in fact richly documented inside the schema (date ranges, sort_by, location, language), so beyond the keyword-count hint the description adds little the schema does not already carry.

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

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

The description names a specific verb and resource: 'This endpoint will provide relevant keywords for the specified terms' and 'get keyword suggestions from Google Ads.' That is enough for an agent to know it retrieves keyword suggestions, not volumes or locations. It does not, however, distinguish itself from near-identical siblings such as gads_kw_for_site_live or bing_kw_for_keywords_live, so differentiation is absent.

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

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

There is no guidance on when to choose this endpoint over the many sibling keyword endpoints, nor any exclusion or prerequisite. The only operational advice ('set up to 20 keywords in the keywords array') restates an input constraint rather than a usage condition, leaving the agent to infer selection criteria from the tool 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?

Annotations declare destructiveHint=true, readOnlyHint=false, idempotentHint=false, and openWorldHint=true, yet the description discloses nothing about the write/submit nature, credit consumption, task lifecycle, or what 'destructive' means here. It adds no behavioral context beyond what the annotations already state.

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?

Brief and front-loaded, but every sentence is off-topic; the content is a deprecation notice rather than functional documentation, so nothing earns its place for an agent trying 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?

For a non-idempotent, destructive task-submission tool with an undocumented body parameter, the description omits everything an agent needs to call it correctly. An output schema exists, so return values need not be explained, but the omission of purpose and behavior is severe.

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 'body' parameter is undocumented in the schema (0% coverage), and the description provides no compensating detail about its structure or required 'keywords' array. The nested item fields are well described in the schema itself, which mitigates slightly, but the description contributes nothing.

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 never states what the tool does. It is entirely a migration note about the Google Ads API replacing the AdWords API, with no verb, resource, or scope describing the actual operation (setting a Google Ads search-volume task). Only the name/title hint at purpose.

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

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

No guidance on when to use this tool versus the many sibling keyword-volume tools (e.g., gads_kw_for_keywords_live, bing_search_volume_live, clickstream variants). The only instruction is an unrelated admonition to upgrade from AdWords.

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

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

Annotations supply the safety profile (readOnlyHint=false, destructiveHint=true, openWorldHint=true, idempotentHint=false), and the description adds essentially nothing beyond supported platforms. As a POST/live task-setting endpoint it omits cost-per-request, auth/credential requirements, rate limits, and the fact that it carries destructive semantics per the annotation. The description's 'provides you with data' framing also sits awkwardly beside the destructive annotation, though it is not a direct claim to the contrary.

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

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

Two sentences, front-loaded with the purpose and zero filler. It is efficient, though arguably too terse for the endpoint's complexity rather than padded.

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

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

For a POST live task endpoint with an output schema (so returns need not be described), the description still leaves major gaps: how the body must be structured, cost behaviour, and how it differs from the numerous sibling trends endpoints. It is under-specified relative to 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 reported at 0%, so the description is expected to compensate for the single top-level 'body' parameter, and it does not — no explanation of the body array shape, the required 'keywords' field, or the mutually exclusive location_code/location_name and date_from/date_to/time_range options. The nested schema is detailed, but the description itself adds no parameter meaning.

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

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

The description states a clear verb+resource: it returns 'keyword popularity data' / 'keyword trends' from DataForSEO Trends. It even names the supported surfaces (Google Search, Google News, Google Shopping). It does not, however, distinguish this 'explore' endpoint from sibling trends tools like post_dataforseo_keywords_trends_merged_data_live or trends_demography_live.

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

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

There is no guidance on when to choose this tool over its many siblings, nor any prerequisites or exclusions. The only usage-adjacent content is the mention of which Google properties are supported, which is closer to scope than to when-to-use direction.

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

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

The annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=false, and openWorldHint=true. The description adds no behavioral context beyond that: it does not mention credit consumption, rate limits, authentication requirements, or why a read-like metric call is flagged as destructive. The explanation of the metric scale is domain semantics, not operational behavior.

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

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

The description is front-loaded with the core capability and then defines the metric in a compact paragraph. It is appropriately sized for an API endpoint and contains little filler, though the second sentence explaining keyword difficulty is somewhat verbose relative to its value for selecting 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?

Given the nested array schema, required location/language pairs, live billing implications, and the presence of sibling tools, the description is incomplete. It omits usage routing, cost/auth context, and any mention of required parameters. Output schema existence means return values need not be explained, but the remaining gaps are substantial for a live, mutating-priced endpoint.

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 0% at the parameter level, and the top-level body parameter has no description at all. The description does not compensate: it never mentions the body array, the required location_name/location_code and language_name/language_code combinations, or the keywords field. The only numeric detail (1,000 keyword maximum) is already present in the nested schema 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 states a specific verb and resource: it provides the Keyword Difficulty metric for up to 1,000 keywords in one API request. It clearly explains what the metric represents (relative difficulty of ranking in top-10 organic results on a 0–100 logarithmic scale). However, it does not distinguish this tool from any sibling, such as get_semrush_keyword_difficulty or the numerous other DataForSEO keyword endpoints.

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 contains no when-to-use guidance, no prerequisites, and no mention of alternatives. It never says when an agent should call this bulk endpoint versus a single-keyword tool or the Semrush keyword difficulty endpoint. Usage is left 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?

Annotations already declare readOnlyHint=false, destructiveHint=true, openWorldHint=true, and idempotentHint=false. The description adds no behavioral context such as auth needs, cost, rate limits, or mutation semantics, and its 'provide you with estimated' framing does not address the destructive annotation; there is no explicit contradiction, but also no added transparency.

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

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

Two sentences, front-loaded with the core capability and return components. There is no filler or repetition.

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

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

An output schema exists, so return values need not be explained. However, for a complex bulk endpoint with a nested body object, the description omits required body structure and usage context; it is adequate for recognition but not fully complete.

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

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

Schema description coverage is 0% for the single top-level body parameter, so the description must compensate. It mentions the target limit (1,000) and output item types, which loosely map to targets and item_types, but it does not explain the required body array-of-objects structure or the optional language, location, tag, and ignore_synonyms fields.

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: provides estimated monthly traffic volumes for up to 1,000 domains, subdomains, or webpages, and enumerates the organic, paid, featured snippet, and local pack estimates. Clear enough to identify the tool, but it does not explicitly differentiate from sibling DataForSEO Labs bulk endpoints such as bulk keyword difficulty.

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

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

No when-to-use or when-not guidance is given. The bulk/1,000-target limit implies a bulk-estimation context, but the description does not name alternatives, prerequisites, or exclusions, so an agent must infer usage entirely.

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

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

The description frames the tool as passive data retrieval ('provide you with ranking and traffic data', 'review the domain ranking distribution'), implying a read-only operation, while annotations declare readOnlyHint=false and destructiveHint=true. This conflict directly contradicts the impression the text creates, leaving the agent unsure whether the call has side effects.

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

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

Two sentences, front-loaded with the endpoint's function and returning to what the caller can inspect. Some marketing phrasing ('You will be able to review...') is slightly padded, but nothing distracts and the size is appropriate.

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 the description needn't enumerate return fields, and its brief coverage of returning ranking and traffic data is adequate. However, for a live endpoint with a single required body parameter it omits prerequisites, the domain-format requirement, and any usage guidance, and leaves the annotation conflict unresolved.

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% at the top level (only the nested body items are documented), and the description adds no parameter meaning beyond the phrase 'the specified domain'. It does not mention required vs optional fields, the domain-format constraint, or the language/location alternates, so it 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 resource and scope: ranking and traffic data from organic and paid search for a specified domain, including SERP ranking distribution and estimated monthly traffic. This is clear enough to distinguish it from unrelated siblings, but it never explicitly contrasts with the closest sibling (post_dataforseo_labs_google_historical_rank_live) or other domain-overview tools, so it stops short of full sibling differentiation.

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

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

The description says nothing about when to use this tool versus alternatives, nor any prerequisites such as requiring a stripped domain (no https:// or www), being a live/paid call, or how it relates to the historical rank sibling. Usage must be inferred entirely from the name and title.

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

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

The description adds real behavioral context the annotations do not: data coverage starts August 2021 and results depend on the location/language combination. However, it says nothing about cost/credits or rate limits, and the annotations (destructiveHint=true, idempotentHint=false) sit uneasily with a read-style data retrieval description without 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 metric list is front-loaded and the description is short and readable. The closing sentence 'You can find the list of supported locations and languages here' is a dangling reference that adds little value, slightly reducing the score.

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, and the description covers scope (since August 2021) plus the metrics returned. The main missing element is routing guidance relative to the many sibling keyword endpoints, which is handled under usage guidelines.

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?

With reported schema description coverage at 0% and a single body-array parameter, the description only partially compensates by noting that location and language combinations are inputs and that a keyword list is required. It adds no syntax, format, or cardinality detail (e.g., the 700-keyword cap) beyond what the schema already carries.

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

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

The description states a specific verb+resource combination (historical Google keyword data per keyword) and enumerates the returned metrics (search volume, CPC, competition, monthly searches, trends). It implicitly distinguishes itself from the current-state siblings like keyword_overview and keyword_ideas by emphasizing 'historical', though it never names those alternatives.

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. Given numerous sibling keyword tools (keyword_overview, keyword_ideas, trends_explore, related_keywords), the agent is left to infer that this one is for historical/time-series data. No conditions, prerequisites, or exclusions are given.

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

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

The description frames the endpoint as a passive data provider ('will provide you with historical data'), yet the annotations declare readOnlyHint=false and destructiveHint=true. A retrieval operation that merely returns rankings/traffic cannot be destructive, so the description and annotations give the agent conflicting signals about the tool's effect.

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

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

A single front-loaded sentence that states the resource and the concrete data returned. Minor filler ('This endpoint will provide you with') but no wasted clauses.

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 nested request schema is rich. However, the description omits usage guidance, authentication/location-lookup notes, and any mention that the body is an array of request objects, leaving gaps for a fairly complex call.

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

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

The top-level 'body' array has no description and reported schema coverage is 0%, but the nested properties (target, date_from/date_to, location_, language_, correlate, ignore_synonyms, include_clickstream_data) are fully self-documented in the schema. The description only gestures at 'the specified domain' (target) and adds no meaning beyond the schema.

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

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

The description names a clear verb (provide/retrieve) and resource (historical rankings and traffic for a specified domain) plus concrete scope (SERP distribution, organic and paid monthly traffic). The 'historical' qualifier implicitly separates it from the current-snapshot sibling post_dataforseo_labs_google_domain_rank_overview_live, but that sibling is never named explicitly.

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

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

Usage is only implied by the word 'historical'; there is no explicit when-to-use, when-not-to-use, or named alternative. It also omits practical guidance such as the double-price cost of include_clickstream_data or the recommendation to keep correlate=true.

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

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

Annotations (readOnlyHint=false, destructiveHint=true, openWorldHint=true, idempotentHint=false) carry the behavioral profile, and the description adds nothing beyond them. It doesn't disclose that this is a costed/paid POST endpoint, that pagination uses offset_token, or why a keyword-lookup carries a destructive/cost implication. The schema mentions the double-charge for clickstream data, but that is not in the 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?

Two sentences with no filler, front-loaded with what the endpoint returns and followed by the selection rationale. Efficient, though the second sentence is more about the vendor's algorithm than about helping an agent 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?

For a complex, multi-parameter paid endpoint (location requirement, filters, order_by, pagination token, costed flags), the description is far too thin. Output schema exists so return values needn't be explained, but the operational context -- cost, location requirement, pagination -- is entirely 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?

Reported schema description coverage for the top-level 'body' parameter is 0%, so the description is expected to compensate, and it only says keywords are 'specified in a POST array.' It adds no meaning about required location_name/location_code, keyword limits, or filter/sort options that an agent needs before constructing the request.

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 resource ('search terms relevant to the product or service categories') and explains the selection algorithm (categorizing seed keywords), which is clearer than a tautology. However, it never distinguishes itself from close siblings like post_dataforseo_labs_google_keyword_suggestions_live or post_dataforseo_labs_google_related_keywords_live, so an agent can't tell which 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, when-not-to-use, or alternative-tool guidance. The description explains the internal algorithm but gives no signal about when an agent should choose Keyword Ideas over Keyword Suggestions or Related Keywords. This is simply absent.

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

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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=true, openWorldHint=true). The description adds the return-field inventory and notes that include_clickstream_data bills at double price — useful, cost-bearing context — but it never addresses the non-readonly/destructive hint or auth/side-effect implications, leaving a gap between what it says (data retrieval) and what the annotations imply.

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

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

Two sentences, front-loaded with purpose and free of padding, but the second sentence is largely a metric enumeration that duplicates the output schema's job rather than earning its place.

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

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

An output schema exists so return values need not be explained, yet the description still recites them. Against a 1-body-param tool with annotations and a sibling set of competing keyword tools, the missing usage routing and the un-noted read-vs-destructive tension leave it only minimally complete.

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

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

The top-level 'body' parameter has no schema description (0% coverage at that level), though the nested properties are richly documented in the schema. The description adds meaning only for include_clickstream_data; it says nothing about the keyword/location/language requirements, so it neither compensates for nor exceeds the schema.

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

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

States a specific verb+resource ('provides Google keyword data for specified keywords') and enumerates the metric categories returned, so the resource is unambiguous. However, it never distinguishes this from the many sibling keyword tools (keyword_ideas, keyword_suggestions, related_keywords, bulk_keyword_difficulty, historical_keyword_data), which an agent must choose among.

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 specified keywords' weakly implies usage, but there is no explicit when-to-use, no when-not-to-use, and no routing to alternatives despite a dense keyword-tool sibling set. Comparable to the MID calibration where no prerequisites or alternatives are given.

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

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

Annotations are present but terse (readOnlyHint=false, destructiveHint=true, idempotentHint=false, openWorldHint=true), and the description adds nothing behavioral on top of them. For a 'live' task-based endpoint that consumes API credits and can charge double when include_clickstream_data is enabled, cost/async/permission context would be valuable and is entirely absent.

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 clean, front-loaded sentence with no filler or repetition of the schema. It is efficient, though its brevity borders on under-specification rather than true economy.

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?

Placeholder — see corrected value below.

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 coverage is 0%, so in principle the description must carry parameter meaning, and it adds none. In practice the nested body-item schema documents keyword, limit/offset, offset_token, filters, order_by, language/location and the include_* flags in detail, so the agent is not left blind here — but the prose itself contributes zero parameter guidance.

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

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

It states a concrete verb and resource: the endpoint returns search queries containing a specified seed keyword. That is more specific than a tautology and implies the seed-keyword expansion behavior. It does not, however, distinguish itself from close siblings such as keyword_ideas or related_keywords, which an agent would need to choose between.

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, when-not-to-use, or alternative-tool guidance. Nothing tells the agent whether this is preferable to google_keyword_ideas or google_related_keywords, nor when a caller should reach for this endpoint at all.

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

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

The description frames the tool as a data retrieval endpoint ('provides keywords', 'You can get up to 4680 keyword ideas'), but the annotations declare destructiveHint=true and readOnlyHint=false. This is a direct mismatch that can mislead an agent about the operation's safety profile.

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

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

The description is reasonably front-loaded with purpose first, followed by depth and output details. However, the sentence 'View the element.' is extraneous and confusing, and it does not clearly 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?

For a complex endpoint with a contradictory annotation set and an opaque top-level parameter, the description is incomplete. It does not clarify prerequisites, usage conditions, or the destructive annotation, and it redundantly explains return fields despite an output schema being present.

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% for the sole 'body' parameter. The description mentions search depth and max results, but it does not compensate for the missing top-level documentation of required keyword/location/language fields or the array/task structure.

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

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

The description states a specific verb+resource: it provides keywords from the 'Searches Related to' SERP element, with a max of 4680 ideas via search depth. It is clear what the endpoint does, but it does not distinguish this tool from sibling keyword_ideas_live or keyword_suggestions_live.

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 when-not-to-use guidance, and no named alternatives. The description only summarizes what the endpoint returns, leaving the agent to infer appropriate 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?

Adds substantial context beyond annotations: exact cost, response envelope structure, the fact that rejected requests still return HTTP 200, and pagination with offset_token. These are behavioral traits not present in annotations and are crucial for correct usage.

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 longer than average but every sentence earns its place: purpose, cost, alternatives, envelope, and use case are clearly front-loaded. Slightly verbose but well-structured.

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

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

With an output schema present, the description does not need to explain return values. It covers the key operational aspects (cost, response envelope, error behavior, pagination) and routes to alternatives, making it complete for the tool's complexity.

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

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

Though schema coverage is 0% at the top-level, the nested schema descriptions are detailed. The description adds value by explaining pagination tokens and the limit/offset semantics. It doesn't cover all parameters, but the schema does, so the balance is good.

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: finds which pages of a target site earn its rankings, ranked by traffic. It distinguishes from siblings by pointing to alternative tools for keywords and backlinks, and by contrasting with the more expensive google_ads endpoints.

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 says when to use it (to find pages worth defending/expanding) and when not, naming two alternative tools. Also compares cost and data granularity with google_ads endpoints, giving clear selection criteria.

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

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

Annotations already carry the safety profile (readOnlyHint=false, destructiveHint=true, openWorldHint=true, idempotentHint=false), so the bar is lower. The description adds the meaningful output behaviour (primary intent plus secondary intents with probabilities), but says nothing about billing/credit consumption, auth requirements, or why a data-returning endpoint is flagged destructive, leaving a notable gap.

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

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

Three sentences, reasonably front-loaded, but the second and third largely duplicate what the output schema already conveys about returned intent probabilities. 'For each keyword that you specify when setting a task' is also inaccurate for a live endpoint and adds noise.

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 the description need not explain return values, yet it spends most of its length doing exactly that. For a paid, open-world POST endpoint with a body-only parameter contract, the description omits the practically important context: required language specification, credit cost, and any batching limits.

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 (body) has no description at all, though its nested properties are richly documented in the schema (tag, keywords, language_code, language_name). The description only restates the 1,000-keyword cap already stated in the schema and adds no new detail about the language requirement or payload shape, so it neither compensates for the top-level gap nor adds value.

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

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

The description states a specific verb and resource: it returns search intent and intent probability for a specified set of keywords. That is unambiguous and more specific than most siblings (e.g. keyword_overview, keyword_ideas). It does not, however, draw any contrast against the many other Labs keyword endpoints that an agent must choose between.

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 says what is returned but never when to prefer this endpoint over siblings such as google_keyword_overview or google_historical_keyword_data, nor does it state exclusions or prerequisites. The phrase 'when setting a task' is the only usage hint and it is ambiguous for a 'live' endpoint.

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

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

Annotations already declare openWorldHint=true, destructiveHint=true and idempotentHint=false, so the safety profile is largely covered. The description adds nothing beyond output contents: no mention that this is a live, credit-consuming POST request per batch item, no auth or rate-limit context, and no acknowledgement that a supposedly read-style lookup is flagged destructive. Note the description does not explicitly claim read-only, so this is tension rather than a hard contradiction.

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

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

Two compact sentences, front-loaded with what the endpoint returns. The second sentence is slightly padded ('the provided domains gain from the specified keywords'), but nothing is truly wasted.

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

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

For a multi-keyword, multi-filter, live POST endpoint with a complex nested body and several near-identical competitor siblings, the description is too thin. An output schema exists so return values need not be restated, but request construction, batching, cost/side-effect expectations, and sibling differentiation are all 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?

The single top-level parameter ('body') is a batch array with many nested, required-combination fields (keywords, location_name/code, language_name/code, filters, order_by, limit, offset), and the description explains none of it. An agent must reverse-engineer the entire request shape from the schema, and the description gives no hints about batching or the either/or location and language 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?

States a specific verb+resource: it returns a list of domains that rank for specified keywords, plus the metrics attached to those domains. That is clear enough for an agent to know what comes back, but it never distinguishes itself from close siblings such as get_semrush_organic_competitors or post_dataforseo_backlinks_competitors_live, so selection still requires guesswork.

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 stated preconditions (a keyword array plus a location/language pair is mandatory), and no reference to any alternative tool. The agent is told what the output contains but not when this endpoint is the right choice.

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

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

The description portrays a pure data-retrieval endpoint ('provide you with a list', 'get the estimated traffic volume'), yet annotations declare destructiveHint=true and readOnlyHint=false, a direct conflict. The description does add output context (which metrics come back), but the mismatch with the stated safety profile undercuts transparency.

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

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

Three sentences, front-loaded with the primary output, and every sentence states a distinct data category. Minor filler ('In addition to that') but no real waste.

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

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

Because an output schema exists, return-value detail is not required, and the description adequately frames the response content. However, for a live paid POST with a required body, the description omits input format, cost implications, and usage context, leaving meaningful gaps.

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

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

Top-level schema description coverage is 0% (the sole 'body' parameter is undocumented), and the description adds nothing about the required target domain, the body array wrapper, or filtering/ordering options. Parameter meaning must be inferred entirely from the nested schema, which the description never references.

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

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

The description names a specific verb+resource (returns a list of subdomains for a specified domain) and enumerates the data delivered: organic/paid ranking distribution and estimated traffic volume. It is clear enough to distinguish from other DataForSEO Labs tools, though it never explicitly contrasts itself with siblings like domain_rank_overview.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites (a 'live' paid endpoint posting a body array), and no notes on batching or cost. The reader gets what it returns but not when it is the right call.

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

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

Annotations declare readOnlyHint=false, destructiveHint=true, idempotentHint=false, and openWorldHint=true, but the description frames this purely as a retrieval ('returns a list of pages') and never discloses that it is a POST/task-based call that consumes resources, nor that it needs a task id produced by a prior submission. With annotations carrying the safety profile and the description adding no operational context, 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?

Two compact sentences with the core purpose front-loaded and no filler. It is slightly misallocated, spending its second sentence on return content that the output schema already covers.

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

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

For a task-based POST endpoint with a required task id and zero top-level schema coverage, the description omits the workflow prerequisite (obtain id from the Task POST endpoint) and any cost/consumption note. Since an output schema exists it need not describe return values, but the input-side workflow context 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?

Top-level schema description coverage is 0% (the single 'body' array parameter is undocumented). The description compensates only partially by implying a page URL and referencing a 'similarity index,' but it never explains the required task 'id', or the limit/offset/similarity controls, so an agent cannot infer how to shape the request.

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

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

The description states a specific verb and resource: it 'returns a list of pages that have content similar to the page specified in the request,' which clearly identifies duplicate-content detection and separates it from siblings like duplicate_tags or keyword_density. It does not explicitly name or contrast with any sibling, which is what keeps it from 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 mention of alternatives. The phrase 'the page specified in the request' gestures at input but never says when an agent should pick this endpoint over the other OnPage endpoints.

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

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

Annotations declare openWorldHint, destructiveHint, and non-idempotency, but the description adds nothing: it does not mention that this performs a live outbound fetch of the target URL, that it may be slow or rate-limited, or why a measurement operation is flagged destructive. Note a mild tension between the 'measuring quality' framing and destructiveHint=true, though the text makes no explicit read-only claim.

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 padding and the relevant framing is front-loaded, but the sentence earns little of its place since it conveys background rather than actionable tool information. Brief, but briefness here stems from under-specification.

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 for a single-parameter tool with many nested sub-fields and no useful annotations, the description omits the essential fact that it triggers a live Lighthouse run on one URL and returns the scored result. It is inadequate for correct 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 top-level schema description coverage is 0%, so the description is expected to compensate for the single 'body' parameter, and it does not. It says nothing about required URL formatting, audits, categories, version, for_mobile, or language fields, all of which matter for calling this correctly; only the nested schema fields carry that information.

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 defines what the underlying OnPage Lighthouse API is based on, not what this tool does. It never states the action (run a live Lighthouse audit against a URL) or the output form, so an agent cannot distinguish it from siblings like get_dataforseo_on_page_lighthouse_audits or post_dataforseo_on_page_page_screenshot. It borders on restating the name rather than describing the 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?

There is no when-to-use guidance, no indication that this is the endpoint that actually executes a run versus the metadata endpoints (languages, versions, audits), and no exclusions. The agent must infer usage purely 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?

Annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=false and openWorldHint=true, so the mutation/one-shot profile is covered without the description. The description adds no behavioral context of its own — it does not mention task submission, the dependency on a prior Task POST, or async result retrieval. It also never mentions that page_to/page_from isolate internal links, which is the only behavior-shaping constraint it could have surfaced.

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

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

The opening sentence is front-loaded and effective, but the link-type enumeration is a single run-on sentence that mixes format boilerplate with content and could have been condensed to a short list. Nothing is outright wasted, yet the structure is dense and hard to scan.

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 POST task endpoint whose single parameter is an array-of-objects body containing a required id and six optional fields, the description omits the task lifecycle entirely (submit -> id -> poll), which is the key thing an agent needs. An output schema exists so return values need not be described, but the prerequisite and pagination context is 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?

Coverage is reported at 0% for the parameter surface, so the description is expected to compensate and does not: it says nothing about id, limit, offset, filters, page_to/page_from, or search_after_token. The only indirect help is the link-type enumeration, which hints at values usable in the 'direction'/'type' filters, but no parameter is explained.

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: 'provide you with a list of internal and external links detected on a target website,' then enumerates the supported link types (anchor, image, canonical, meta, alternate, redirect). This lets an agent distinguish it from generic crawl tools, though it never contrasts itself with close siblings like resources or uncrawlable_resources.

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

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

There is no when-to-use guidance at all: no statement that this is a task-submission endpoint, no note that the required id must come from the Task POST endpoint before this can be called, and no routing between this and the other on_page link-adjacent siblings. The agent must infer everything 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?

Annotations declare destructiveHint=true and readOnlyHint=false, yet the description characterizes the operation purely as a retrieval ('returns a list of pages'). An agent reading the description would assume a safe read, directly conflicting with the destructive annotation, so the safety profile is misrepresented.

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, well-formed sentence that front-loads the core purpose with no filler. It is appropriately sized, though it omits any usage or prerequisite framing that would make it more 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 values need not be explained, but the description omits the task-ID prerequisite, any usage guidance, and any parameter/pagination context. For a POST endpoint that requires an id obtained elsewhere, this leaves meaningful gaps for correct invocation.

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

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

With 0% schema description coverage reported and a single required 'body' array parameter, the description carries the full burden of parameter explanation, yet it says nothing about limit/offset pagination, filters syntax, or the required task id. The description adds no parameter meaning beyond what the nested schema already provides.

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

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

The description names a specific verb and resource ('returns a list of pages that are blocked from being indexed') and even defines what 'non-indexable' means via robots.txt/HTTP headers/meta tags. It is clearly distinguishable from other OnPage endpoints conceptually, though it does not explicitly contrast itself with the many sibling post_/get_ 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 guidance on when to use this tool versus alternatives, nor any mention of the prerequisite workflow. The schema's 'id' field reveals you must first obtain a task ID from the Task POST endpoint, but the description never states this dependency, leaving the agent without the context needed to invoke it successfully.

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

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

Annotations declare destructiveHint=true, openWorldHint=true and idempotentHint=false, but the description adds nothing behavioral: it doesn't say this is an asynchronous task submission, that it consumes credits/charges (several schema params mention additional charges), or that results must be retrieved via separate endpoints/pingback. With the annotation bar already low, the description still fails to add useful context.

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

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

Three sentences of generic API prose that never front-load the tool's actual action. Nothing is wasted in a harmful way, but the content is misallocated — the reader finishes without knowing what invoking this tool does.

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 isn't required, but for a destructive, non-idempotent, credit-consuming task submission with a complex 40+ field body, the description omits task-submission semantics, cost implications, and result-retrieval flow. It is materially incomplete 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 reported at 0%, so the description must compensate for the single top-level 'body' array parameter — and it does not mention the body, required fields, target, or max_crawl_pages. The rich per-field documentation lives entirely in the schema, so the description adds no parameter meaning of its own.

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 never states the tool's action — it explains what the OnPage API is and what it checks, not that this tool submits/creates an OnPage crawl task. Only the title ('Setting OnPage Tasks') hints at the verb, and the description never distinguishes this from sibling endpoints like force_stop or raw_html. This is closer to API marketing copy than a tool-purpose statement.

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 (e.g., force_stop to cancel, content_parsing/keyword_density to consume results). An agent gets no routing signal at all.

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

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

Annotations already declare openWorldHint=true, destructiveHint=true and idempotentHint=false, so the safety profile is covered. The description adds the useful workflow detail that results depend on a previously issued task and that the prompt must match the keyword from the POST request, but nothing about auth, rate limits, or the lifetime of the 30-day task.

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

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

Front-loads the purpose in the first sentence, then states the task_id requirement. Compact and mostly waste-free, with only the trailing 'Learn more in our Help Center' acting as mild filler.

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

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

An output schema exists, so return values need not be explained, and annotations carry the safety profile. The description adequately covers purpose and the key prerequisite for a POST-based result endpoint, with differentiation from siblings being the main remaining 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?

Context reports 0% schema description coverage at the top level, so the description should compensate, but it only names the required task_id and its source. It says nothing about prompt, fetch_content, include_links, or support_extra, though the nested schema (where the metric does not register) does document 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?

States a specific verb+resource: it summarizes SERP content and generates a prompt-driven AI response. Clear on its own, but it does not distinguish itself from near-identical siblings such as post_dataforseo_content_summary_live or the various LLM-response endpoints.

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 a prerequisite (you must supply task_id found in the POST response) which implies the tool is a follow-up/result-retrieval call. However, it never states when to choose this AI-summary endpoint over the sibling summary/LLM tools, leaving alternative selection to inference.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=false, openWorldHint=true, so the safety profile is covered. The description contributes useful behavioral context — 'real-time', 'top 100', and coverage of featured snippets and extra SERP elements — but says nothing about cost, rate limits, or that a required nested body must be supplied.

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

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

Two sentences, front-loaded with the core capability and with zero filler. Nothing is repeated or bloated, though there is room to spend a sentence on the parameters or engine identity instead of the generic second sentence.

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

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

An output schema exists, so return values need not be explained. However, for a live, billable, indexed SERP endpoint with a required nested request body, the description leaves the agent without engine identification, usage conditions, or parameter requirements needed to call it correctly.

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

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

Schema description coverage is reported as 0% and the description explains none of the body fields (keyword, device, os, language/location options, the language_code-or-language_name alternation). It only vaguely references 'the specified keyword, search engine, and location', which does not compensate for the documented 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?

It states a specific verb+resource ('Live SERP provides real-time data on top 100 search engine results') and mentions keyword/engine/location scoping, but never says the engine is Bing and never distinguishes itself from siblings like post_dataforseo_serp_google_organic_live or post_dataforseo_serp_youtube_organic_live. An agent must infer the Bing target from the tool name alone.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives among the many SERP siblings. It also omits any note that this is a paid, live request rather than a cached one. The agent gets no routing help.

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

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

Annotations already declare the profile (readOnlyHint=false, destructiveHint=true, openWorldHint=true, idempotentHint=false), so the bar is lower, but the description adds nothing behavioral: no mention that this is a live (billable, open-world) request, no auth or rate-limit notes, no note on whether the call mutates state or is merely an expensive read. No contradiction with annotations.

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

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

One front-loaded sentence with no filler, so nothing wastes space. However it is under-specified rather than well-scoped; brevity here reflects missing content rather than tight editing.

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