Web Search & Data API

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

With no annotations, the description must disclose behavior. It mentions keyless access, cost per call, and parameter ranges, but does not explicitly state the operation is read-only or describe rate limits/error handling. It provides some behavioral context but not comprehensive coverage.

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

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

The description is a single paragraph that efficiently packs purpose, return fields, use cases, cost, params, and an example. It is front-loaded with the purpose and reasonably concise, though a more structured layout could improve readability.

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

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

There is no output schema, so the description should describe the return structure. It lists the returned fields but does not specify the response format (e.g., array of objects) or pagination behavior. For a search tool with no schema, this is a notable gap, though the core information is 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?

The schema only defines a generic 'params' object with no properties, so the description must define parameters. It does so thoroughly: name, maxItems, top_works, with ranges and an example. This fully compensates for the schema's lack of detail.

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 performs author and researcher profile search, specifies the returned data (affiliation, publication count, citations, h-index, i10-index, most-cited papers), and names explicit use cases (author lookup, disambiguation, citation-metrics). This is a specific verb+resource and differentiates from paper-centric sibling 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 identifies when to use the tool via use cases (author lookup, disambiguation, citation-metrics) and notes the keyless OpenAlex source. However, it does not explicitly mention alternatives or when not to use it, though the sibling tools are mostly paper-related so the context is reasonably clear.

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

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

No annotations are provided, so the description carries the full burden. It mentions the cost per call ($0.05/call) and the type of data returned (transactions, politician, ticker, amount, date), but it does not disclose details about response format, error handling, rate limits, or potential side effects. The description is adequate but not rich in behavioral detail.

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

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

The description is compact and front-loaded with the core purpose. It packs the parameter list into a single sentence, which is somewhat dense but efficient. The example at the end aids comprehension. It could be more structured (e.g., bullet points) but remains concise and readable.

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

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

Given that the schema provides no parameter definitions, the description covers all the necessary parameter details and includes an example. It does not mention output format or error behavior, but for a data lookup tool this is arguably sufficient. The absence of explicit optional/required flags for parameters is a minor gap, but the example helps infer typical usage.

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

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

The schema only defines a 'params' object with additionalProperties, leaving all parameter semantics to the description. The description thoroughly explains each parameter: politician (name substring), ticker (exact), chamber (house|senate), dateRange (format with example), type (substring with examples), and maxItems (integer). This fully compensates for the lack of schema detail.

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's purpose: 'US congressional stock trades' with details about the STOCK Act and the data fields (politician, ticker, amount, date). This is specific and distinguishes it from generic search tools. It also includes pricing, which further clarifies its role.

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 explicitly mention when to use this tool versus alternatives. It provides an example query ({'ticker': 'NVDA', 'chamber': 'house'}) but no comparative guidance. Since there are no sibling tools dedicated to congressional trades, the need for explicit differentiation is lower, but the dimension asks for when-to-use guidance, which is missing.

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

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

With no annotations provided, the description carries the full burden. It discloses the data sources (NIST NVD and GitHub Security Advisories), the filtering capabilities, and even the cost structure ('Keyless. [$0.01/call]'), giving a transparent picture of the tool's behavior without hidden 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?

The description is informative and packed with details, yet it remains structured and readable. It could be slightly more compact by trimming the redundant example, but overall it is efficient and well-organized.

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 moderate complexity, the description covers all essential aspects: purpose, data sources, output fields, parameters, example usage, and cost. It even notes the absence of authentication ('Keyless'), making it sufficiently complete for an agent to decide when and how to use it.

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

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

Although the schema only exposes a generic 'params' object, the description details the meaningful keys (cve_id, keyword, severity, source, maxItems) with formats and examples. This adds substantial semantic meaning that the schema alone lacks, effectively documenting the parameters despite the generic 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 clearly states a specific action ('CVE vulnerability lookup') and the subject ('security vulnerability records'), making it distinct from sibling tools like serp or domain_info. It enumerates the data fields returned, so an agent immediately knows what this tool does.

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 suggests when to use the tool ('For vulnerability triage and dependency risk checks'), providing clear context. However, it does not explicitly contrast with alternatives or state when *not* to use it, so it falls slightly short of full explicit 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 mentions the cost per call ($0.03/call), which is a behavioral detail, but it does not explicitly state whether the tool is read-only or if it has other side effects. Given no annotations, this level of disclosure is partial but not fully transparent.

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

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

