SnoopScan

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

Annotations already cover read-only, open-world, and destructive hints. The description adds useful context by referencing a 'last fetched' state, implying the tool compares against a previous fetch. However, it does not disclose whether the tool performs a new network fetch, updates internal state, or how the diff is returned.

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

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

The description is a single clear sentence with no filler and the core purpose is front-loaded. It is concise, though it could have included parameter or usage details without becoming 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?

With an output schema present, return values need not be described, and annotations cover safety traits. Still, the description omits essential context about what 'includeDiff' controls, whether a live fetch occurs, and how the last-fetched baseline is established. An agent would likely need to inspect the output schema and infer behavior.

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

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

Schema description coverage is 0%, and the description does not explain either parameter. 'url' is only implicitly tied to 'a page,' and 'includeDiff' is left entirely to inference from its name. The description adds no explicit meaning beyond the bare parameter names.

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 ('check whether a page has changed') and a clear resource ('a page since it was last fetched'). This uniquely distinguishes it from sibling tools like crawl, extract, and scrape, which perform fetching or extraction rather than change 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?

No guidance is given about when to use this tool versus alternatives, nor any exclusions or prerequisites. The description only implies a use case (change detection) but does not explain when to prefer it over crawl, fetchMore, or scrape.

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 behavioral context beyond annotations: it reads 'the homepage and a few contact/about pages, nothing behind a login,' which specifies scope and boundaries. This is consistent with readOnlyHint=true and openWorldHint=true, and provides detail on what pages are accessed 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 a single well-structured paragraph that front-loads the core purpose, then lists outputs, then adds behavioral details, and ends with usage guidance. It avoids redundancy and is appropriately sized for the information it conveys, though it could be slightly tighter.

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

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

Given the existence of an output schema and safety annotations, the description covers the essential aspects: what it reads, what it returns, and its single-company scope. It does not mention potential failure modes or edge cases, but these are not critical given the schema and annotations. It is adequate for an agent to call correctly.

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

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

Schema description coverage is 0%, so the description must explain parameters. It mentions 'Give it a company domain' which maps to the url parameter, but it does not explain the 'contacts' boolean parameter at all. The description fails to compensate for the missing schema descriptions, leaving one parameter undocumented.

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

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

The description clearly states the tool profiles a company website and lists the specific data returned (firmographics, contact emails, social links, contact form). It distinguishes itself from directory search by stating it is 'not a directory search' and is the 'single-company half of a lead pipeline,' making it unambiguous vs. siblings like search or findLeads.

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

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

The description gives clear usage context: 'Use it to enrich one company' and 'single-company half of a lead pipeline, not a directory search.' This implies when to use it (single-company enrichment) and when not (directory search), though it does not explicitly name alternative sibling tools or conditions.

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 that the tool runs in the background, returns a job id immediately, and can take minutes while consuming significant resources. This is valuable behavioral context that annotations alone do not provide and directly affects how the agent should handle the call and set parameters.

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

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

The description is three sentences with no filler, front-loads the core action, and places the important async/resource behavior immediately after. Every sentence adds operational value, and the parameter warning is integrated naturally rather than buried.

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

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

Given the output schema exists and annotations are present, the description covers the essential async contract, result retrieval path, and resource warning. The main gap is the undocumented path-filter parameters, but the tool is still callable with just the required url and safe defaults, so the description is nearly complete.

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

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

Schema description coverage is 0%, so the description must compensate for missing parameter documentation. It only explains limit ('set limit conservatively') and implies url via 'crawling a website', but says nothing about maxDepth, includePaths, or excludePaths, leaving their meaning and usage to inference from their names and defaults.

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

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

The lead sentence 'Start crawling a website' names a specific verb and resource, and the background-job framing distinguishes it from sibling tools like crawlStatus and crawlPages. The description makes clear this tool initiates a crawl rather than inspecting or reading crawl results.

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 tells the agent to use crawlStatus for progress and crawlPages for results, giving concrete follow-up routes. It also warns that crawls take minutes and consume significant resources, advising a conservative limit, which helps the agent decide whether this heavyweight tool is appropriate.

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 known. The description adds valuable behavioral context about pagination and the risk of context overflow, which is beyond the annotations. It does not contradict the read-only hint.

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

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

