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

The description goes well beyond the annotations: it discloses that execution is a synchronous network call via a specific Apify Actor, that it creates a billed Actor run and dataset on the user's Apify account, that it requires APIFY_TOKEN, and that latency is 15-40 seconds with a 120-second timeout. This is rich behavioral context that annotations alone do not 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 well-structured with clear sections (Behavioral Transparency, Usage Guidelines) and front-loads the core purpose. It is slightly longer than strictly necessary, but every section earns its place by providing actionable guidance. The formatting aids scanning.

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 (2 params, 1 required, output schema present), the description covers the essential operational context: what it searches, when to use it, what side effects occur, auth requirements, and latency. The output schema handles return-value documentation, so nothing critical is missing.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (location and max_results) with types, defaults, and constraints. The description adds no additional parameter-level meaning 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 states a specific verb ('Search') and resource ('vacation rental listings, nightly prices, occupancy ratings, and property classifications from Airbnb'). It clearly distinguishes this from siblings by naming the domain (Airbnb short-term rentals) and the data fields returned. The title reinforces the scope.

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

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

The description explicitly provides 'When to use' and 'When NOT to use' sections, and names three sibling alternatives (google_maps_search, glassdoor_jobs_search, sec_edgar_filings) with the conditions for choosing them. This is exactly the kind of routing guidance an agent needs.

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 execution model (synchronous cloud Actor), side effects (billed run and dataset), authentication requirement (APIFY_TOKEN), latency expectations, and timeout cap. These go well beyond the annotations and add practical context without contradicting them; the readOnlyHint refers to the public registry source, not the platform-side billed run.

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 main capability is front-loaded in the first sentence, followed by clearly labeled Behavioral Transparency and Usage Guidelines sections. Every section earns its place and the formatting 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?

The description covers purpose, scope, alternatives, side effects, authentication, latency, and parameter trade-offs. An output schema exists, so return-value details are not required here; nothing important is missing for correct tool 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?

With 100% schema coverage, the schema already explains parameters well. The description adds meaningful behavioral nuance, such as include_details making runs slower and max_results affecting billing, which helps agents choose parameter values wisely.

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

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

The description uses a specific verb and resource: 'Search official Alabama Secretary of State business-entity records by company name' and lists the exact returned fields. This clearly distinguishes it from multi-state, Florida, and contractor-license siblings.

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

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