The description is succinct, covering purpose, cost, parameters, and an example in a compact format. The information is well-organized and directly relevant, with no redundant or vague phrasing.

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

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

The description includes the tool's purpose, cost, parameters, and an example, which is enough for basic invocation. However, it does not describe the output format or data structure returned, which would be helpful for agents expecting a particular result. The absence of an output schema increases this need slightly.

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

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

The schema provides no specific parameter definitions (only a generic 'params' object), so the description carries full weight. It explicitly lists the parameters (domain, record_type) with types and allowed values (A|AAAA|CNAME|MX|NS|TXT), plus a concrete example, making the parameters fully clear.

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 tool as a DNS propagation checker that compares DNS records across specific public resolvers. It uses the verb 'compares' and specifies the resource (DNS record) and the scope (public resolvers), which distinguishes it from related domain 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 states its intended use ('to spot propagation lag or split-horizon answers'), giving a clear context for when to invoke it. While it doesn't explicitly compare to sibling tools like domain_info, the niche purpose is well-defined and leaves little ambiguity.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It mentions the $0.02/call cost but omits potential side effects, rate limits, auth requirements, or behavior for invalid/nonexistent domains. No contradictions with annotations exist, but the transparency is incomplete.

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 concise and well-structured. It front-loads the core purpose, lists the returned data in a clear sequence, and includes cost and parameter details without redundant fluff. Every sentence contributes useful 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 lookup tool, the description covers the essential aspects: what it does, what data it returns, the input parameter, and cost. It does not describe the return format, error handling, or data freshness, but these are less critical given the tool's simplicity.

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

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

The schema provides no concrete parameter definitions, so the description is the sole source of parameter meaning. It explicitly names the parameter 'domain', specifies its type as string, and provides an example ('example.com'). It does not clarify whether the parameter is required or the exact format, but it is sufficient for basic usage.

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 performs a 'Domain WHOIS and DNS lookup' and lists the specific data returned (registrar, dates, nameservers, DNS record types). This differentiates it from sibling tools without ambiguity.

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

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

No explicit guidance on when to use this tool over alternatives. For example, it does not contrast with 'dns_propagation' or other domain-related tools, leaving the agent to infer selection criteria. The example param is helpful but does not address use-case 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?

Description discloses cost per call ($0.01/call), which is important operational information. It implies a read-only operation with no side effects, but does not mention rate limits, authentication requirements, or error behavior. Since no annotations are present, the description carries the burden and could be more explicit.

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

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

The description is compact and well-structured: a one-sentence purpose, cost inline, and a bullet-style parameter list with an example. Every sentence adds value without redundancy.

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

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

The description explains the input and the general behavior (address to coordinates, coordinates to address) but does not describe the output format or structure. Given the opaque schema and no output schema, a brief mention of the response (e.g., 'returns lat/lon' or 'returns formatted address') would improve completeness. However, the core purpose is fully 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?

Parameters q, lat, lon, and maxItems are listed with a concrete example, making their purpose clear. However, the schema is a generic freeform object with zero coverage, so the description is the only source. It lacks constraints (e.g., valid lat/lon ranges, maxItems bounds), but the given example covers the primary use case.

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

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

Description clearly states it performs both forward and reverse geocoding, converting addresses to coordinates and vice versa. This distinguishes it from all sibling tools, which are focused on search, academic, or domain-specific data retrieval.

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 guidance is implicit via parameter explanation: 'q' for forward geocoding, 'lat' and 'lon' for reverse geocoding. An explicit statement like 'use q when you have an address, use lat/lon when you have coordinates' would strengthen clarity, but the current text is adequate.

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

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