Two sentences with no wasted words. The purpose is front-loaded, and the second sentence justifies the defaults. Efficient and well-structured.

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

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

The tool has an output schema, so return values are covered elsewhere. Annotations cover safety. The description explains the pagination rationale and context limits, which is sufficient for a low-complexity tool. It could mention cursor mechanics, but not critically missing.

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

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

Schema description coverage is 0%, so the description must compensate. It hints at pagination ('a few at a time') but does not explain the cursor parameter for pagination, the maxCharsPerPage limit, or how limit interacts. The parameters are simple but the description adds minimal semantic detail beyond the schema.

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

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

The description clearly states the verb (Read) and the resource (pages a crawl has collected), and distinguishes it from sibling tools like crawl (initiates) and crawlStatus (checks status). It specifies the operation and scope precisely.

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

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

The description provides contextual guidance ('Small defaults on purpose — a crawl's full output will not fit in context') that implies when to use it (reading crawl results in chunks) and why small limits are appropriate. However, it does not explicitly name alternative tools or state when not to use this tool, leaving some inference to the agent.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context beyond annotations by stating the return contains counts and cost and explicitly excluding page bodies, which prevents an agent from expecting scraped content.

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

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

Two short sentences, with the core action front-loaded and the key limitation ('never page bodies') immediately after. No filler or redundant restatement of the tool name.

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

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

For a simple one-parameter status tool with readOnly annotations and an output schema, the description covers the essential call context: what to check, what is returned, and what is not returned. It does not explain error cases or how to obtain a jobId, but these are minor given the tool's simplicity.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining the single jobId parameter, but it never mentions jobId, where it comes from, or its format. The parameter name is self-explanatory, but the description adds no semantic value 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 uses a specific verb ('Check') and resource ('progress of a crawl'), and adds a distinguishing behavioral note: it 'Returns counts and cost, never page bodies.' This clearly separates it from execution tools like crawl and crawlPages, and from content-returning tools like extract or scrape.

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

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

The phrase 'progress of a crawl' implies it is used after a crawl has been started, but the description does not explicitly say when to prefer it over siblings such as crawl, crawlPages, or leadsStatus, nor does it mention any exclusions or alternatives.

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

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

Annotations already declare readOnlyHint, openWorldHint, and destructiveHint. The description adds meaningful behavioral context: 'Nothing here fetches the page, so nothing here can be blocked.' This goes beyond the annotations and helps set expectations about reliability.

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

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

The description is compact and well-structured: core outputs first, then use cases, then behavioral caveat. Every sentence earns its place, with no filler or repetition of schema/annotation data.

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

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

The output schema and annotations cover return values and safety, and the description provides strong use-case context. However, the complete lack of parameter documentation for limit and backlinks leaves a meaningful gap for an agent deciding how to invoke the 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 0%, and the description does not explain the url format, limit, or backlinks parameter. The phrase 'who links to it' indirectly hints at backlinks, but limit is entirely undocumented, leaving the agent without enough information to tune the call.

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 concrete data points the tool returns: domain age, registrar, hosting, and backlinks. It also explicitly contrasts itself with page scraping ('off-page questions a page scrape cannot answer'), which distinguishes it from siblings like scrape and extract.

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

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

The description gives clear when-to-use scenarios: comparing competitors, judging a source, and checking whether a domain was registered recently. It implies the alternative (page scraping) but does not name a specific sibling tool or explicitly state when not to use it.

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

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

Annotations already mark the tool as read-only, open-world, and non-destructive. The description adds meaningful behavioral context: output is validated against the schema, missing fields produce errors rather than invented values, and errors should be treated as genuine absence rather than retry opportunities.

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

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

Three sentences with no filler. The core purpose is front-loaded, followed by concise validation and error-handling behavior. Every sentence earns its place.

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

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

The description covers the main extraction flow and error semantics, and the output schema reduces the need to describe return values. However, it leaves the 'prompt' parameter undocumented and does not clarify URL handling or pagination, so an agent may not fully understand all inputs.

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

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

Schema description coverage is 0%, so the description must compensate for all three parameters. It only loosely covers 'urls' and 'schema', but gives no detail about the 'prompt' parameter, its optionality, or how it affects extraction. This is partial compensation at best.

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: 'Extract structured data from one or more pages according to a JSON schema.' This clearly distinguishes it from sibling scraping/crawling tools by emphasizing schema-based structured extraction.

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

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

The description implies usage through 'according to a JSON schema' and the error-handling note, but it does not explicitly state when to prefer this tool over siblings like scrape or crawl, nor does it list exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral context beyond annotations: it explains that the page will be truncated again if still too long, and that the result is the next section of the same page. This gives agents an accurate model of the tool's iterative behavior without contradicting annotations.

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

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

The description is three short sentences and is front-loaded with the core purpose. Every sentence earns its place: the first states the action, the second explains the input, and the third describes the output behavior. There is no filler or redundant detail.

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

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

For a simple tool with two parameters and an output schema, the description covers the main action, input semantics, and behavioral nuance (re-truncation). The only gap is the undocumented 'maxChars' parameter, but given its optional nature with a default, the overall description is sufficient for an agent to correctly invoke the 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 0%, so the description must compensate. It does explain the 'token' parameter as coming from a truncation marker, which is valuable. However, it does not describe 'maxChars' at all, leaving its purpose and effect undocumented. With two parameters, one is explained and one is neglected, so the description partially compensates but is not complete.

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

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

The description states a clear verb ('Read') and a specific resource ('remainder of a page that was truncated'), and clarifies the mechanism (passing a token from a truncation marker). This distinguishes it from sibling tools like 'scrape' or 'crawl' which operate on whole pages, while 'fetchMore' is explicitly for continuing a truncated page.

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 clearly states the condition for use: when a page was truncated, pass the token from the truncation marker. It also implies it should be used to continue the same page. It does not explicitly name alternatives or state when not to use it, but the context is clear enough for an agent to make the right selection.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds useful output expectations (contact page, form, emails, social links) but does not disclose failure modes, pagination, or potential delays. This is adequate but not rich, and there is no contradiction with annotations.

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

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

The description is two short sentences with no wasted words: the action is front-loaded, followed by specific output details and a brief context note. Every sentence earns its place.

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

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

With an output schema present and only one parameter, the description provides sufficient context for standard use. It does not cover edge cases like invalid URLs or rate limits, but the simplicity and output schema reduce the need for additional detail.

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

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

Schema description coverage is 0%, so the description must compensate. It implies the 'url' parameter is the company website address, but does not explicitly state its format or constraints. Given a single obvious parameter, the omission is minor but not fully compensated.

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

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

The description states a clear verb and resource ('Find contact information for a company website') and enumerates specific outputs (contact page, form, emails, social links). It differentiates from sibling findLeads by focusing on contact details rather than broader lead discovery.

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

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

The purpose implies when to use this tool (need contact details for a URL), but there is no explicit when-to-use/when-not-to-use guidance or reference to alternative tools. The phrase 'Used by the lead pipeline' provides context but does not help an agent choose between this and 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 adds substantial behavioral detail beyond the annotations: it runs in the background for 2–5 minutes, merges duplicates, reads business websites for contact info, and is charged per lead delivered. This gives the agent realistic expectations about latency, pricing, and partial success without contradicting the provided 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 dense but well-organized, front-loading the core purpose before explaining parameters and runtime behavior. Every sentence adds useful information, though the single-paragraph format could be slightly more scannable with line breaks or bullet-like separation.

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

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

For a tool with seven parameters, async execution, and an output schema, the description covers the essential workflow: inputs, sources, contact enrichment, roles, background timing, and how to retrieve results. The only notable gaps are the semantics of limit and requireWebsite, but defaults and the output schema mitigate the risk.

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

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

Schema description coverage is 0%, so the description must compensate. It explains who, where, sources, contacts, and roles with concrete examples and behavior. However, limit and requireWebsite are not explained in the description, leaving two of seven parameters without semantic guidance beyond their names and defaults.

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

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

The description opens with a specific verb and resource: 'Find businesses by what they do and where, with how to reach each one.' It clearly distinguishes the tool from siblings like findContacts by emphasizing trade/location-based lead discovery plus contact enrichment, and from map/search by naming the aggregator sources and background execution.

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

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

The description gives clear operational context: what inputs to provide, which sources are searched by default, how to override sources, and that results are retrieved via leadsStatus. It does not explicitly name alternatives or state when not to use this tool, but the context is strong enough for an agent to infer appropriate use.

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

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

Beyond readOnlyHint and openWorldHint, the description explains the internal workflow: locate the careers page, identify the ATS, read its public job feed. It also discloses the important fallback behavior of naming the careers page when no feed exists and explicitly warns the agent not to read 'no feed' as 'not hiring'.

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

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

The description is front-loaded with the core purpose, followed by method and caveats, with no wasted operational detail. Some motivational framing ('A company hiring six engineers has budget...') is not strictly necessary, but it is brief and does not obscure the guidance.

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

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

An output schema exists, so return-value details are already covered. The description covers the input, the multi-step process, the fallback behavior, and the interpretation of negative results, making it fully sufficient for an agent to call the tool correctly.

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

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

With 0% schema description coverage, the description compensates by saying 'Give it a company domain,' which clarifies the lone required parameter is a company identifier rather than an arbitrary URL. It could be more precise about accepted URL formats, but it provides enough semantic guidance for an agent to proceed.

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 title and description both state a specific verb and resource: find a company's open jobs. The description further distinguishes it from generic crawling by explaining it reads the ATS's public job feed and returns real roles, so an agent can tell it apart from sibling tools like listPosts or listProducts.

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

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

The description gives clear context for when to use the tool: when you need to know what a company is currently recruiting for, and it tells the agent to supply a company domain. It does not explicitly name alternatives or exclusion conditions among the sibling tools, but the purpose is sufficiently contextualized.

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 readOnlyHint and destructiveHint annotations, the description discloses the polling behavior: it returns the stage while running and returns leads 25 at a time when done. It also explains pagination semantics, which is valuable behavioral context not present in the annotations.

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

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

The description is three sentences, front-loaded with the core purpose, and every sentence adds useful information. It avoids repetition and clearly structures the polling and pagination behavior.

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 read-only polling tool with an output schema, the description is complete: it explains the lifecycle, the result fields, the page size, and how to continue fetching. No critical information needed to call the tool correctly is missing.

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

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

With 0% schema description coverage, the description carries the burden of explaining parameters. It implicitly ties jobId to a Find Leads run and explicitly explains offset as the mechanism to fetch the next 25 leads. It could be more explicit that jobId is the identifier returned by findLeads, but it provides enough context.

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 ('Follow a Find Leads run, and read its leads') and a clear resource (lead-search results). It distinguishes itself from sibling tools like findLeads by clarifying it reads results after a run rather than starting one.

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 clearly indicates when to use the tool: after a Find Leads run, while it is running, and once it has finished. It gives pagination guidance with offset, though it does not explicitly name alternatives or state when not to use it.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds behavior beyond that: it explains how the tool selects API vs RSS/Atom based on the platform, what fields are returned, and directs the agent to scrape for full content. It omits pagination/rate-limit details, but for a read-only list tool this is a minor gap.

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

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

The description is three sentences with no filler. The primary action is front-loaded, followed by platform-specific details and an alternative-tool pointer. Every sentence earns its place and the structure is easy to scan.

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

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

An output schema exists, so return-value details are not needed in the description. The description covers platform behavior, returned fields, and the next step via scrape. The only meaningful gap is the undocumented limit parameter, which prevents a perfect score. Overall, an agent can use this tool correctly with minimal ambiguity.

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

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

Schema description coverage is 0% – neither url nor limit has any schema documentation. The description implies url is the site URL and mentions output fields, but it never explains limit (e.g., maximum number of posts) or the expected url format. With zero schema coverage, the description needed to carry this burden and does not.

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

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

The description states a specific verb and resource: 'List a site's posts or articles from its own API or feed.' It clearly distinguishes itself from sibling listProducts and from scrape by specifying the output fields (titles, URLs, dates) and pointing to scrape for reading one post. An agent can immediately identify what this tool does.

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

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

The description gives practical context for when to use the tool: WordPress, Substack, Squarespace, and Discourse go through APIs, while everything else uses RSS/Atom. It also explicitly names scrape as the alternative for reading a single post. It does not explicitly exclude other sibling tools, but the platform breakdown and the scrape pointer provide solid usage 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. The description adds beyond that: no key required, pagination up to 250 products per request, and the fields returned (title, price, availability, variants, URL). This is meaningful extra context, though it omits details like rate limits or error behavior.

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

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

Two sentences, purpose first, then key details. Every clause adds value and there is no fluff.

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 and annotations covering safety, the description covers the essential usage context: no key, pagination, returned fields, and when to use it. It is not exhaustive (e.g., no mention of errors or rate limits), but for a read-only list operation it is adequate.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It does not explicitly define 'url' or 'limit'. It implies 'url' is the store URL and mentions 'up to 250 products' but does not connect that to the 'limit' parameter. This is insufficient given zero 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 description states a specific verb ('list'), resource ('every product a store publishes'), and scope ('from the store's own catalogue'). It also explicitly contrasts with crawling a shop, differentiating it from sibling tools like 'crawl' or 'scrape'.

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

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

Explicitly states 'Use this instead of crawling a shop', providing a direct alternative and when to prefer it. Also notes it works for Shopify and WooCommerce without a key, which is a clear condition for use.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's addition of 'without fetching page content' reinforces the read-only nature without contradicting it. The phrase 'Fast and cheap' adds contextual behavior about performance. While it does not detail other behaviors like rate limits or result formatting, the annotations and output schema cover those gaps, so this is a solid score.

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

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

The description is two sentences with no fluff. The primary action is front-loaded ('List the URLs on a website'), followed by a concise usage hint. Every word earns its place, achieving high clarity in minimal space.

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's core purpose is clear, and an output schema exists to explain return values. However, the description omits any explanation of the 'limit' and 'search' parameters, which are non-obvious. For a tool with only three parameters, failing to document two is a notable gap that could cause misuse. The description is sufficient for basic calls but incomplete for advanced usage.

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

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

Schema description coverage is 0% – the description doesn't mention any parameters. It only says 'List the URLs on a website,' which implicitly covers the required 'url' parameter, but it fails to explain 'limit' (a default of 100) or 'search' (a nullable filter). With 0% coverage, the description had to compensate, but it doesn't, leaving two of three parameters opaque to the agent.

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: 'List the URLs on a website' and explicitly clarifies it does 'without fetching page content.' This clearly distinguishes it from siblings like 'crawl' and 'scrape' which fetch content. The title 'Map a site's URLs' aligns perfectly with the description, making the purpose unambiguous.

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

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

The description provides clear context: 'Fast and cheap. Use this to understand a site's structure before deciding what to scrape.' This tells the agent when to use the tool (as a preliminary step) and hints at the alternative (scraping). However, it does not explicitly name alternatives or state when not to use it, so it stops short of a perfect 5.

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

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

Beyond the readOnly/openWorld/destructive annotations, the description reveals that results come from public search with 'no login, no profile scraping' and exposes the critical distinction between CONFIRMED and unconfirmed employers, plus a flag for former employees. This is essential behavioral context that is not present in 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 structured and front-loaded: purpose first, then examples, parameter enumerations, and finally a safety warning. The role/seniority lists are necessary because the schema lacks enums, and every sentence adds value.

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

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

Given an output schema exists, the description covers all key calling requirements: required company, optional role/seniority, allowed values, and the meaning of CONFIRMED/former flags. It also addresses access behavior (no login, no scraping), making it complete for an agent to invoke and interpret results correctly.

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

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

Schema description coverage is 0%, so the description carries the parameter burden. It enumerates all allowed values for `role` and `seniority`, clarifies their optionality, and implies the company is required. However, it does not explain `limit` beyond the schema's default, leaving one of four parameters under-described.

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 starts with 'Find the people at a company, by what they do and how senior they are' – a specific verb, resource, and scope. It distinguishes this tool from siblings like findContacts/findLeads by emphasizing function-plus-seniority queries and public search with no login.

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

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

The description provides clear usage context through relatable examples ('Head-hunting a developer, poaching a sales team...') and explains the input pattern (company plus optional role/seniority). However, it never explicitly names sibling alternatives or states when not to use this tool, so it lacks explicit exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, making it clear this is a safe read operation. The description adds that it returns 'clean markdown', which is a useful output trait, but doesn't elaborate on rate limits, network failures, or handling of dynamic content. Given annotations cover safety, the description adds minimal but non-zero behavioral context, warranting a 3.

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 extremely concise—two sentences with zero fluff. It front-loads the primary purpose and output, then provides usage guidance. Every word earns its place. It's not under-specified because it covers the core behavior and usage.

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?

While the description clarifies the main use case and output, it fails to explain the four optional parameters that have defaults (maxAge, waitFor, maxChars, onlyMainContent). Given the output schema exists (though not detailed here), return values are covered, but the agent may not know how to fine-tune parameters like waitFor or onlyMainContent. For a tool with six parameters, the description is too thin on optional behavior, so a 3 is appropriate.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. The description does not explain any of the six parameters (url, maxAge, formats, waitFor, maxChars, onlyMainContent), leaving the agent to rely on names and defaults. However, the description clarifies the core purpose and output format, which indirectly informs that 'url' is the target and 'formats' might control output types. Yet, depth is lacking—for example, 'maxChars' and 'onlyMainContent' have no explanation. Since coverage is 0%, the description should have provided some parameter guidance; its silence is a significant gap. Score 2 would be more fitting than 5, but given the tool's simplicity and that 'url' is the only required param, 4 may be too generous. I'll adjust to 3.

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

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

States a specific verb ('Fetch') and resource ('a single web page'), explicitly names the output ('clean markdown'), and distinguishes itself from siblings by noting it's for when you have a specific URL, versus 'search' or 'map' for finding pages first. This fully differentiates from the sibling 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?

Explicitly says 'Use this when you have a specific URL and need to read what is on it. For finding pages first, use 'search' or 'map'.' This provides both a clear when-to-use condition and names the alternatives for the opposite case. 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?

The description discloses that fetching content is slower and costlier, and explains the trade-off between links/snippets vs full bodies. This is additive beyond the annotations, which only state read-only and open-world hints. It clarifies the default behavior (links/snippets) and the cost of opting into content fetching.

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

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

The description is two sentences, front-loaded with the core action, then a focused caveat on cost. Each sentence earns its place with no 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 is adequate for a simple search tool with an output schema and annotations covering safety. It lacks explicit mention of the numeric parameters, but their defaults and types are in the schema. The core behavior and the costly option are covered, so the agent can make an informed call.

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

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

The description meaningfully explains the fetchContent parameter, including its performance implications. However, it does not address limit or maxCharsPerResult, leaving the agent to rely on the schema alone. With 0% schema description coverage, the description only partially compensates for the missing 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?

States clearly that it performs web searches and returns results. The specific verb 'Search' and resource 'the web' make the action unambiguous, and the optional content fetching adds nuance. It doesn't explicitly differentiate from siblings, but the name and basic function are sufficient for selection.

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

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

Provides no guidance on when to prefer search over sibling tools. The only guidance is about the fetchContent parameter, not tool selection. No mention of alternatives or contexts where other tools would be more appropriate.

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