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

No annotations provided, so description must fully disclose behavioral traits. It mentions returns metadata and URLs, but does not state read-only nature, rate limits, authentication needs, error conditions, or side effects. This is a significant gap for a read operation.

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

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

Description is extremely concise: two sentences, front-loaded with purpose, and immediately followed by actionable guidance. No wasted words.

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 no output schema, description mentions returns 'metadata and URLs', but not what metadata includes. No coverage of pagination, error cases, or tool-specific features. Adequate but not thorough.

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% (all 6 parameters described in schema), so baseline is 3. The description adds no additional meaning beyond schema; no explanation of parameter purpose or usage 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?

Description clearly states 'Browse a subreddit's posts' with specific verb and resource, and distinguishes from fetch by directing to use fetch for full content. However, it does not differentiate from search_reddit sibling, leaving ambiguity about when to use browse vs 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?

Description provides partial guidance: it tells users to use fetch for reading full content, implying browse is not for that purpose. But it gives no explicit when-to-use vs siblings like search_reddit, and no prerequisites or context.

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

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

With no annotations, the description carries full burden. It mentions handling multiple file types and returning markdown, but omits details on caching, redirect handling, or rate limits. The schema adds some behavior (POST bypasses cache), but the description does not summarize this.

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

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

Three sentences, each adding critical information: core function, supported formats, and usage guidance against alternatives. No waste 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 tool with 7 parameters and no output schema, the description covers core behavior, supported formats, and use cases. Missing details like error handling or timeouts, but schema covers parameter constraints.

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. The description adds no parameter-specific meaning beyond what the schema already provides. The mention of 'handles HTML...' is about output, not parameters, and does not enhance parameter understanding.

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 fetches any URL and returns markdown content. It differentiates from sibling tools by noting 'no domain restrictions' and explicitly contrasts with the search tool for URL 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?

Provides explicit guidance to use this tool for reading web pages and directs users to the search tool for URL discovery. Does not contrast with other fetch-like siblings (e.g., get_alibaba_product), but the 'no domain restrictions' implies preference for generic 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?

No annotations provided, so description carries full burden. It lists returned data types but does not disclose read-only nature, error handling, rate limits, or authentication needs. Adequate but with gaps.

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

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

Two concise sentences with no wasted words. Front-loads the main action and key details. Every piece of information is relevant.

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 2-parameter tool with no output schema and no annotations, the description is fairly complete. It explains what the tool does, what input to provide, and what kind of information to expect. Could mention that product_id can be just a number, but it's implied.

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%, but description adds value by clarifying that product_id accepts both numeric ID and full URL. For timeout, description adds nothing beyond schema defaults and bounds. Overall helpful beyond 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?

Clearly states 'Get Alibaba.com B2B product details' and lists specific data points (tiered pricing, MOQ, lead times, supplier info, specifications). Distinguishes from sibling tools like search_alibaba and get_aliexpress_product in scope and target platform.

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 indicates when to use: when you have a numeric product ID or full URL. Does not provide when-not-to-use or name alternatives, but the context is clear for a retrieval vs. search 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?

No annotations are provided, so the description carries the full burden. It mentions the tool retrieves details including price, specs, ratings, and recent reviews, which suggests a read-only behavior. However, it does not disclose potential failure modes, authentication needs, rate limits, or whether it fetches live data from the web, leaving some behavioral aspects unclear.

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 long: the first states the purpose and output, the second states the input format. It is front-loaded with the core action and is free of unnecessary words or redundancies.

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 lists some returned fields (price, specifications, ratings, recent reviews) but does not provide a complete response structure. With no output schema, the agent must infer the full format. Additionally, it lacks details on constraints like pagination, language, or error handling, making it adequate but not comprehensive.

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 repeats the input format ('numeric product ID or full URL') that is already in the schema description for product_id. It does not add significant additional meaning 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 clearly states the tool's purpose: 'Get AliExpress product details including price, specifications, ratings, and recent reviews.' It uses a specific verb ('Get') and resource ('AliExpress product details'), and distinguishes itself from sibling tools like search_aliexpress by focusing on retrieving details for a known product rather than searching.

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 when you have a numeric product ID or full URL ('Accepts a numeric product ID or full URL'), but it does not explicitly state when to use this tool versus alternatives like search_aliexpress or get_alibaba_product. No when-not or alternative guidance is provided.

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

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