No annotations exist, and the description only says 'GitHub data' without mentioning rate limits, authentication, or side effects, leaving behavioral implications unstated.

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 packed with information but arranged in a single dense paragraph with capitals and punctuation, which could be more readable with clear separation of modes and parameters.

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

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

It lists the types of data returned but does not describe the output structure. Given the absence of an output schema, this leaves some ambiguity for an agent expecting a detailed response format.

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

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

Although the schema only defines a generic 'params' object, the description explains the sub-parameters (mode, repos, q, usernames, maxItems) and provides an example, adding significant meaning beyond the sparse 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 that the tool retrieves GitHub data including repository stats, user profiles, and code-search results, making the purpose explicit and distinct from sibling 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?

It provides examples of modes and parameters, but does not explicitly mention when to prefer this tool over alternatives, nor when not to use it.

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

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

The description discloses the cost per call ($0.01/call), which is important for agents to consider. It does not explicitly mention side effects or read-only status, but the nature of a feed tool implies no side effects beyond the API call itself.

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 relatively concise and includes a compact example. The inclusion of the cost and example in the same paragraph makes it slightly less scannable, but overall it is efficient and 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?

Given the minimal schema, the description provides sufficient context about the tool's functionality and parameters. Since there is no output schema, it does not need to describe return values, and the description covers the required usage context adequately.

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

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

The schema only defines a generic 'params' object with additionalProperties allowed, so it provides no field-level semantics. The description compensates by specifying the actual fields (mode, q, maxItems) and their allowed values, including an example, giving full 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 clearly states the tool's purpose: it provides a Hacker News feed with top, new, and best stories plus full-text search. It also lists the data fields (titles, scores, comment counts, author), making the resource and operation unambiguous.

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

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

The description includes example parameters and explains the mode options, which gives some usage guidance. However, it does not explicitly state when to use this tool over similar sibling tools (e.g., serp, paper_search), leaving the selection to the agent's 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?

With no annotations, the description carries full burden. It discloses output behavior (ranking relative to strongest region), granularity (daily/weekly/hourly based on timeframe), and pricing ($0.03/call). It doesn't mention error behavior or read-only nature, but the core behavioral traits are covered.

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

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

The description is dense but well-organized: purpose, use case, price, then parameters with example. Every sentence adds value, though the timeframe enumeration in parentheses is a bit cluttered. It's front-loaded with the core purpose and scoping.

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

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

Given the generic schema and lack of output schema, the description must cover parameters, output semantics, and usage context. It does so thoroughly, including granularity and pricing. Minor gaps: no error handling or edge cases, but for a read-only data tool this is acceptable.

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

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

The schema only defines a generic 'params' object with additionalProperties true (0% coverage). The description fully compensates by explaining each parameter: keyword (search term), geo (ISO-3166 alpha-2 code, 213 countries), timeframe (with allowed values), and provides an example. This is essential for correct invocation.

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?

Clearly states the tool returns subregional breakdown of Google Trends interest for a keyword, with specific details on ranking (0-100 relative to strongest region). This distinguishes it from siblings like 'trend' (likely national) and related_queries/topics, making the purpose unambiguous.

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

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

Explicitly gives use cases: 'regional demand mapping, geo targeting, and finding where a keyword over-indexes before spending on it.' It implies when to use (need regional breakdown) but doesn't explicitly contrast with alternative tools like 'trend' for national-level data. Clear context, no exclusions.

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

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

The description explicitly states 'Keyless' and '[$0.08/call]', disclosing authentication requirements and cost. The language strongly implies a read-only retrieval operation ('get one structured result'), but it does not mention rate limits or explicitly state that no data is modified.

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 organized, moving from purpose to output to cost to parameters and example. It could be slightly tightened, but nearly every sentence adds useful information and the structure makes it 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?

Given the empty schema and no annotations, the description covers the essential input parameters, output structure, deduplication behavior, identifier formats, and pricing. It does not mention error handling or what happens when neither q nor id is supplied, but the core usage context is complete enough for an agent.

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?