The description explicitly gives 'When to use', 'When NOT to use', and 'Named alternatives'. It tells agents to prefer 'us_business_entity_search' for combined state lookups and 'california_contractor_license_search'/'us_contractor_license_search' for contractor licenses, leaving no ambiguity about routing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description goes further by detailing execution mode (network call via Apify Actor), side effects (read-only, hitting Apple's public endpoints), authentication requirements (APIFY_TOKEN), and concrete limits (5-30s latency, 500-review cap, 120s timeout). This adds valuable operational context beyond the annotations.

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

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

The description is well-structured into a concise main sentence followed by clearly labeled sections (Behavioral Transparency, Usage Guidelines). Every sentence adds value: the purpose is front-loaded, operational details are scannable, and usage rules are explicit. There is no fluff or redundancy, making it efficient for an agent 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?

With 9 parameters fully described in the schema, a rich output schema present, and annotations covering read-only and idempotent behavior, the description adds the missing pieces: execution method, authentication, latency, limits, and routing rules. Nothing an agent needs to correctly invoke this tool is absent. It is complete for a tool of this complexity.

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

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

Input schema has 100% coverage with each parameter described (e.g., app_ids, countries, min/max_rating, recent_days). The description's main text does not add parameter-specific meaning, but the schema already provides it. The behavioral notes about the 500-review cap relate to max_reviews_per_app, offering marginal extra context. Baseline 3 is appropriate since the schema carries the semantic load.

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 clear resource ('Apple App Store'), and enumerates the exact outputs: customer reviews with star ratings, review text, app version, and full metadata. It differentiates from sibling tools by naming alternatives like 'google_play_reviews_search' and 'google_maps_search' in the usage section, leaving no ambiguity about what this tool does versus its peers.

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

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

Provides explicit when-to-use scenarios (iOS reviews, ASO, competitor research) and when-not-to-use cases (Android, employer reviews, Mac-only titles), plus named alternatives for each exclusion. This is textbook guidance that lets an agent decide correctly without needing to infer 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?

The description goes far beyond the annotations (readOnlyHint, destructiveHint) by disclosing the execution model (network call via Apify Actor), side effects (billed run and dataset creation), authentication requirement (APIFY_TOKEN), and latency limits (10-30 seconds, 120s timeout). This is comprehensive and adds significant 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?

The description is well-structured with clear sections (main purpose, Behavioral Transparency, Usage Guidelines). Every sentence adds value, no fluff, and the core purpose is front-loaded. It remains readable despite covering many facets.

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 (network call, auth, billing, latency, output schema), the description covers all essential operational aspects: execution, side effects, authentication, latency, and usage boundaries. The presence of an output schema means return-format details are not required in the description. Nothing an agent needs to call 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 coverage is 100%, so all parameters already have detailed descriptions in the input schema. The description does not add extra parameter-level semantics beyond what the schema provides (e.g., the include_details speed tradeoff is already in the schema). Per the rubric, a baseline of 3 is appropriate when the schema carries the full burden.

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

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

The description opens with a specific verb-resource pair: 'Search public California CSLB records by contractor or business name,' and it enumerates the returned fields (license number, status, city, name type). This clearly distinguishes the tool from siblings like us_contractor_license_search, which covers multiple states, and general business registries.

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?

A dedicated 'Usage Guidelines' section explicitly states when to use (vetting, verification, lead building) and when NOT to use (Oregon-only lookups, business entity searches, non-contractor trades), naming specific alternative tools. This is the gold standard for routing an agent correctly.

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 goes well beyond annotations by disclosing that execution is a synchronous network call via a specific Apify Actor, that it creates a billed Actor run and dataset on the user's Apify account, that APIFY_TOKEN is required, and that typical latency is 10-30 seconds with a 120-second timeout. This is rich, actionable behavioral context that annotations alone do not 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 well-organized into purpose, behavioral transparency, and usage guidelines sections. It front-loads the core function, then adds necessary operational detail without fluff. Every sentence earns its place, and the length is justified by the cloud-execution and side-effect disclosures.

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 execution model, side effects, authentication, latency caps, use cases, exclusions, and alternative tools. An output schema exists, so return-value structure need not be spelled out. For a tool with network execution and billing side effects, 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%, so the input schema fully documents all three parameters with types, defaults, ranges, and examples. The description's mention of searchable dimensions broadly echoes the 'condition' parameter without adding meaning beyond the schema. Baseline 3 is appropriate given the schema already carries the parameter semantics.

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 specific resource ('official ClinicalTrials.gov registry'), and the scope of searchable entities (condition, intervention, sponsor, free-text keyword). It also lists the return fields, making the tool's purpose unmistakable and differentiating it from generic search tools.

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

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

The description provides explicit 'When to use' and 'When NOT to use' guidance, and names concrete sibling alternatives for adjacent domains such as openfda_search, epa_facility_search, and fec_campaign_finance_search. This gives an agent clear routing logic based on the user's intent.

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

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

Annotations cover readOnly/openWorld/destructive hints, but the description adds substantial operational detail: synchronous network execution via a named Apify Actor, billing side effects, APIFY_TOKEN requirement, latency expectations, and a 120-second timeout cap. There is no contradiction with the annotations; the billed run is a side effect of a read-only data fetch.

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 organized into labeled sections that front-load the core behavior and then cover operational and usage details. It is longer than average, but every section carries decision-relevant information such as auth, billing, latency, exclusions, and named alternatives.

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 scope, return shape, execution model, side effects, authentication, latency limits, exclusions, and alternatives. An output schema exists for detailed return values, and annotations cover the safety profile, so nothing critical is missing for an agent to select and invoke this 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?

Schema description coverage is 100%, and each parameter already includes type, constraints, defaults, examples, and behavioral notes such as the hospital-only fallback for provider_types. The description reinforces that results are normalized and covers the seven provider types, but it adds little per-parameter meaning beyond what the input 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?

States a specific verb ('Search') plus a precise resource: official CMS Provider Data Catalog directories for Medicare-certified providers. It enumerates all seven provider types and clarifies the consistent row shape, so an agent knows exactly what kind of data is returned. This clearly differentiates it from the many general-purpose 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 contains explicit 'When to use' and 'When NOT to use' sections, and it names exact alternative tools such as clinical_trials_search, epa_facility_search, and us_contractor_license_search. An agent can route correctly without needing to inspect other tool schemas.

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 execution style (synchronous cloud call via Apify Actor), side effects (billed Actor run and dataset), authentication requirements (APIFY_TOKEN), and latency bounds (10-60 seconds, 120-second timeout). This goes well beyond the annotations and adds important operational 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?

The description is organized into labeled sections with front-loaded purpose. Each paragraph adds distinct value—scope, behavior, cost/auth, latency, usage—without repeating schema content or padding.

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

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

For a multi-registry tool with five parameters and an output schema, the description covers all necessary context: purpose, exclusions, alternatives, authentication, cost, latency, and behavior. Nothing essential is missing for an agent to select and 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?

Schema description coverage is 100%, so all five parameters are already documented with meaningful descriptions. The tool description adds little parameter-level detail, so the baseline 3 is appropriate; the schema carries the semantics.

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: 'Search UK Companies House, French SIRENE, and the global GLEIF LEI register in one call.' It then lists the normalized fields returned, making the tool's scope concrete and clearly distinct from single-country siblings.

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

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

An explicit 'Usage Guidelines' section provides when-to-use, when-not-to-use, and named alternatives: us_business_entity_search, gleif_lei_search, and french_company_search. This gives an agent precise routing criteria without inferring from 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?

The description provides a full 'Behavioral Transparency' section that discloses execution as a synchronous cloud network call via a specific Apify Actor, the side effect of creating a billed Actor run and dataset, the authentication requirement (APIFY_TOKEN), and typical latency with a timeout cap. These details go well beyond the annotations (readOnlyHint, openWorldHint, etc.) and give the agent a complete picture of runtime behavior and costs. 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 well-structured with a one-sentence summary followed by clearly labeled sections for Behavioral Transparency and Usage Guidelines. It is concise relative to the amount of information conveyed, with no redundant or filler content. The essential information is front-loaded, making it easy for an agent to quickly grasp the tool's purpose and constraints.

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 (8 parameters, output schema, and annotations), the description covers all critical aspects: execution, side effects, authentication, latency, usage guidance, and alternatives. It does not describe the return format, but the presence of an output schema makes that unnecessary. The description is complete enough for an agent to decide when to use it and what to expect during 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 input schema provides 100% coverage for all 8 parameters, each with descriptive text, so the baseline is 3. The description itself does not add parameter-level semantics beyond what the schema already states; it mentions search_type and nature_of_suit only in passing, without additional context. Since the schema already handles parameter documentation, the description meets the baseline without exceeding it.

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

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

The description clearly states a specific action ('Search published judicial opinions or federal RECAP dockets') on a named resource (CourtListener) and enumerates the types of returned data. It also explicitly differentiates from siblings by naming alternative tools (sec_edgar_filings, us_business_entity_search) for other use cases, leaving no ambiguity about what this tool is for.

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 dedicated 'Usage Guidelines' section with explicit 'When to use' and 'When NOT to use' conditions, plus named alternatives. It clearly states the tool is for legal research, litigation monitoring, and docket screening, and warns against treating results as complete dockets or legal advice. This is exemplary guidance for selecting the right tool.

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

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

Annotations already signal read-only and non-destructive behavior, but the description goes further by disclosing that execution creates a billed Apify Actor run and dataset, requires APIFY_TOKEN, needs no NVD/CISA credentials, and can take 5-30 seconds with NVD rate limits. These operational side effects and constraints are valuable beyond the annotations and show no 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?

The description is organized under clear headings, front-loads the core purpose, and groups behavioral and usage details logically. Every sentence contributes operational, safety, or routing information with no filler or redundancy.

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

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

The description covers purpose, authentication, side effects, latency, rate limits, output limits, when-to-use, when-not-to-use, and a named sibling alternative. With the output schema present and 100% parameter coverage in the input schema, no critical guidance for correct invocation is missing.

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

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

Schema description coverage is 100%, so the input schema already documents each parameter thoroughly. The description adds only general operational context like output capping and typical run durations, not new per-parameter semantics. This matches the baseline for high schema 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 first sentence states the operation ('Search'), the resource ('NIST NVD'), and the enrichment set ('CISA Known Exploited Vulnerability status, remediation deadlines, ransomware use, CVSS, CWE, affected CPEs, and references'). This clearly distinguishes it as a vulnerability-intelligence lookup rather than a generic web search or scanner, and the title reinforces the exact scope.

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

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

The description explicitly lists when to use the tool (CVE research, vulnerability triage, patch prioritization, identifying active exploitation), when NOT to use it (as a network scanner or proof of asset vulnerability), and names a specific alternative (tech_stack_detector). This leaves no ambiguity about tool 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?

Beyond the annotations, the description discloses synchronous network execution, a billed Actor run and dataset creation on the user's Apify account, APIFY_TOKEN authentication, and latency/timeout limits. This is valuable behavioral context that annotations alone do not provide, and it does not contradict the readOnly/destructive hints.

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 it is well-structured with clear section headers and every section serves a distinct purpose. The opening sentence front-loads the core purpose, and the additional sections are informative rather than redundant.

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

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

For a tool with 5 parameters, an output schema, and external side effects, the description covers execution model, authentication, side effects, latency, exclusions, and alternatives. Nothing an agent needs to decide whether and how to invoke this tool is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning by naming the main search dimensions (state, facility name, NAICS code, environmental program) and explicitly warns that city, ZIP, and violation-only filters are unavailable in this MCP tool, which helps agents avoid invalid usage patterns.

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 ('official EPA ECHO service'), a clear verb ('Search'), and the exact output ('compliance status, inspection, and penalty data'). It also explicitly calls out which filters are NOT available in the MCP tool, helping differentiate it from the underlying Actor and from unrelated 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 has dedicated 'When to use' and 'When NOT to use' sections, plus named alternatives for each exclusion. This gives an agent explicit routing guidance and leaves no ambiguity about when to select this tool over siblings.

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

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

The description goes well beyond the annotations by disclosing that execution is a synchronous network call via a specific Apify Actor, that it creates a billed Actor run and dataset on the user's Apify account, that it requires APIFY_TOKEN, and that latency is typically 5-20 seconds with a 120-second timeout. It also explains how max_results and include_entities affect duration. This is rich behavioral context that annotations alone do not 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 well-structured with clear sections (Behavioral Transparency, Usage Guidelines) and front-loads the core purpose in the first sentence. It is longer than the minimum, but every section earns its place by providing operational and selection guidance. A small deduction because the behavioral and usage sections could be slightly tightened without losing 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 10-parameter network tool with an output schema, the description covers the essential operational context: what it searches, what it returns, how it executes, what side effects it has, what auth it needs, and when to use alternatives. The output schema handles return-value details, and the description covers the rest. Nothing an agent needs to decide whether to call this tool is missing.

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

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

Schema description coverage is 100%, so the schema already documents all 10 parameters. The description adds value by explaining the trade-off of include_entities ('adds roughly one extra request per 8 results') and by framing the query parameter as a 'Europe PMC search expression' with an example. It does not restate every parameter, which is appropriate given full schema coverage; a 4 reflects the added operational context 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 opens with a specific verb ('Search') and resource ('Europe PMC and PubMed'), and enumerates the search dimensions (topic, author, journal, publication year, open-access status) and the returned record fields (identifiers, abstracts, citation counts, MeSH indexing, funding, full-text links). This clearly distinguishes it from sibling tools like clinical_trials_search and openfda_search, which target different biomedical data sources.

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 has an explicit 'When to use' section listing concrete use cases (biomedical literature search, systematic-review scoping, citation tracking, funding provenance, open-access discovery, entity mining) and a 'When NOT to use' section naming two sibling alternatives (clinical_trials_search, openfda_search) with the conditions that route to them. This is exactly the guidance an agent needs to select the right tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: synchronous network call via Apify Actor, billed Actor run and dataset creation, APIFY_TOKEN requirement, and latency/timeout expectations. It does not contradict annotations. Minor gap: no detail on pagination or exact dataset output structure, but the output schema exists and the description covers the main behavioral traits.

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

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

The description is well-structured with clear sections (Behavioral Transparency, Usage Guidelines) and front-loaded purpose. It is somewhat long but every section earns its place, providing operational and routing details. The length is justified by the complexity of 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 tool's complexity, the output schema exists, and annotations cover safety, the description is complete. It covers execution model, side effects, auth, latency, exclusions, and alternatives. An agent has everything needed to select and 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 the schema already documents all parameters. The description adds meaning by explaining that data_type selects the record type and that fields differ across types, and clarifies that state filters the contributor's state for contributions. This goes beyond the schema's basic descriptions, though it doesn't deeply elaborate every parameter.

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

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

The description states a specific verb ('Search') and resource ('US Federal Election Commission's public register of federal candidates, committees/PACs, or individual campaign contributions'). It also explicitly notes that a single call returns one record type only, selected with data_type, which distinguishes it from a generic multi-type search. This is clear and differentiates from siblings.

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

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

The description provides explicit 'When to use' and 'When NOT to use' sections, including named alternatives like 'french_company_search', 'epa_facility_search', 'clinical_trials_search', and 'openfda_search'. It also states a key exclusion (contributor street addresses never returned). This is exemplary 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 readOnlyHint=true and destructiveHint=false, but the description goes well beyond them by disclosing synchronous cloud execution via a specific Apify Actor, billing side effects (billed Actor run and dataset), authentication requirements (APIFY_TOKEN), and latency limits. This gives the agent material operational context 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 organized into clear sections with front-loaded purpose and concise bullets for execution, side effects, authentication, latency, and usage guidance. Each section adds non-redundant, decision-relevant information, and no sentence feels wasted.

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

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

For a tool with 4 parameters, a rich output schema, and annotations, the description is complete: it covers the data source, return content, execution behavior, billing side effects, auth, latency, and use cases. Nothing critical an agent needs to decide or invoke 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%, so the input schema fully documents query, sort_order, max_results, and document_types. The description adds high-level context about returned fields and billing implications of max_results, but it does not meaningfully explain individual parameter meanings beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Search') plus a precise resource ('official US Federal Register rules, proposed rules, notices, and presidential documents'), and enumerates the returned content types. This clearly distinguishes it from the judicial, SEC, and grants-focused siblings.

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

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

The description explicitly provides when-to-use scenarios ('rulemaking monitoring, regulatory research, agency-action tracking...'), a when-not-to-use caveat (not legal advice, don't assume a proposed rule is in force), and names alternative tools like courtlistener_case_search and sec_edgar_filings. This fully addresses 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 readOnlyHint=true and destructiveHint=false, but the description adds substantial context: it reveals the synchronous network execution via a specific Apify Actor, the billing side effect (creates a billed Actor run and dataset), the APIFY_TOKEN authentication requirement, and latency/limits (10-30 seconds typical, 120s timeout). These go far beyond the annotations and are critical for an agent to set expectations and avoid surprises.

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 structured with clear headers and front-loads the core purpose in the first sentence. Each subsequent section (Behavioral Transparency, Usage Guidelines) adds distinct, non-redundant information. No sentence is wasted, and the length is justified by the tool's complexity (network call, billing, auth, multiple usage scenarios).

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 are documented elsewhere. The description covers execution model, side effects, authentication, latency, and usage exclusions. For a network-calling tool with billing implications, this is complete. An agent has everything needed to decide whether to call it, prepare credentials, and interpret the result.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description does not add any parameter-specific meaning beyond what the schema already provides. For example, max_results, search_query, and include_details are each fully described in the input schema. The description's mention of include_details in the latency context is contextual, not parameter semantics, so a 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 ('Search'), a specific resource (Florida Division of Corporations Sunbiz business registry), and lists the returned fields (entity name, document number, status, entity type). It clearly distinguishes this from sibling tools by naming the exact state and registry. The purpose is unambiguous and immediately actionable.

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 an explicit 'When to use' and 'When NOT to use' section, naming specific alternatives (florida_officer_search, us_business_entity_search, alabama_business_search) and the exact conditions under which each should be chosen. This gives an agent complete routing guidance with no inference required.

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

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

The description discloses synchronous network execution, the specific Apify Actor, billing and dataset creation side effects, the APIFY_TOKEN requirement, typical latency, and the 120-second timeout. This goes well beyond the readOnly/destructive annotations and gives the agent the operational context needed to call the tool safely. The billed run/dataset is a platform artifact rather than a mutation of the searched registry, so it does not contradict readOnlyHint.

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 one clear sentence, followed by well-labeled Behavioral Transparency and Usage Guidelines sections. Every bullet adds distinct value with no repetition or filler.

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

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

Given the tool's moderate complexity, the description covers authentication, cost, latency, output shape, parameter trade-offs, and sibling alternatives. An output schema exists, so the description does not need to repeat return-value details.

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 describes all three parameters well (100% coverage), so the baseline is 3. The description adds extra operational meaning beyond the schema by explaining that max_results controls billed records and that include_details incurs an extra page load per matched company, which helps agents reason about cost and latency.

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 exact action ('Search the Florida Sunbiz registry by an officer, director, or registered-agent name') and the concrete result ('every Florida company tied to that person, with entity name and document number'). This clearly distinguishes it from sibling company-name search tools.

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

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

It provides explicit 'When to use' and 'When NOT to use' guidance, and names specific alternatives: 'florida_new_filings_search' for company-name lookups and 'us_business_entity_search' for multi-state searches. An agent is fully routed to the correct 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?

Beyond the annotations, the description discloses execution as a synchronous network call, the billed Apify Actor run/dataset side effect, a required APIFY_TOKEN environment variable, and latency/timeout limits. These details add real behavioral context without contradicting the read-only and non-destructive hints.

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

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

The description is well-structured with clear headers and front-loaded purpose, then usage, side effects, auth, and limits. Every sentence earns its place; there is no filler or redundant restatement.

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

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

Given that an output schema exists, the description does not need to document return values. It covers search scope, filters, side effects, authentication, latency, and exclusions, making it fully sufficient 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 input schema already describes all five parameters with meaningful details and coverage is 100%, so the description does not need to repeat them. The description's mention of search dimensions maps to the schema but adds no parameter-level syntax or constraints beyond it.

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 France's official company register (SIRENE/INSEE)' and enumerates search filters and exported fields. This clearly distinguishes the tool from US-focused sibling tools like us_business_entity_search and epa_facility_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 includes explicit 'When to use' and 'When NOT to use' sections with named alternatives for each excluded use case. An agent can reliably route between this tool and its siblings without inferring anything.

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?

Discloses execution mechanism (synchronous Apify Actor call), side effects (billed run and dataset creation), authentication requirements (APIFY_TOKEN), and latency limits (15-40s typical, 120s timeout). This adds substantial context beyond the annotations and clarifies the true cost/operational profile of the 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 organized into clear, front-loaded sections: purpose, behavioral transparency, and usage guidelines. Every sentence provides useful operational or routing information without fluff or redundancy.

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

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

For a 3-parameter search tool with a rich output schema and strong annotations, the description covers authentication, side effects, latency, and alternatives. Nothing needed for correct selection or invocation 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 documentation covers all three parameters with 100% coverage, including defaults, constraints, and examples. The tool description itself adds no parameter-level detail, so the schema already carries the burden; 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 ('Search') and names the exact resource ('active employment vacancies, hiring employers, estimated compensation bands, and corporate ratings from Glassdoor'). It clearly distinguishes itself from sibling tools like linkedin_jobs_search by anchoring the source as Glassdoor.

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

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

Provides explicit when-to-use guidance ('researching active job openings, hiring trends...'), explicit when-NOT-to-use guidance ('local commercial lead generation...'), and names concrete alternatives (google_maps_search, sec_edgar_filings, usaspending_contracts). This is exemplary routing behavior.

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, but the description adds critical behavioral context: it runs via an Apify Actor, incurs billing, requires APIFY_TOKEN, and has documented latency and timeout (120s). It also explains the side effect of creating a billed Actor run and dataset, which is beyond what annotations provide. This is rich and valuable disclosure.

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

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

The description is structured into clear sections (purpose, behavioral transparency, usage guidelines) and front-loads the core purpose. Although it is longer than a typical description, every sentence earns its place—no filler or redundancy. The organization makes it easy for an agent 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 tool's complexity (7 parameters, a network call, billing implications, and output details), the description is comprehensive: it explains execution, side effects, prerequisites, latency, and usage boundaries. It also describes the return record fields even though an output schema exists, further aiding the agent in understanding expected results.

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

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

Schema description coverage is 100%, so every parameter is already documented with clear explanations (e.g., search_mode, status, include_relationships). The description adds no additional parameter-specific meaning beyond what the schema already provides. The baseline of 3 applies, and the description does not elevate it further.

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

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

The description states a specific verb ('Search') and resource ('the official GLEIF register'), and explicitly distinguishes it from siblings by naming alternatives in the usage guidelines. It clearly conveys what the tool does and how it differs from related tools.

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

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

The description includes an explicit 'When to use' and 'When NOT to use' section, naming concrete alternatives (sec_edgar_filings, us_business_entity_search, french_company_search) and conditions that select them. This leaves no ambiguity about 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?

Beyond annotations, the description has a 'Behavioral Transparency' section detailing execution method (synchronous network call via Apify Actor), side effects (billed run and dataset creation), authentication (APIFY_TOKEN), and latency limits. This is rich, non-redundant disclosure that exceeds the annotation hints.

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 structured into clear sections (Behavioral Transparency, Usage Guidelines) and front-loaded with the core purpose. Every sentence delivers information; no fluff 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?

With an output schema present and annotations covering safety, the description supplies all necessary operational details: execution, side effects, auth, latency, and clear usage guidance. Nothing an agent needs to decide or call the tool 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%, so baseline is 3. The description adds value by explaining that expansion modes cause additional requests and that max_results caps output, providing behavioral context for those parameters beyond their schema definitions.

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: 'Generate localized Google Autocomplete keyword suggestions from one or many seed phrases.' It also details supported features (alphabet/question expansion, ranking, deduplication) and later names a sibling alternative (google_news_search), making the purpose unmistakable.

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?

A dedicated 'Usage Guidelines' section explicitly states when to use (SEO research, question discovery, content planning) and when NOT to use (not as verified volume/CPC data). It also names the alternative tool 'google_news_search' for news coverage, satisfying the when/alternative requirement clearly.

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 goes well beyond the annotations: it discloses that execution is a synchronous cloud network call via a specific Apify Actor, that it creates a billed Actor run and dataset on the user's Apify account, that APIFY_TOKEN is required, and that latency is typically 15-45 seconds with a 120-second timeout. This is rich behavioral context that annotations alone do not 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 well-structured with clear labeled sections (Behavioral Transparency, Usage Guidelines) and front-loads the core purpose. It is longer than the minimum, but every section earns its place by providing operational and routing details. The only minor deduction is that the 'When NOT to use' list could be slightly tighter, but it is not bloated.

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 3 parameters, 100% schema coverage, an output schema, and annotations declaring readOnly/openWorld/destructive hints, the description is complete. It covers purpose, usage boundaries, side effects, auth, latency, and alternatives. There is no meaningful gap an agent would need to fill by guessing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the search_query format with concrete examples ('HVAC contractors in Phoenix, AZ') and clarifying the relationship between location and search_query ('Omit if already included in search_query'). It doesn't add much beyond the schema, but the examples and the dedup guidance justify a 4.

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 ('Extract') and enumerates the exact resource types: verified commercial business listings, postal addresses, phone numbers, review ratings, and canonical websites from Google Maps. It clearly distinguishes this tool from the sibling list by naming the domain (local business/B2B leads) and even names alternatives for adjacent domains.

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 has an explicit 'When to use' and 'When NOT to use' section, and it names four sibling tools as alternatives for excluded use cases (glassdoor_jobs_search, sec_edgar_filings, usaspending_contracts, airbnb_listings_search). This is exactly the kind of routing guidance an agent needs.

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 execution details (synchronous network call via Apify Actor), side effects (billed Actor run and dataset creation), authentication (APIFY_TOKEN), and latency limits (5-20 seconds, capped by max_results). Annotations already indicate readOnlyHint=true and destructiveHint=false, and the description adds context beyond those, such as the billing implication and execution environment, without contradicting them.

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

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

The description is well-structured with a clear purpose statement followed by dedicated sections for behavioral transparency and usage guidelines. Each sentence contributes unique information, and the most critical details (what it does, when to use it) are front-loaded. No filler or redundancy.

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

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

Given that an output schema exists, the description need not detail return types, but it covers all other essential context: execution model, side effects, authentication, latency, limits, and usage boundaries. An agent has everything needed to decide when to call this tool and what to expect, making it fully complete for its complexity.

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

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

Schema coverage is 100% so the baseline is 3, but the description adds value beyond the schema by noting that output is capped by max_results and by describing the nature of returned data. It doesn't repeat the per-parameter descriptions, but it provides context about the tool's behavior that helps an agent understand the parameters' practical impact.

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

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

The description clearly states a specific verb ('search') and resource ('Google News'), enumerates the target entities (companies, people, products, etc.), and lists what it returns (headlines, publishers, timestamps, links, snippets). This distinguishes it from the many sibling search tools, which focus on other domains.

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 an explicit 'When to use' section listing use cases (company-news monitoring, brand mentions, market intelligence, current-event research, source discovery) and a 'When NOT to use' section excluding full article text, historical archives, and fact checking. It also names two alternatives (sec_edgar_filings for official filings and europe_pmc_paper_search for biomedical literature), giving an agent clear routing guidance.

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

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

The description discloses execution model, auth requirements, latency, and side effects, but it openly states it 'creates a billed Actor run and dataset on your Apify account', which contradicts the annotation readOnlyHint=true. Per rubric this is an annotation contradiction, so the behavioral transparency score is grounded to 1.

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

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

The description is well-structured with clear section headers, front-loaded purpose, and clearly separated behavioral and usage sections. Every sentence adds information 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?

Combined with the output schema and full parameter descriptions, the description covers execution, billing side effects, authentication requirements, rate-limits, timeout, latency, and alternatives. There are no important operational or selection details missing, aside from the annotation inconsistency.

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 input schema already documents all five parameters, including constraints and defaults. The description adds no meaningful parameter-specific detail beyond the schema, which fits the baseline 3 for full schema 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?

Describes the tool's specific verb and resource: extracting public Google Play reviews with an explicit field list and app-level metadata. It clearly differentiates itself from the sibling tools, none of which target app-store review data.

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

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

Gives explicit 'When to use' guidance, explicit 'When NOT to use' exclusions, and names specific alternatives like linkedin_jobs_search and youtube_video_search. The tool is easy for an agent to route correctly.

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 readOnly/openWorld/non-destructive, so the bar is lower, but the description adds valuable context: network execution via Apify Actor, a billed run/dataset side effect, APIFY_TOKEN requirement, and latency impact of include_details. This is rich behavioral disclosure that is consistent 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?

The definition is well organized with labeled sections and a front-loaded purpose sentence. There is minor redundancy between the 'When NOT to use' and 'Named alternatives' bullets, which repeat the same alternative tools nearly verbatim, but overall the structure is clear and efficient.

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

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

Combined with the rich input schema, annotations, and output schema, the description covers execution model, authentication, side effects, latency, usage boundaries, and the types of data returned. There is no critical missing context for an agent to correctly select and invoke 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?

Schema description coverage is 100%, so the schema already documents all parameters and the baseline is 3. The description mostly restates these fields, though it does add a useful note that include_details adds one detail request per result. It does not meaningfully extend parameter semantics beyond the schema, but no compensation is needed.

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: 'Search official US federal funding opportunities from Grants.gov' and enumerates the searchable fields (keyword, agency, status, opportunity number, Assistance Listing). This clearly distinguishes it from siblings like usaspending_contracts and ted_eu_tender_search.

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

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

It explicitly states when to use the tool ('grant prospecting, research-funding discovery and federal opportunity monitoring'), when not to use it ('awarded federal contracts' and 'European procurement'), and names specific alternatives. This gives an agent direct routing guidance between similar search tools.

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

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

The description goes well beyond the annotations by disclosing that execution is a synchronous network call via a specific Apify Actor, that it creates a billed Actor run and dataset on the user's Apify account, that it requires the APIFY_TOKEN environment variable, and that typical latency is 15-40 seconds with a 120-second timeout. This is exactly the kind of behavioral context (side effects, auth, latency) that annotations alone do not 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 well-structured with clear sections for behavioral transparency and usage guidelines. It front-loads the core purpose in the first sentence, then uses labeled sections for additional context. Every sentence earns its place, and the formatting makes it easy for an agent 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?

The description is complete for a tool of this complexity. It covers purpose, execution model, side effects, authentication, latency, usage boundaries, and named alternatives. The output schema exists, so the description doesn't need to explain return values in detail. The only minor gap is that it doesn't mention pagination, but the max_results parameter and output schema cover the practical 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?

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds some context by mentioning the return fields and the 'without logging in' constraint, but it does not add significant meaning beyond the schema's parameter descriptions. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Search'), a specific resource ('public LinkedIn job postings'), and the key constraints ('by keyword and location without logging in'). It also lists the exact return fields (role title, hiring company, location, posting date, job URL), which clearly distinguishes it from sibling tools like glassdoor_jobs_search and people-search tools.

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

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

The description explicitly provides 'When to use' and 'When NOT to use' sections, including named alternatives like 'glassdoor_jobs_search' for Glassdoor listings and 'google_play_reviews_search'/'youtube_video_search' for non-hiring data. This gives an agent clear routing logic without needing to inspect sibling schemas.

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 execution model, side effects (billed Actor run and dataset creation), authentication requirement, latency range, and output cap. This is substantially more behavioral context than readOnlyHint and destructiveHint alone provide, and nothing contradicts 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 well-organized into sections with bullet lists and front-loads the core purpose before behavioral and usage details. Every section carries meaningful information; there is no filler or repetition of schema 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 output schema, full input schema, and rich annotations, the description still supplies additional essentials: authentication, runtime side effects, latency, result cap, and alternatives. This is complete enough for an agent to decide whether to call the tool and what to expect.

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 covers all 5 parameters with detailed descriptions, so the schema baseline is high. The description adds a high-level grouping of how parameters combine ('by year, make and model or by NHTSA campaign number') but does not materially improve the parameter semantics beyond what the schema already states.

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

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

The description opens with a specific verb and resource: 'Search official US vehicle-safety recalls' and names the two main query paths: make/model/year or NHTSA campaign number. It also lists concrete return contents, which makes the tool's purpose immediately distinguishable from sibling search tools.

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

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

Dedicated usage guidelines explicitly say when to use the tool, when not to use it, and name two alternatives: openfda_search for FDA recalls and sec_edgar_filings for company filings. This gives an agent clear routing criteria rather than 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?

Beyond the readOnly/destructive annotations, the description discloses a billed Actor run, required APIFY_TOKEN environment variable, typical 10-40 second latency, exact-match behavior vs fuzzy screening, and the side effect of creating a run/dataset on the user's Apify account. This is far richer than the annotations alone and fully informs the agent of real-world consequences.

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

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

The description is well-structured with clear sections for behavioral transparency and usage guidelines. The core purpose is front-loaded, and every sentence provides actionable information with no filler. The length is justified by the tool's complexity and side-effect profile.

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 execution model, side effects, authentication, latency, result semantics, and explicit alternatives. An output schema exists, and annotations cover safety hints, so nothing critical is missing for an agent to decide when and how to invoke 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?

Schema coverage is 100% and each parameter already has a meaningful description, so the baseline is 3. The tool description restates some parameter concepts (name, alias, program, country, entity type) but does not add new semantic detail beyond what the schema already provides.

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

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

The description names a specific resource ('official US Treasury OFAC SDN and consolidated non-SDN data'), a precise verb ('search'), and the key query dimensions (primary name, alias, program, country, entity type). It also states what is returned, which clearly separates it from sibling search tools without needing to inspect 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 explicitly states when to use the tool (research, list reconciliation, name discovery) and when not to use it, including named alternatives like sec_edgar_filings, gleif_lei_search, and us_business_entity_search. This is exactly the guidance an agent needs to route correctly.

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: synchronous cloud execution via a named Apify Actor, a billed run/dataset side effect on the user's account (important nuance given readOnlyHint=true), the APIFY_TOKEN authentication requirement, and concrete latency bounds (10-30s typical, 120s cap). These details materially change call decisions and are not inferable from readOnlyHint/openWorldHint alone.

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

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

The description is front-loaded with a crisp two-sentence purpose statement, then organized into labeled sections (Behavioral Transparency, Usage Guidelines) with four and three tersely worded bullets respectively. Every sentence earns its place — the billing caveat, auth requirement, latency bounds, and alternative routing are all decision-relevant with zero 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 100% parameter schema coverage, a rich enum, an output schema covering return values, and annotations covering the safety profile, the description fills every remaining gap: execution model, side effects/billing, auth, latency, and sibling routing. Nothing an agent needs to invoke this 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%, so the baseline is 3; the schema itself already documents the query syntax with a field-targeting example, the dataset enum, max_results bounds, and the include_details cost model. The description's dataset-domain list loosely maps to the dataset enum but adds no new parameter-level semantics beyond what the schema 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 uses a specific verb ('Search') plus a precise resource (official openFDA datasets) and enumerates the covered domains: drug labels, drug approvals, adverse events (FAERS), and drug/device/food recalls. It also distinguishes itself from siblings by naming what it is not (clinical trials, environmental, campaign finance, corporate registry), so an agent can tell it apart before opening an alternate schema.

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

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

A dedicated Usage Guidelines section gives explicit when-to-use conditions (safety surveillance, approval history, adverse-event monitoring, recall tracking), explicit when-NOT-to-use exclusions, and named alternatives for each excluded domain (clinical_trials_search, epa_facility_search, fec_campaign_finance_search, french_company_search). This is textbook routing guidance; nothing is left to inference.

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

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

The Behavioral Transparency section discloses execution model (synchronous network call via a named Apify Actor), side effects (billed Actor run and dataset creation on the user's Apify account), authentication requirements (APIFY_TOKEN), and latency limits (10-30 sec typical, 120 sec timeout). This adds significant context beyond the annotations, which only state readOnly/destructive hints, and it does not contradict them.

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

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

The description is organized into clear labeled sections (purpose, Behavioral Transparency, Usage Guidelines) with bullet points. Every sentence carries operational or routing value; there is no filler or redundant elaboration. It is longer than minimal but justified by the tool's billing, auth, and alternative-routing complexities.

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 paid, network-backed search tool with three parameters, the description covers execution, billing side effects, authentication, latency, disambiguation from siblings, and output behavior (via existing output schema). Nothing an agent needs to decide whether to call and how to invoke it is missing.

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

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

Schema description coverage is 100%, so all three parameters are already well-documented in the input schema. The description adds no new parameter-level semantics beyond the schema—its mention of optional endorsement/insurance/complaint details merely echoes the include_details schema description. Baseline 3 is appropriate because the schema carries the load.

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 ('Search'), a precise resource ('official Oregon Construction Contractors Board licence records'), and a scope ('by contractor or business name'). It explicitly differentiates from sibling tools in the Usage Guidelines by naming 'us_contractor_license_search', 'california_contractor_license_search', and 'us_business_entity_search', so an agent can disambiguate 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 contains a dedicated Usage Guidelines section with explicit 'When to use', 'When NOT to use', and 'Named alternatives'. It lists positive use cases (vetting, verification, lead generation), exclusions (California-only, general registrations, legal determinations), and the exact alternative tools to pick instead, leaving no ambiguity about when this tool 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 discloses that execution is a synchronous network call via an Apify Actor, that it creates a billed Actor run and dataset, that APIFY_TOKEN is required, and that latency is typically 10-30 seconds with a 120-second timeout. This adds substantial context beyond the annotations, which only indicate readOnly/openWorld/non-destructive behavior. No contradiction with annotations exists.

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

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

The description is well-structured with clear sections for behavior and usage. It front-loads the core purpose, then provides operational details and routing guidance without redundant filler. Every section earns its place for a tool with side effects and authentication requirements.

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 what it does, when to use it, when not to use it, named alternatives, authentication, side effects, latency, and limits. The presence of an output schema means return-value documentation is not required in the description. Nothing essential for correct invocation 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?

The input schema already provides 100% coverage with descriptions for all three parameters, including enum meanings and defaults. The tool description adds no additional parameter-level semantics beyond restating form types, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Retrieve') and clearly identifies the resource: official SEC EDGAR regulatory filings, listing specific form types (10-K, 10-Q, 8-K). This makes the tool's function unambiguous and distinguishes it from the many entity-search siblings in the tool list.

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 an explicit 'When to use' section with concrete use cases and a 'When NOT to use' section with exclusions. It also names specific alternative tools ('usaspending_contracts', 'google_maps_search', 'glassdoor_jobs_search'), leaving no ambiguity about routing.

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

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

Beyond the annotations (readOnlyHint=true, destructiveHint=false), the description discloses the synchronous network execution via a specific Apify Actor, the side effect of creating a billed Actor run/dataset, the APIFY_TOKEN authentication requirement, and expected latency. This is rich, non-obvious behavioral context that annotations alone would not convey.

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-organized into clear sections with bullet-pointed behavioral and usage guidance. Every sentence carries useful information, and the core purpose is front-loaded before the supplementary 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?

Given the presence of an output schema, the description need not explain return values, and it still covers execution, side effects, authentication, latency, limits, and usage boundaries. This is more than sufficient 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?

Input schema coverage is 100%, with each parameter already documented. The description adds no per-parameter semantic detail beyond what the schema provides, though it does mention the company input can be a ticker or CIK. At high schema coverage, this meets the baseline but does not exceed it.

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

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

The description begins with a specific verb ('Export') and resource ('structured insider buys, sales, grants, exercises and derivative transactions from official SEC Form 4 and 4/A XML'), immediately distinguishing this from generic EDGAR or financial-data tools. It also names explicit alternatives in the Usage Guidelines, so an agent can differentiate it from siblings like sec_edgar_filings and fec_campaign_finance_search 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 provides explicit 'When to use' and 'When NOT to use' guidance, including named alternative tools ('sec_edgar_filings' for 10-K/10-Q/8-K, 'fec_campaign_finance_search' for campaign finance). This leaves no ambiguity about 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?

The description goes well beyond the annotations by disclosing that execution is a synchronous cloud network call, that it creates a billed Actor run and dataset, that APIFY_TOKEN is required, that latency is typically 5-20s capped at 120s, and that detection is signature-based and therefore cannot prove absence of JavaScript-rendered technology. This is exactly the kind of contextual behavioral transparency that annotations alone do not 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 core purpose is front-loaded in the first sentence, and the Behavioral Transparency and Usage Guidelines sections are well organized. It is slightly longer than strictly necessary, with some redundancy between the 'When NOT to use' list and the 'Named alternatives' section, but every major section earns its place given the tool's complexity.

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

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

For a tool with this complexity, the description covers execution model, authentication, side effects, latency caps, limitations, use cases, exclusions, and named alternatives. An output schema exists, so detailed return-value documentation is not required here; nothing essential is missing for an agent to select and 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?

Schema description coverage is 100%, so the input schema already documents urls, max_results, and include_details well, including defaults, ranges, and behavioral effects such as extra requests for include_details. The description does not add significant parameter-level meaning beyond that, so the baseline of 3 is appropriate.

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

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

The description states a specific action ('Scan a batch of public websites and detect...') and a concrete resource with rich detail: CMS, ecommerce platform, payment gateway, CDN, analytics, hosting, plus 15 other categories from 75 signatures. It clearly differentiates this from the sibling business/job/map search tools by emphasizing website technology detection.

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 lists when to use the tool for competitive tech research and B2B prospecting, and when NOT to use it, naming concrete alternatives like us_business_entity_search, gleif_lei_search, linkedin_jobs_search, glassdoor_jobs_search, google_play_reviews_search, and google_maps_search. This gives an agent strong routing guidance beyond any schema 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?

Beyond annotations, the description discloses execution model (synchronous cloud Actor), side effects (billed Actor run and dataset), authentication requirement (APIFY_TOKEN), and latency limits (10-45 seconds, max_results cap). This meaningfully augments the annotations without contradicting them.

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

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

The description is well-structured with focused sections: a one-sentence summary, a behavioral transparency block, and a usage-guideline block. Every sentence provides actionable information, and key facts are front-loaded.

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

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

For a complex 9-parameter tool, the description covers when to use it, when not to use it, authentication, side effects, latency, limits, and output content. Combined with the full schema and output schema, nothing essential for correct invocation 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%, so the schema already documents every parameter in detail. The description does not clarify additional meaning beyond the schema, but because baseline 3 is appropriate when the schema fully covers parameter semantics, it neither adds nor detracts.

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 — 'Search official Tenders Electronic Daily notices' — and enumerates the distinct search dimensions (keywords, contracting authority, country, CPV code, publication date. It also states what is returned, making the tool's purpose unmistakable even among 30 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 Usage Guidelines section explicitly provides explicit when-to-use scenarios and explicit exclusion cases, naming two sibling tools (grants_gov_opportunity_search and usaspending_contracts) for US grants and awarded contracts. This is the highest level of guidance an agent could receive.

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?

Even though annotations include readOnlyHint and destructiveHint, the description adds substantial behavioral context: synchronous cloud execution via a named Apify Actor, billing side effects and dataset creation, APIFY_TOKEN authentication requirement, and latency/timeout expectations. This goes well beyond what annotations provide and directly informs invocation decisions.

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 uses clear headings and bullet-style scannable sections. Every sentence contributes meaningful operational or selection information, and the core purpose is front-loaded before behavioral and usage 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 network-backed tool with billing, authentication, and latency characteristics, the description covers all essential operational context. The output schema exists, so return-value details are not required in the description, and the usage and side-effect sections fully equip an agent to decide and execute 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 has 100% description coverage, with each parameter already documenting its purpose, default, and constraints. The tool description itself adds no additional parameter-level detail, but none is needed 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 opens with a specific verb and resource ('Extract real-time live broadcasting streams, viewer counts, channel metadata, and game categories from Twitch'), and differentiates itself from unrelated siblings by explicitly naming alternatives. The title also reinforces the tool's live-streaming focus, leaving no ambiguity about what the 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?

The description contains a dedicated 'Usage Guidelines' section with both 'When to use' and 'When NOT to use' conditions, and provides named alternatives (glassdoor_jobs_search, google_maps_search, airbnb_listings_search). This gives an agent clear routing criteria and explicitly excludes VOD archives, YouTube channels, and job boards.

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

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

Annotations already declare readOnlyHint and destructiveHint, but the description adds valuable context: synchronous execution via Apify Actor, billing side effects (billed run and dataset), authentication requirement (APIFY_TOKEN), and latency limits. This goes beyond annotations and helps agents anticipate costs and runtime.

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

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

The description is well-structured with distinct sections for purpose, behavior, and usage. Every bullet adds information and is directly relevant. No filler or redundancy exists; the length is justified by the tool's operational complexity.

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

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

With an output schema present, the description need not detail return values. It covers execution environment, side effects, authentication, latency, and usage boundaries. For a network-backed tool with two parameters, 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?

The schema covers 100% of parameters with clear descriptions (recipient_name with examples, max_results with bounds and default). The description adds no additional semantic detail about the parameters themselves, so it meets the baseline but does not exceed it.

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

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

The description states a specific verb ('Search') and a clear resource ('federal procurement contracts, defense department awards, and prime agency obligations') from the official USAspending database. It distinguishes itself from siblings by explicitly naming alternatives like sec_edgar_filings and google_maps_search.

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

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

It provides explicit when-to-use guidance (government contracting intelligence, prime vendor tracking) and when-not-to-use scenarios (commercial retail, SEC filings, vacation pricing). It also names specific alternative tools for each excluded use case, leaving no 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?

Annotations already indicate read-only/non-destructive, and the description adds execution model (Apify Actor), billing side effects, APIFY_TOKEN requirement, and latency/timeout bounds – all beyond what annotations provide. No contradictions.

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

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

Well front-loaded with purpose first, then organized sections. However, the 'When NOT to use' and 'Named alternatives' bullets repeat the same alternatives, which is slightly redundant; still, every other sentence earns its place.

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

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

Given the output schema exists and annotations cover safety, the description covers execution, cost, auth, limits, and alternative routing – an agent has everything needed to invoke correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds operational color (e.g., include_details slows the run) but these details are also present in the schema's parameter descriptions. It does not materially expand per-parameter 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 opens with a specific verb ('Search'), identifies the resource ('public Secretary of State business registries'), names the exact states covered, and explains the return shape ('normalized, source-tagged record per state match'). It clearly differentiates from siblings by naming alternatives later.

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

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

Explicit 'When to use' and 'When NOT to use' sections with named alternatives include single-state tools, officer/person searches, and contractor-license searches, leaving no ambiguity about routing. This exceeds typical 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 includes a dedicated Behavioral Transparency section detailing execution (network call, Apify Actor), side effects (billed run, dataset creation), authentication (APIFY_TOKEN), latency/limits (5 addresses per batch, 60s timeout, 10-60s typical), and output behavior (one row per address). This significantly enriches the annotations (readOnlyHint, destructiveHint) by explaining billing, timeout, and output volume without 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?

The description is well-structured with clear sections (purpose, behavioral transparency, usage guidelines). Every sentence serves a purpose: it starts with the core value proposition, then addresses operational details and routing. It is long but not verbose, with no filler or redundant statements.

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 (network call, billing, enums, latency), the description covers all essential aspects: what it does, when to use it, side effects, authentication, limits, and output behavior. The presence of an output schema means return format details are handled structurally, so the description is complete for an agent to invoke correctly.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters with clear descriptions, including the enums and their meanings. The description reiterates key points about max_results and output volume, but adds no new information beyond what the schema provides. Per the rubric, a baseline of 3 is appropriate when the schema fully covers parameter semantics.

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 ('geocode'), resource ('US street addresses'), and the exact output ('full Census Bureau geography... FIPS, GEOIDs, etc.'). It explicitly distinguishes from 'just a pin' and lists the specific geography attributes, making the tool's purpose unmistakable and clearly separate from any sibling.

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