With no annotations, the description has to do the work alone, and it discloses genuinely non-obvious behavior: 'Who can apply' is surfaced first, postings past their closing date are flagged because the board still serves 2001-era listings as though live, and about a third of postings return an outbound URL instead of a record. That is the kind of context needed to interpret a result correctly. It stops short of covering failure modes (invalid ID) or any rate-limit/auth expectations.

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

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

One tight sentence, front-loaded with the core purpose before the value-add details about eligibility, stale listings, and off-site hosting. The parenthetical about 2001-era postings is slightly colorful but still carries information about stale data, so nothing is wasted.

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

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

There is no output schema, so the description carries the return-value burden, and it does describe the notable parts of the response: the eligibility line reported first plus the outbound-URL fallback. It is not an exhaustive field list, but it covers what an agent needs to decide whether this tool answers its question.

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

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

Schema description coverage is 100%, and the schema already documents job_id as a numeric poster ID from the URL with a concrete example, so the description adds essentially nothing beyond that. Baseline 3 applies when the schema does the heavy lifting and the description only restates the key format.

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

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

States a specific verb and resource: full detail for a single GC Jobs posting, keyed by the numeric poster ID from its URL. That is clearly distinct from the sibling list tools (search_gcjobs) and from job-detail tools for other boards (get_linkedin_job, get_indeed_job, get_gojobs_job) without needing to open any schema.

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

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

The usage is implied rather than stated: 'by the numeric poster ID in its URL' signals this is the detail lookup that follows a search, and the mention of postings hosted off-site hints at when the result will not contain a full record. But it never explicitly names search_gcjobs as the way to obtain an ID, nor states any when-not condition.

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

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

No annotations are provided, so the description carries the full behavioral burden. It adds useful context by warning that the competition status may say a job is filled while the posting still appears open, but it omits explicit read-only/no-side-effects confirmation and does not describe error behavior or return shape.

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 two tight sentences with the core purpose front-loaded. The second sentence adds a non-obvious data caveat without wasting words.

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 retrieval tool, the description gives enough context to select and call it correctly, especially since the schema fully documents the ID format. It could say more about what 'full detail' includes, but no output schema exists and the main operational caveat is already surfaced.

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

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

There is only one parameter and schema description coverage is 100%, so the schema already documents the Job ID with an example. The description restates that it is a numeric Job ID but adds no meaningful syntax, format, or validation 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 states a specific verb and resource: retrieves full detail for one Ontario Public Service posting by numeric Job ID. It implicitly distinguishes itself from the sibling search_gojobs tool by emphasizing a single posting looked up by ID rather than a 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 makes the usage context clear enough: use it when you have a numeric Job ID and need the full posting. However, it does not explicitly say when to use this instead of search_gojobs or other job-detail siblings, nor does it mention prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the returned fields and explains that the expiry date distinguishes a live posting from a stale index entry, but it does not state read-only safety, authentication requirements, 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?

It is two tightly written sentences with no waste, and the core purpose is front-loaded before the supporting use case. The expiry explanation earns its place by clarifying why the field matters.

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 detail tool with no output schema, the description identifies the main returned fields and the key expiry semantics. It stops short of describing error cases or the full response shape, but it is otherwise complete enough 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 coverage is 100%, and the schema already explains that job_key is an alphanumeric key from a ?jk= URL with an example. The description adds no parameter-level detail 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 and resource — 'Full detail for one Indeed posting' — and names the fields returned, including description, salary band, and expiry date. This clearly distinguishes the tool from search_indeed and from sibling get_*_job tools for other boards.

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 gives a concrete when-to-use scenario: retrieving a posting body that a UKG or PeopleSoft careers site gates behind a session. It does not explicitly name search_indeed as the prior step or state when not to use it, but the retrieval context is clear.

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

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

No annotations are provided, so the description must disclose behavioral traits. It notes that applying requires an account, but lacks information on rate limits, authentication needs, or any side effects. The tool is a read-only operation, but this is not explicitly stated.

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

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

The description is exceptionally concise with two sentences that front-load the core purpose and essential caveat. Every sentence is necessary and contributes to understanding.

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 simple input (one parameter) and no output schema, the description covers the key output fields and a practical limitation. However, it does not mention potential errors or response format, which could be useful for completeness.

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% schema description coverage with a well-described job_id parameter. The tool description adds further context by explaining how to obtain the job ID from a LinkedIn URL, which enhances understanding 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 tool retrieves full public detail for a single LinkedIn job posting, listing specific fields. It distinguishes itself from sibling search tools by being a detail fetcher, though not explicitly differentiating from get_alibaba_product or get_aliexpress_product which are similar in nature but for different platforms.

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 mentions that applying requires a LinkedIn account, which provides some context, but it does not guide on when to use this tool versus alternatives like search_linkedin_jobs. No explicit when-to-use or when-not-to-use guidelines are provided.

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

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