Although the JSON schema is generic and provides 0% coverage, the description fully compensates by defining the meaningful parameters: q, id, doi, and maxItems, including their roles, accepted identifier forms, and limits. The example further clarifies usage.

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 that the tool produces a literature review map from a seed paper or topic query, and enumerates the exact output contents (references, cited-by, related work, deduplicated table with specified fields). It also positions itself as consolidating search, citation lookup, and related-paper discovery into a single call.

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

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

The description explains how to invoke the tool with either q or id/doi, defines maxItems as the per-section node limit, and gives an example. It also contrasts itself with separate search/citation flows, though it does not explicitly name sibling tools or spell out exactly when to prefer this tool over each 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?

The description mentions the cost ('[$0.03/call]') and the backend sources ('Keyless via OpenAlex and Semantic Scholar'), providing transparency about pricing and data origin. It does not indicate any destructive or state-changing behavior, implying a read-only operation, though it does not explicitly state this.

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

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

The description is compact but dense, containing purpose, parameters, cost, and an example in a single paragraph. It is well-structured with clear parameter definitions and an example, though the repeated mention of 'citation lookup' could be trimmed slightly without losing meaning.

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

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

It covers the tool's purpose, accepted identifiers, parameters, cost, and an example, which are sufficient for an agent to decide to use it. It does not describe the exact return format or error handling, but those are not essential for a straightforward lookup and are likely handled by the tool's standard response.

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?

Although the schema only defines a generic 'params' object, the description enumerates all relevant parameters (id, doi, ref_limit, cite_limit) with their purposes and provides a concrete example. This fully compensates for the schema's lack of parameter detail.

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 tool as a citation lookup and reference list for a paper, specifying that it returns references and cited-by lists given a DOI, arXiv id, OpenAlex id, or PMID. It also states the intended use case: 'for bibliography building and citation lookup', which removes ambiguity.

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

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

The description provides clear input options and the operations performed, such as returning references and cited-by works. It does not explicitly contrast with sibling tools like papers or related_papers, but the specific terminology 'bibliography building and citation lookup' gives a strong contextual hint for when to invoke this tool.

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

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

The description reveals key behavioral aspects: it is keyless and has a cost per call. It also indirectly implies a read-only operation, but it does not explicitly state side effects, rate limits, or potential error conditions. Without annotations, this leaves some behavioral aspects undisclosed.

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

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

The description is moderately concise, including necessary details about input types, output, pricing, and an example. It is well-structured, though slightly verbose with repeated mentions of the identifier sources.

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 minimal schema, the description provides essential context: what the tool does, what inputs it accepts, and what output to expect. It omits edge-case handling, but that is not critical for a typical tool description.

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

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

Although the schema only reveals a generic 'params' object with no defined properties, the description explains that it expects 'id' or 'doi' keys and elaborates on the accepted identifier formats. This adds significant meaning beyond the schema, though it could be more explicit about the alias relationship.

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's purpose: retrieving full text and open-access PDFs for a paper using various identifiers. It explicitly mentions the output format (sections, PDF location) and distinguishes it as a post-search retrieval tool, making its role unambiguous.

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

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

It provides usage guidance by describing the tool as 'the now read it call after a paper search' and listing accepted identifier types. However, it does not explicitly mention alternative tools or when to prefer them, but the contextual hint is sufficient for most use cases.

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

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

With no annotations provided, the description carries the full disclosure burden. It usefully discloses keyless access, the $0.02/call cost, deduplication, and the ranked result-set format. However, it omits rate limits, pagination behavior, and error/empty-result handling, which are relevant for a keyless paid API.

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 every sentence earns its place: purpose, output fields, capabilities, cost, and a complete parameter list with a worked example. The param enumeration is long but necessary given the empty schema; it is front-loaded with the core purpose before details.

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

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

For a search tool with no output schema and no annotations, the description covers the purpose, output fields, all parameters, cost, and access model. Remaining gaps — explicit response shape, rate limits, pagination beyond maxItems — are minor given the field list already implies the return format.

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

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

Schema coverage is 0% — the schema only exposes a loose 'params' object with additionalProperties. The description fully compensates by documenting every parameter (q, source with its enum, maxItems 1-50, year_from/year_to inclusive, sort with its enum) and providing a concrete example call. This is exactly the compensation the rubric demands at low coverage.

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

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

The description states a specific verb and resource — search research papers across arXiv, PubMed, OpenAlex, Crossref, and Semantic Scholar in one call — and enumerates the returned fields (title, authors, year, venue, abstract, citation count, DOI, PDF link). It distinguishes itself from siblings like paper_details, paper_fulltext, and author_search by framing itself as the multi-source ranked search, 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?

The description explains how to use the tool (query by keyword, restrict to one source, filter by year, sort), but never says when to use it versus alternatives like paper_details, paper_fulltext, or related_papers, and gives no exclusions. Usage is implied by its search-focused framing rather than stated explicitly.

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

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

With no annotations, the description carries the full burden. It discloses keyless access and cost ($0.03/call) and mentions the fallback mechanism ('via Semantic Scholar recommendations with an OpenAlex related-works fallback'). It does not mention rate limits or error handling, but these are not critical for a read-only search tool.

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

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

The description is well-structured: purpose, input type, service details, cost, parameter list, and example. It is slightly long but each sentence adds value. The example clarifies usage without redundant text.

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

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

There is no output schema, so the description should give some output context. It states the tool 'returns semantically similar and recommended scholarly papers', which is a high-level output, but does not detail response structure or error behaviors. For this simple search tool, the omission is minor and does not hinder basic use.

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?

Although the JSON schema only wraps a generic 'params' object, the description thoroughly explains each parameter: id (arXiv/DOI/OpenAlex), doi (alias for DOI), q (query alternative), and maxItems (1-50). It also provides an example usage. This fully compensates for the schema's lack of detail.

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's purpose: 'Literature review and related-paper discovery' that returns 'semantically similar and recommended scholarly papers' given a seed paper or topic query. It names the specific resources (Semantic Scholar with OpenAlex fallback) and distinguishes itself from sibling tools like author_search or paper_details by focusing on related-paper discovery.

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

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

It provides clear conditions for use: 'Given a seed paper (arXiv id, DOI, or OpenAlex id) or a topic query'. It also suggests a use case: 'to expand a reading list or systematic review'. However, it does not explicitly compare to sibling tools or state when not to use it, leaving some inference to 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?

With no annotations provided, the description carries the transparency burden. It explains the output shape (scored queries and growth) but does not mention potential errors, rate limits, or behavior when a keyword has no related queries. It is honest about what is returned, but omits edge-case 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 verbose and contains redundant information. The timeframe allowed values are listed twice: once as prose describing daily vs. weekly series, and again as a parenthetical pipe-separated enum. This repetition adds length without adding clarity, though the core content is well-organized.

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 lack of an output schema, the description adequately explains the result format (top queries relative scores, rising queries with growth) and provides all needed input conventions. It lacks explicit error-handling information, but otherwise gives a complete picture for an agent to make and interpret a 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 input schema is generic (a single free-form params object) and provides no property definitions, so the description fully compensates. It explains that 'keyword' is the search term, 'geo' is an ISO-3166 alpha-2 country code, and 'timeframe' is one of an explicit enum list, including an example illustrating usage.

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 Google Trends related queries for a keyword, describing both top queries (scored 0-100) and rising queries (with percentage growth), and positions it for SEO keyword research, content planning, and spotting breakout demand. This distinguishes it from similar sibling tools like related_topics and interest_by_region.

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

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

The description includes concrete usage guidance: an example parameter set for 'bitcoin' in the US, a full allowed timeframe list, and geo format specification. It states the primary use cases but does not explicitly contrast with sibling tools like related_topics or interest_by_region, which would have made the when-to-use guidance stronger.

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 discloses the cost ($0.03/call) and details the response format (top topics, rising topics, granularity). It is explicitly read-only in nature ('Returns', 'reports'), with no hidden side effects. This is fully transparent given no annotations are provided.

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

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