With no annotations, the description carries the full burden and does well: it discloses that the source is vector artwork with no PDF, that the tool reconstructs pages, and that it writes files to disk (a side effect an agent must know about). It omits where files land, whether an existing file is overwritten, and any auth or rate-limit 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?

Front-loaded with the action and resource, then the reason it exists, then format guidance and the exclusion. Slightly longer than needed because the format sentence duplicates the schema enum text, but no sentence is 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?

For a two-parameter tool with no output schema, the description covers what is produced (a PDF, per-page PNGs, or SVG sources written to disk) and why the textual route is impossible. Missing only operational specifics like output path and overwrite 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 coverage is 100% with clear enum descriptions for url and format, so the baseline is 3. The description's "one combined file" vs "one image per page" framing restates the schema's pdf/png semantics rather than adding new detail such as file naming or resolution.

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

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

States a specific verb and resource ("Download a Ubiquiti UniFi installation guide") plus the exact URL pattern it operates on. It further distinguishes itself from generic fetching and from the store/techspecs pages, so an agent can tell what this tool does and does not cover without opening the schema.

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

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

Explicitly routes the agent away for adjacent intents ("For a device's specifications or price, fetch its store or techspecs.ui.com page instead") and explains which format to pick for which output need. It does not name any sibling tool as an alternative, which keeps it short of a 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?

With no annotations, the description carries the full burden and does it well: it discloses the fallback chain, per-provider page ceilings, that DDG is silently skipped past page 10 in `all`/fallback modes, that result sources are labeled, and even a latency hazard (Brave challenge recovery up to three minutes). These are exactly the operational traits an agent needs before committing a 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?

Front-loaded with purpose in the first sentence, then dense but relevant operational detail. Slightly overpacked as a single block, and the provider/fallback information partly duplicates what the schema's `provider` description already states, but no sentence is 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?

For a 3-parameter, annotation-free, output-schema-free tool, the description covers everything material: what comes back (titles/URLs/snippets with source labels), how provider choice behaves on failure, and per-provider page limits. 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 baseline is 3; the description earns above that by adding a fact the schema cannot express — that the `page` maximum of 100 is provider-dependent (Google/Brave 1-100, DDG only 1-10 and skipped beyond 10). The `provider` and `query` semantics largely restate the enum description rather than extend 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 first sentence names a specific verb and resource ("Search the web") and states the return shape (titles, URLs, snippets), then explicitly routes to the sibling `fetch` for full pages. An agent can distinguish this general web search from the domain-specific `search_*` siblings and from `fetch` without opening any schema.

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

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

It gives explicit two-step usage (search here, then fetch), and detailed provider-selection guidance: google as default with automatic fallback to DDG then Brave, `all` to merge. It stops short of saying when NOT to use it (e.g., prefer the job/marketplace-specific search siblings for those domains), leaving that 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?

No annotations are provided, so the description bears full responsibility. It mentions the return type (supplier listings with pricing, MOQ, info) but does not disclose behavioral aspects such as rate limits, authentication needs, pagination behavior, or whether results are real-time. It is adequate but lacks depth.

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

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

The description is a single sentence that front-loads the primary action and key return info. There is no unnecessary content, and it is efficiently concise.

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

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

Given the absence of an output schema, the description covers the primary return elements (supplier listings, pricing, MOQ, supplier info). However, it omits details on pagination, result count limits, and how filters combine. The parameter schema is well-documented, but the description could be more complete for a tool with moderate complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no extra meaning beyond what the schema already provides (e.g., explanation of how min_price/max_price interact or sort options). It merely restates the purpose.

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 'Search', the resource 'Alibaba.com B2B products', and what is returned (supplier listings with tiered pricing, MOQ, and supplier info). It distinguishes from siblings like search_aliexpress (consumer) and search_marketplace (generic).

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

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

The description does not explicitly state when to use this tool versus alternatives, nor does it provide prerequisites or exclusions. The name and purpose imply B2B product search on Alibaba, but explicit guidance is absent.

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

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

No annotations are provided, so the description must disclose behavior. It mentions best-effort execution and possible anti-bot failure, which is useful. However, it omits details on rate limits, data freshness, or whether results are real-time, which are important for a scraping tool.

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

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