The description is well-structured: it opens with a one-sentence summary, then describes the output, cost, parameters, and response granularity in a logical order. It avoids unnecessary repetition and is information-dense without being 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 description covers the tool's purpose, output characteristics, pricing, all parameter details (including constraints and defaults), and response timeframes. It gives an example invocation. No critical operational detail is missing for an agent to use the tool 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?

Even though the schema only has a generic 'params' object, the description thoroughly documents the actual parameters: keyword, geo (with country code examples and supported count), and timeframe (with all allowed values and response granularity semantics). It also provides an example. This fully compensates for the lack of schema detail.

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's function: 'Google Trends related topics for a keyword.' It specifies the output (topics, named entities, scores, percentage growth), the geographic scope, and provides a concrete example. This is unambiguous and distinguishes it from generic trend tools.

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

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

The description includes a use case ('market research and content planning') and an example invocation, which guides when to employ the tool. However, it does not explicitly contrast with sibling tools like related_queries or interest_by_region, so the guidance is not as sharp as it could be.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals that the tool outputs markdown plus structured metadata (title, headings, links, word count), is keyless, costs $0.03 per call, and is limited to a single page per call. It does not mention error handling or rate limits, but for a simple scraping tool, it covers the key behavioral aspects.

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 main purpose and includes essential details (cost, parameters, example) in a compact format. It is informative without being verbose, and the structure flows logically from purpose to constraints to parameters. It could be slightly more concise, but it earns its length.

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-URL scraper with a weak schema and no output schema, the description covers the necessary context: what it does, what it returns, its constraints (single page, no key), cost, and parameter semantics. It doesn't discuss error handling or edge cases, but these are not critical for a simple tool. An agent has enough information to invoke it correctly.

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

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

The input schema is minimal (a generic 'params' object with arbitrary properties) and schema description coverage is 0%, so the description must compensate. It does so by explicitly naming 'url' and 'maxChars' with brief explanations ('page URL to scrape', 'markdown cap') and provides an example. This adds meaning beyond the schema, though it doesn't elaborate on optional constraints or defaults.

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's purpose: scraping a single web page to clean markdown. It names the specific verb ('Scrape') and resource ('any web page'), and differentiates itself from siblings by highlighting it is a single-page scraper, not a site crawler, and a per-call alternative to Firecrawl. This is specific and distinguishes it from other tools like serp or domain_info.

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

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

The description provides clear context for when to use the tool: for reading a page without a browser, with no API key, and as a per-call alternative to Firecrawl. It explicitly states 'Single page per call, not a site crawler,' which excludes crawling use cases. While it doesn't explicitly list when not to use it beyond that, the context is sufficient for an agent to decide.

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 discloses key behavioral traits: 'Keyless' and '[$0.05/call]' reveal access and cost, and it lists the output fields (company, form type, filing date, accession number, document link). However, it does not mention rate limits, pagination behavior, error handling, or the maximum number of results, which are important for an agent to understand the tool's response characteristics. Since no annotations are provided, the description carries the full burden and these omissions lower the score.

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 paragraph but well-structured, with a clear breakdown after 'Params —' and an example at the end. Every sentence contributes either to explaining functionality, parameters, or cost. It is slightly dense but not verbose or repetitive, maintaining good information density.

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 there is no output schema and the input schema is minimal, the description provides essential context: the tool's purpose, search inputs, example usage, cost, and the fields returned. It lacks details on pagination, result limits, and error responses, but the tool is a straightforward search function, and the description covers the core information an agent needs to make an initial call. The example further aids understanding.

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 actual JSON schema only defines a single 'params' object with no inner structure, providing zero coverage. The description compensates by explicitly listing and explaining each intended parameter: q (full-text query), company (entity name), cik (SEC CIK), type (form type with examples), dateRange (format YYYY-MM-DD..YYYY-MM-DD), and maxItems (integer). It also includes a concrete example, making the semantics completely clear despite the schema's opacity.

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's purpose: 'SEC filings full-text search' with explicit details on the types of filings (10-K, 10-Q, 8-K, and every other form type) and the search facets (keyword, company name, ticker, CIK, date-range). It is distinct from sibling tools like 'congress_trades' or 'author_search' by its focus on SEC EDGAR filings, leaving no ambiguity about its function.

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 states 'For SEC filings research and disclosure monitoring,' which indicates the appropriate use case. While it does not explicitly contrast with sibling tools, the specificity of the domain and search parameters makes it clear when this tool should be chosen. It lacks an explicit 'when not to use' statement, but the purpose is distinct enough to infer usage context.

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

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