Two sentences: the first states purpose and return type, the second adds a behavioral caveat. No extraneous words, front-loaded with key 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?

With 6 parameters and no output schema, the description covers purpose and basic behavior but lacks details on pagination, sorting options in context, or filter usage. Schema descriptions for params help, but overall context is minimal.

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 description does not need to add parameter details. The description adds no extra meaning beyond what the schema provides, maintaining the baseline score of 3.

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

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

The description clearly states the verb 'Search' and resource 'AliExpress products', and specifies the return type (listings with prices, ratings, links). This distinguishes it from siblings like 'search_alibaba' (different platform) and 'get_aliexpress_product' (specific product).

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 for searching AliExpress and warns of potential anti-bot failure, but does not explicitly state when to use this tool over alternatives like 'get_aliexpress_product' or other search tools. No exclusions or context for when not to 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?

With no annotations, the description carries the burden well: it discloses that upstream matching is unreliable and that post-filtering is applied, which is real behavioral context an agent cannot get from the schema. It also explains the Pay field's provenance (local-law dependent, e.g. Canada). It stops short of stating result caps, deduplication across multiple queries, or whether postings include apply URLs.

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

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

Front-loaded with the verb and facets, then the caveats, then the disambiguation rule — a sensible order with no filler. It is on the long side and the paired examples are somewhat redundant with the job_category schema description, but each sentence still carries decision-relevant information.

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

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

For an 8-parameter, no-annotation, no-output-schema search tool, the description covers invocation strategy, result trustworthiness, and a distinguishing data feature. Remaining gaps are minor and mostly schema-documented (sort, limit) — only cross-query result handling and return shape are unaddressed.

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, and the description earns an increment by adding semantics the schema does not convey: that title and job_category target different fields and return disjoint sets, with worked examples of each failing case. The anyOf (at least one of title/location/job_category) is never stated in prose, which keeps it from a 5.

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

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

States a specific verb and resource ("Search amazon.jobs") plus the three facet dimensions it accepts, which immediately separates it from the sibling job boards (search_indeed, search_linkedin_jobs, search_google_jobs). The added note that pay bands are surfaced as a Pay field tells the agent what makes this source distinct.

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 explains that Amazon's native search is fuzzy and that title/location are re-applied against each posting, which tells the agent how to trust results. It goes further and states the exact selection rule between title and job_category (disjoint sets, with concrete examples) and when to run the category instead: "To survey a field rather than a job name, run the category too."

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that place names are auto-resolved to Apple location codes and that locale affects only output URLs, but it does not describe authentication, rate limits, return format, or result pagination behavior.

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

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

The description is three tight sentences with the core purpose front-loaded. Each sentence adds useful context about search scope or the location/locale behavior, with no 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?

For a five-parameter search tool with no output schema, the description covers the main ambiguity around location versus locale and explains automatic location resolution. It does not describe the shape of returned job results or pagination beyond the limit parameter, but it is largely complete for correct invocation.

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

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

Schema coverage is 100%, so the schema already documents all five parameters. The description still adds meaning beyond the schema by explaining that location drives country scope and that place names are automatically resolved, while reinforcing that locale only changes storefront links.

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: searching jobs.apple.com by title and location. Naming the Apple jobs domain clearly distinguishes this from sibling job-board search tools such as search_linkedin_jobs or search_indeed. It also clarifies the key location/locale distinction up front.

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

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

Usage is implied by the platform-specific description: use this to search Apple job postings. However, it does not explicitly say when to use this instead of other job-search siblings or state any prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden and provides meaningful behavioral context: the board ranks rather than filters, title filtering is re-applied against posting names, the number dropped is reported, and location matching returns the board's own spellings when nothing matches. It does not cover authentication, rate limits, or return format, but the ranking/filtering caveat is unusually transparent.

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

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

Four sentences, front-loaded with the core search scope, then the important ranking caveat, then the follow-up fetch instruction. No filler; every sentence carries actionable information.

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

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

For a 7-parameter search tool with no annotations and no output schema, the description covers the key behavioral caveat (ranking vs filtering), the follow-up path for full descriptions, and location quirks. It could say more about the return shape (e.g., list of postings with URLs) but adequately enables correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds genuine meaning beyond the schema by explaining that strict_title re-applies the title against each posting's own name and reports the number dropped, and that location returns the board's own spellings when nothing matches—semantics the schema alone does not convey.

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), resource (company career site hosted by Eightfold AI), and scope (Microsoft, Netflix, PayPal, or any Eightfold tenant via board URL). This clearly distinguishes it from generic job search siblings by naming the hosting platform, though it doesn't explicitly compare against the many other job-board tools.

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

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