With no annotations provided, the description carries the full transparency burden. It explains result fields, news fallback to web, engine fallback behavior, and the cost per call, making the tool's behavior quite predictable.

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 and information-rich, but it is written as a long run-on paragraph with many embedded clauses and parentheticals. It could be clearer with structured bullets or separated option lists, though no sentence is pure 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?

Given the tool's complexity, the description covers the main behavior, all major options, fallback behavior, and an example call. It does not describe error cases, but it provides sufficient context for an agent to invoke the tool 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 schema only exposes a generic 'params' object, but the description fully documents the accepted parameters and their value formats, including q, num_results cap 25, region, timelimit, safesearch, page, mode, and engine. This fully compensates for the opaque 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 identifies the tool as a keyless web search returning ranked title, URL, and snippet, and enumerates its search options. It is distinguishable from the sibling tools by its explicit 'SERP' purpose, though it does not explicitly contrast itself with serp_batch/serp_multi/serp_read.

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

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

It provides a concrete example and recommends the 'auto' engine, including fallback behavior when pinned engines fail. However, it does not explicitly say when to choose this tool over related sibling search tools like serp_batch, serp_multi, or serp_read.

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

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

No annotations are provided, so the description carries the burden. It discloses that the call is paid and mentions cost savings, but it does not explicitly state read-only behavior, side effects, rate limits, or failure modes. The read-only nature of a search is inferable but not stated.

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

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

The description is compact and information-dense, covering purpose, output, cost, and all parameter options in a single paragraph. Some redundancy exists (e.g., referencing filters twice), but the structure is efficient and easy to parse.

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 moderate complexity and the lack of an output schema or annotations, the description covers the main purpose, output shape, cost, and parameter values. However, it does not specify defaults, required parameters, error behavior, or pagination, leaving some gaps for an agent to infer before invoking.

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

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

The schema only exposes a free-form 'params' object with no properties, so the description provides essential semantics. It explains the 'queries' format with '|' separation, the 25-result cap, and allowed values for region, timelimit, safesearch, mode, and engine. It lacks defaults and required-field clarity but substantially compensates for the empty schema.

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

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

The description clearly states the tool performs bulk web searches, accepts up to 5 queries per call, and returns ranked title, URL, and snippet for each. The verb 'search' and resource 'web' are explicit, and the outcome is defined precisely.

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 indicates the tool is for multiple web searches in one call and highlights a cost advantage ('one paid call instead of five'), but it does not explicitly state when to prefer this tool over similar siblings like serp or serp_multi, nor does it mention prerequisites or 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?

With no annotations provided, the description carries the full burden, and it delivers: it discloses result deduplication by URL, reciprocal-rank fusion, per-engine rank attribution, the $0.05/call cost, and the web-only limitation. This goes well beyond a generic tool description, though a mention of error behaviors or rate limits would have pushed it higher.

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 purpose is front-loaded in a clear opening sentence, but the parameter list is a run-on that mixes periods, semicolons, and colons awkwardly: 'Params — q: search query; engines: comma list of 2-3 engines: yahoo, yandex (web mode). news mode has a single live engine (bing), so multi-engine is web-only; num_results: ...' The news-mode note is embedded mid-list, making it harder to parse than a clean structured list would be.

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 no output schema and no annotations, the description covers a lot: what it does, why to use it, all parameters with formats, cost, and limitations. The main missing piece is a description of the return format (what a merged/deduplicated result set looks like), which would help an agent interpret the output without an output schema.

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

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

The schema is essentially opaque (a single nullable 'params' object with additionalProperties: true and 0% coverage), so the description must compensate. It lists all seven keys (q, engines, num_results, region, timelimit, safesearch, mode) with types, constraints (e.g., 'cap 25', 'on|moderate|off'), and a concrete example. A brief note on the exact engine enumeration (whether Brave is a valid engines value, given the first sentence mentions it but the engines list only shows 'yahoo,yandex') is the main 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 specific verb ('search'), a resource ('web'), and a distinguishing mechanism ('fanned out across 2-3 search engines (Brave, Yahoo, Yandex)... merged by reciprocal-rank fusion'). It clearly differentiates from sibling tools like serp (presumably single-engine) by emphasizing the multi-engine metasearch approach, and the name itself (serp_multi vs serp/serp_batch) reinforces the 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?

It provides a rationale for when to use it ('consensus ranking across engines instead of one engine's bias') and a caveat on when not to ('news mode has a single live engine (bing), so multi-engine is web-only'). However, it never explicitly compares against serp, serp_batch, or serp_read (e.g., 'use this instead of serp for broader coverage'), leaving some selection guidance implicit.

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

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

No annotations are present, so the description carries the full burden. It discloses per-URL error reporting, cost per call, caps on fetch_top and num_results, and parameter constraints. It does not mention rate limits or authentication, but for a read-only search+scrape tool these are minor gaps.

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

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

The description is long but every section earns its place: purpose, error behavior, cost, and a structured parameter list. It is front-loaded with the core value proposition and avoids redundancy. The parameter list is necessary given the number of options.

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

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

There is no output schema, so the description must convey return shape. It states the tool returns ranked search results with per-page markdown content and mentions error reporting. It includes caps and an example. Missing details like the exact JSON structure or whether content may be null for some results are not critical for a well-specified 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 coverage is 0% because the schema only exposes a generic params object, so the description is the sole parameter documentation. It enumerates all parameters with explanations, caps, and an example, fully compensating for the missing schema details.

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 line clearly states the tool combines web search and page reading into one call, with a specific purpose of answering with sources. It distinguishes itself from siblings by noting it returns both SERP and page content, eliminating a second scrape call.

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 when to use it (when you need search results plus page content) and contrasts with a two-call alternative ('without a second round of scrape calls'). It does not explicitly name sibling tools like serp or scrape, nor state when NOT to use it, but the context is clear enough for an agent to route appropriately.

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

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

With no annotations provided, the description carries the full burden of explaining behavior. It specifies the return type (dated series 0-100), the granularity depending on timeframe, optional country filter, and the $0.05/call cost. It does not explicitly state that the operation is read-only or describe error conditions, but the read-only nature is strongly implied.

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 informative but somewhat redundant: it states the default weekly/daily/hourly granularity twice and repeats the phrase about returning search interest. The structure could be tightened without losing any essential detail.

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

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

Given the loose schema and no output schema, the description provides all necessary context: parameters, defaults, allowed timeframe values, output nature, cost, and an example invocation. Nothing critical is missing for an agent to call the tool 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 input schema exposes only a free-form `params` object with no property definitions, so the description completely compensates by documenting keyword, geo, and timeframe, including accepted values, defaults, and examples. This is essential and well covered.

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 Google Trends search interest over time as a dated series indexed 0-100, which distinguishes it from region/topic/query-focused sibling tools. It also names concrete use cases like keyword trend analysis and SEO research.

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

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

The description provides clear context for when to use the tool ('For keyword trend analysis, search demand seasonality, and SEO keyword research') and explains the default timeframe and optional country targeting. It does not explicitly contrast with sibling tools like interest_by_region, so it stops short of a perfect 5.

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