The description gives an implied context—use this for Eightfold-hosted career sites—and a follow-up instruction to use fetch() for full descriptions. However, it does not explicitly say when to choose this over search_linkedin_jobs, search_indeed, or the other job-board siblings, nor does it state exclusions.

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

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

With no annotations, the description carries the full burden and does so well: it discloses that filters are sent as the board's own form sends them, confirmed against the page echo, that title/location/salary are re-verified, and that rows return soonest-closing first. It omits rate limits, error behavior, and what fields each row contains, keeping it short of a 5.

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

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

Front-loaded with purpose and domain, then behavior, then routing advice — a sensible order. A couple of clauses (the 'way the board's own form sends them' detail) are dense but earn their place by conveying verification behavior; overall it is tight for the amount of substance.

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

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

For an 8-parameter, zero-annotation, no-output-schema search tool this covers purpose, filtering semantics, sort order, the fetch fallback, and the crucial eligibility caveat. The main gap is that return-row shape is unspecified, which an agent may need to know when parsing 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 coverage is 100%, so baseline is 3, but the description adds meaning beyond the schema by identifying which five inputs are 'real board filters' and which three (title, location, salary) are re-checked server-side after submission. It does not elaborate on strict_title or exclude_various_locations, which live entirely in the schema.

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

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

States a specific verb and resource — searching the GC Jobs federal public service board — and pins it to the exact domain. It distinguishes itself from the many other job-search siblings by being the only route to Government of Canada postings, and explains why a plain fetch fails, so an agent can tell it apart immediately.

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 names the constraint 'Give at least one filter' (matching the schema's anyOf), and routes the agent to the sibling get_gcjobs_job with the precise condition: before relying on eligibility, since 'Who can apply' is not on the listing. It also excludes fetch by explaining the JS-shell failure mode.

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

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

With no annotations, the description carries the full behavioral burden and does well: it explains that the board has NO keyword search, that its only native text input is an exact Job ID, and that `title` is therefore matched client-side against each posting's own title. It also warns that unfiltered listings trigger "a dozen sequential postbacks," a useful performance trait. It stops short of covering return shape or pagination, hence not a 5.

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, zero waste, and the most decision-relevant fact (the board's lack of keyword search) is front-loaded right after the identity sentence. Every clause earns its place by either orienting the agent or preventing a costly invocation mistake.

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 seven params with 100% schema coverage but no annotations and no output schema, the description supplies the key behavioral context an agent needs to call it correctly. The one remaining gap is the absence of any indication of what the results look like or how `limit` interacts with the sequential-postback warning, but for a public search tool this is a minor omission rather than a blocking one.

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 real semantic value the schema lacks: it explains that `title` is matched locally against posting titles because the board has no keyword field, and it clarifies which fields (region, city, job category, career level, minimum salary) correspond to genuine board filters. The special

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

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

The description names a specific verb and resource ("Search gojobs.gov.on.ca, the Ontario Public Service (OPS) careers board") and immediately clarifies what kind of postings it returns ("Every posting is an Ontario government job"). This source identification cleanly distinguishes it from the many other job-board search siblings without needing to name each 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?

It gives a concrete invocation requirement — "Give at least one filter — an unfiltered listing is a dozen sequential postbacks" — which maps directly to the anyOf constraint and explains the cost of ignoring it. It does not explicitly compare against siblings like get_gojobs_job or the other portal search tools, so the when-to-use alternative guidance is implied rather than stated.

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

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

With no annotations, the description carries the full burden and does real work: it warns that Google's free-text matching is loose (with a concrete 38-vs-2 example), that postings are re-checked, and that two counts are reported separately. That is meaningful disclosure about result semantics and accuracy that no structured field provides; only auth, rate limits, and pagination behavior are left unstated.

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

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

Two sentences, zero filler; purpose comes first and the matching caveat second. The em-dash example is dense but earns its space by quantifying the looseness problem in a way the agent can reason about.

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?

Seven parameters, no annotations, no output schema — the description compensates by explaining the matching model and that two result counts are returned, which is the key return-shape fact an agent needs. It does not cover empty-result behavior or the relevance/date sort semantics, small gaps for a low-risk search 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%, so baseline is 3, but the description adds rationale the schema cannot: the loose-matching explanation justifies the default-on strict_title/strict_location checks and tells the agent why reported counts differ. It also reinforces the precise-location requirement the schema already documents.

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

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

States a specific verb and resource ('Search Google's own careers board') plus the two scoping dimensions (job title, location), which cleanly separates it from the many other company-specific job search siblings. An agent can immediately tell this is the Google-board variant rather than another board.

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 scope ('Google's own careers board') implies when to reach for it, but there is no explicit when-to-use/when-not or named alternative among the ~15 sibling job search tools. The agent must infer routing from the tool name and the board scope rather than being told.

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

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

No annotations exist, and the description carries the full burden well: it discloses the ~15-posting page cap, the sign-in wall on deeper offsets, that salary bands appear on most cards, and that some postings are reachable here that UKG/PeopleSoft career sites will not serve. These are exactly the operational traits an agent cannot infer from the schema.

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

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

Three tight sentences, front-loaded with what is searched, followed by result quality, the follow-up tool, and the pagination caveat. No sentence is filler and the most consequential constraint (no deep pagination) is stated plainly.

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 no output schema and no annotations, the description supplies result count, salary-band richness, and the escalation path to get_indeed_job, which is nearly everything needed. What remains unstated is the shape of returned fields and whether empty result sets or blocked offsets surface as errors versus empty lists.

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; the description earns a bump by clarifying that the effective result ceiling is one page (~15) per query, which tempers expectations for the limit parameter (max 100, default 25). It says nothing about title, location, radius_km, or the strict_* flags, leaving those entirely to the schema.

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

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

States a specific verb and named resource with geographic scope ("Search ca.indeed.com"), which immediately separates it from search_linkedin_jobs, search_jobbank and the other board-specific searchers. It also distinguishes itself from get_indeed_job by assigning that sibling the full-body reading job.

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

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

Explicitly routes the agent to get_indeed_job for full posting bodies and warns that deeper offsets hit a sign-in wall, so the correct behavior is to refine the query instead of paginating. It gives no guidance on choosing between this and the other job-board siblings when a title matches several, which is the only gap.

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

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

With no annotations, the description carries the full burden and largely meets it: it discloses a serious silent-failure mode (an unresolved location returns 64,000+ national postings as an ordinary success) and explains that results are radius-based with the radius reported. It omits auth/rate-limit behavior and return shape, which keeps it short of a 5.

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

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

Three sentences, front-loaded with what the tool is, followed by the two facts most likely to cause a wrong call (location resolution and radius semantics). No filler and no repetition of the 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 6-parameter, annotation-free search tool with no output schema, the description covers the major pitfall and the scoping model. It stops short of describing result ordering, pagination, or what fields come back, which is a modest gap given there is no output schema to rely on.

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 limit, title, location, radius_km, strict_title and strict_location in detail, including example radii. The description adds the reason location must be resolvable but otherwise restates schema-level behavior; baseline 3 applies.

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

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

Opens with a specific verb+resource ('Search jobbank.gc.ca, the federal Job Bank') and identifies the board precisely, which separates it from siblings like search_indeed, search_gcjobs, and search_linkedin_jobs. It also states a differentiating characteristic (salary published on most listings).

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?

Explains the mechanics of use — a place name is resolved to a numeric city id, and searches are radius-based around a city — which tells the agent how to supply inputs correctly. It does not explicitly name when to prefer this over search_indeed or search_gcjobs, so the routing guidance is implied rather than stated.

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

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

With no annotations, the description carries the burden and delivers the two most important facts: no authentication/account is required, and the response shape is a compact listing (title, company, location, date, URL) rather than full postings. It omits rate limits and pagination ceilings (which the schema covers for start/limit), so it is informative but not exhaustive.

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

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

Three tight sentences: what it searches, what it filters, what it returns, plus the routing hint. Filter list is front-loaded and no sentence is redundant.

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

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

For a 14-parameter list tool with no output schema, the description fills the key gap by naming the returned fields, so an agent knows what it gets back. Minor residual gaps (pagination/size expectations, result ordering) are already handled in the schema's sort, start, and limit descriptions.

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 every parameter carries its own explanation, including the non-obvious strict_location and sort caveats, so the schema does the heavy lifting. The description only restates the filter categories generically without adding syntax or interaction details, which is the baseline for fully-documented schemas.

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

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

States a specific verb and resource ('Search LinkedIn's public job board'), scopes it ('no account needed'), enumerates the filter dimensions, and names the follow-up sibling get_linkedin_job. An agent can distinguish it from search_indeed or search_workday_jobs by the LinkedIn-specific naming without opening a 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?

Clear context for when to use it and an explicit hand-off rule: 'Call get_linkedin_job(job_id) for the full description,' which tells the agent this is the discovery step, not the detail step. It does not state when to prefer the other job-board siblings, so it stops short of a full alternatives map.

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

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

With no annotations, the description bears full burden. It mentions 'grouped results' and simultaneous search, but omits details on rate limits, authentication, error handling, or result volume.

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, immediately stating the main purpose and key features. No redundant or filler 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?

Despite 8 parameters and no output schema, the description is very brief. It does not explain return format, pagination, error behavior, or how to interpret grouped 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 coverage is 100%, so the description adds minimal value beyond what schema already provides. It restates 'human-readable parameters' but doesn't elaborate on format or constraints.

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

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

The description clearly states the verb 'Search' and the specific resources (Kijiji, Craigslist, Facebook Marketplace), distinguishing it from sibling tools like search_aliexpress or search_reddit.

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 for multi-platform searches, but lacks explicit guidance on when not to use it or how it compares to alternatives like the 'fetch' tool for individual listings.

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

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

No annotations are provided, so the description bears the full burden. It usefully discloses a fallback behavior: a place name is matched against Meta's real office list, and that list is returned when nothing matches. However, it does not cover other relevant traits such as read-only nature (implied by 'search'), rate limits, authentication, or result format/pagination.

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

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

Two sentences, front-loaded with purpose and followed by a key input nuance. Every clause earns its place, and there is no extraneous text.

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

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

For a five-parameter search tool with no output schema, the description covers the core purpose and a critical location-formatting detail, but it omits useful context such as result ordering, pagination behavior, and explicit usage contrast with sibling job-search tools. It is adequate but leaves clear gaps.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the specific location-matching quirk (e.g., 'Vancouver, Canada' vs 'Vancouver, BC') and the fallback behavior when no office matches. It does not elaborate on limit, remote_only, or strict_title, but the schema already documents those fully.

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

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

The description states a specific verb, resource, and target site: 'Search metacareers.com by title and office.' This immediately distinguishes it from sibling job-search tools that target other companies (LinkedIn, Indeed, etc.). An agent can tell exactly what this tool does without opening the schema.

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

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

The description implies usage (searching Meta jobs) and provides input-format guidance for office names, but it does not explicitly state when to use this tool versus the many sibling job-board search tools. There are no exclusions or alternative recommendations, leaving the agent to infer that this is Meta-specific from the domain name.

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

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

With no annotations the description must carry the burden, and it does disclose two non-obvious traits: the return payload (full posting text, location, department, job family) and that country filtering is server-side while city matching is performed by this tool. It omits pagination/limit interplay and any rate-limit or auth expectations, which keeps it below a 5.

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 front-loaded sentences with no filler; the platform scope leads, the return shape follows, and the location quirk closes. It is dense but every sentence contributes, with the parentheticals the only minor drag.

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 6-parameter tool with a fully documented schema and no output schema, the description supplies both the return fields and the server-vs-local filtering behavior an agent would otherwise get wrong. What remains unaddressed is how limit interacts with the 200 cap and how this tool relates to the overlapping search_uber_jobs sibling.

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 every parameter including limit, title, location, and both strict_* flags is already documented, and the baseline of 3 applies. The description adds only the rationale for city filtering happening here, which explains strict_location indirectly but gives no new syntax or default information 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?

States a specific verb (search) and resource (a career site on Oracle Recruiting Cloud / Fusion), and enumerates the tenant forms it accepts, which implicitly separates it from the many other ATS-specific search_*_jobs siblings. It stops short of naming a sibling to use instead when an employer is not on ORC, so differentiation is by platform rather than by explicit routing.

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 opening clause establishes applicability precisely: any ORC tenant by careers URL or Fusion host, with Oracle and Uber called out as current examples, which tells an agent when this tool is the right pick. It offers no explicit when-not or named alternative (e.g. search_workday_jobs), leaving cross-tool routing to inference.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns listings with price, address, beds/baths, size, agent, and a realtor.ca URL, and suggests using fetch for full descriptions. However, it does not mention any rate limits, authentication needs, or potential side effects, which would elevate it to a 5.

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 long, front-loading the purpose and filter capabilities in the first sentence, and detailing return values and follow-up in the second. Every 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?

Given the complexity of 11 parameters, no output schema, and no annotations, the description is fairly complete. It covers the tool's purpose, key filters, return fields, and a clear next step (fetch). It lacks only a mention of pagination beyond the page parameter description in the schema.

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

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

Schema description coverage is 100%, so baseline is 3. The description summarizes key filters (location, price, beds, baths, property/building type, ownership) but adds little meaning beyond what the schema already provides. It does not elaborate on parameter usage nuances.

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 searches Canadian homes for sale or rent on realtor.ca with full filters. It specifies the resource (realtor.ca) and the action (search), distinguishing it from sibling tools like search_aliexpress or search_alibaba.

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

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

The description does not explicitly state when to use this tool versus alternatives. It mentions a follow-up action (call fetch for details) but provides no guidance on selecting this tool over other search tools among 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?

No annotations are provided, so the description carries the full burden. It states that the tool returns metadata and URLs, implying it is read-only, but does not disclose rate limits, authorization needs, pagination behavior (despite the 'after' parameter), or error handling. The behavioral description is minimal.

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 only two sentences, front-loaded with the primary purpose, and includes a complementary instruction to use 'fetch' for full content. Every word is necessary and there is 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 tool has 7 parameters and no output schema. The description is too brief to be complete: it omits explanation of the return structure beyond 'metadata and URLs', does not explain pagination (despite the 'after' parameter), and does not differentiate from the sibling 'browse_reddit' tool. More context is needed.

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 input schema already documents all 7 parameters. The description adds no additional meaning beyond what is in the schema (e.g., it does not explain the purpose of 'sort', 'time', or 'after'). 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 clearly states the tool searches Reddit posts and returns metadata and URLs. It distinguishes from siblings like 'browse_reddit' by indicating that this tool is for searching, not browsing, and that full content requires another tool. However, it does not explicitly differentiate from the generic 'search' tool.

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 a usage hint: use another tool ('fetch') for full content. However, it does not give explicit context on when to use this over siblings like 'browse_reddit' or 'search', nor does it mention prerequisites 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?

With no annotations, the description carries the full burden and does useful work: it discloses that the board answers anonymously (no auth needed) and that results carry the full posting text rather than snippets. It omits rate limits, pagination behavior, and whether result counts are capped beyond the limit parameter.

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 search action and scope front-loaded; the second sentence is informational rather than padding. Slightly verbose about the Oracle backend, but it earns its place by explaining why full descriptions are available.

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?

No output schema exists, so the description helpfully enumerates expected return fields (title, department, team, level, location, description). For a five-parameter read-only search this is nearly complete, with only pagination and result-ordering behavior left unstated.

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 including strict_title and strict_location are already documented in the schema. The description adds only the general notion of filtering by title and location, no extra semantics for the strictness flags, so the baseline of 3 applies.

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

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

States a specific verb (Search) and a precisely scoped resource (Uber's job board), with the qualifying dimensions (title and location) named up front. It is trivially distinguishable from the many sibling job-board tools because the company is named, and it even clarifies the underlying ATS (Oracle Recruiting), which helps separate it from search_oracle_jobs.

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 title/location framing implies when the tool applies, but there is no explicit guidance on when to prefer it over search_oracle_jobs or the other company-specific job tools, nor any stated prerequisites or exclusions. Usage is inferable rather than instructed.

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

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

With no annotations, the description carries the disclosure burden and does well: it explains that it resolves the tenant's own location facet regardless of naming and that title filtering is done client-side because Workday's searchText silently drops real matches. It omits rate limits, pagination, and return shape, which are the remaining gaps for a no-annotation tool.

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

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

Two sentences, both earning their place: the first establishes scope and inputs, the second discloses the two non-obvious implementation quirks. No filler or restatement of the 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 five-parameter search tool with no output schema and no annotations, the description covers the critical gotchas (tenant resolution, facet naming, unreliable server-side title search). It does not describe the result structure or how empty results are signaled, leaving a modest gap.

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

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

Schema coverage is 100%, so the baseline would be 3, but the description adds cross-parameter semantics the schema cannot: location is matched against the tenant's dynamically-named facet (with real values surfaced on no-match), and title is filtered client-side rather than via Workday's searchText.

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 ('Search any Workday board (*.myworkdayjobs.com) by job title and location') and enumerates concrete tenants. This clearly distinguishes it from sibling tools like search_indeed, search_google_jobs, or search_linkedin_jobs, which target other job 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?

It makes the usage condition explicit: any Workday tenant, either by known employer name or by board URL, with worked examples. It does not explicitly say when to prefer a sibling board search or what to do if the employer is not on Workday, so it stops short of full routing guidance.

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