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

Annotations only cover readOnlyHint and openWorldHint, but the description adds the extraction mechanism (cross-encoder scoring over every passage of top pages), the output contract ([n] citations back to sources), the reliability caveat, and the billing behavior ('Costs 1 credit'). That is substantive context beyond what the structured fields provide.

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

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

Three sentences, front-loaded with the defining trait (verbatim, never generated) before mechanism, caveat, and cost. The middle pipeline sentence is dense but earns its place by explaining result quality; nothing is redundant padding.

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

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

With no output schema, the description compensates by describing the return shape (best passages plus [n] citations) and the credit cost. For a two-parameter read tool whose safety profile is covered by annotations, nothing an agent needs to select or call it is missing.

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

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

Schema description coverage is 100% and both parameters are already documented, so the baseline is 3. 'Top pages' and 'every passage of the top pages' loosely maps num_results to pages searched, but adds no syntax or semantics beyond the schema's own 'Pages searched for passages (1-10, default 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+resource: 'Answer a question with passages quoted verbatim from the web, never generated.' The 'never generated' clause distinguishes it from a generative research tool and from contextfetch_search, which the passage-scoring description implies returns pages rather than extracted quotes. An agent can pick this out from siblings 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?

'Use it for quick factual lookups; the quotes may not fully answer an open-ended question' gives a positive trigger and a soft exclusion that steers open-ended work elsewhere. It falls short of naming the alternative sibling (e.g. contextfetch_research / deep_research) explicitly, so the routing 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?

Annotations already flag a non-read-only, idempotent, open-world operation; the description goes further by disclosing that real money is spent automatically, that a saved card is required, and that a $500 monthly ceiling applies. It stops short of saying whether omitted fields are preserved or reset on a partial update, which matters for a configuration-mutating 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 tight sentences: the behavior and its trigger come first, prerequisites and the hard limit second. No filler, and the conditional logic is readable at a glance.

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 full parameter documentation, the description covers the essentials for a billing-related mutation: what happens, what it costs, what credentials are needed, and what cannot be exceeded. Only the response shape and partial-update semantics are absent, which is acceptable but not 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 coverage is 100%, so the baseline is 3; the description earns more by explaining the causal relationship between the parameters — threshold triggers the purchase of pack, bounded by monthly_max_usd. The $500 note largely restates the schema maximum.

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 set of actions (turn on, turn off, change) on a specific resource (auto-reload) and explains the mechanism: below a credit threshold the saved card repurchases a pack up to a monthly cap. This is clearly distinct from siblings like contextfetch_balance or contextfetch_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?

Gives clear prerequisites (CONTEXTFETCH_API_KEY and a card saved at checkout) and states the operating condition (credits dropping below the threshold). It does not name an alternative path for raising the cap beyond $500, but the in-tool limit is disclosed.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the bar is lower; the description still adds real context by noting the required CONTEXTFETCH_API_KEY env var, that the call is free, and that a failed payment surfaces a last auto-reload error. It does not describe the response shape, which is a minor gap given no output 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?

Two dense sentences, front-loaded with what is returned, then the auth/cost constraint and usage trigger. No filler or 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 zero-parameter read tool with no output schema, the description covers auth requirements, cost, what data is returned, and when to call it — everything an agent needs to invoke it correctly.

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

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

The tool takes zero parameters, so the baseline is 4; the description correctly does not invent parameters and instead clarifies the implicit auth dependency (CONTEXTFETCH_API_KEY).

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 (Show) and a precisely enumerated resource: remaining credits, 7-day burn rate, and auto-reload settings. This is clearly distinguishable from siblings like contextfetch_auto_reload (which would modify settings) and contextfetch_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?

Gives a concrete trigger — 'Check it before long jobs' — and signals it is free, implying no credit cost for polling. It does not explicitly name an alternative or a when-not condition, so it falls 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?

Annotations already cover the read-only/open-world profile, so the bar is lower; the description still adds billing behavior (1 credit per page returned), robots.txt compliance, and hard scope caps. Return format is disclosed as Markdown. It stops short of describing pagination or failure behavior, keeping it from 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?

Two sentences, zero waste, front-loaded with what is retrieved before the constraints and optional query behavior. Every clause carries 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 no output schema, the description still names the return form (Markdown pages) and the credit cost, while the schema carries all parameter detail. An agent has enough to invoke and predict the result.

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

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

Schema coverage is 100%, so the schema already documents all six parameters, including the depth and limit bounds. The description repeats those caps and glosses the query ranking/pruning behavior, adding only marginal meaning beyond the schema.

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

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

States a specific verb (crawl) and resource (one website from a start URL) plus the output form (pages as Markdown). An agent can distinguish this from extract_url (single page) and map (link discovery) without opening either 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?

Gives scoping conditions (same-site links only, robots.txt obeyed) and explains the query mode, which implies usage. But it never names an alternative sibling (e.g. extract_url or map) or states when NOT to crawl, leaving the agent to infer routing.

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

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

Beyond the readOnlyHint/openWorldHint annotations, it discloses credit cost per sub-query (1 credit each), server-side execution, deduping/ranking behavior, and the exact derivation logic used when sub_queries is omitted. This is substantial behavioral context the annotations cannot convey.

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

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

A single dense paragraph that front-loads the alias note and output shape before the parameter-usage guidance. Every clause carries information, though the fallback-derivation sentence is long and slightly nested.

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, the description fully specifies the return artifact (one Markdown evidence pack, numbered sources, pruned passages) plus cost and query-derivation rules. An agent has everything needed to invoke it correctly.

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

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

Schema coverage is already 100%, so the baseline is 3. The description goes beyond it by explaining how sub_queries is synthesized (query itself, + 'documentation', + 'benchmark' or 'example' with suffix-skip rules) and by tying sub-query count to credit consumption, adding real semantic value.

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

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

States precisely what the tool produces: a single Markdown evidence pack with numbered sources and query-pruned passages, built from up to 3 server-side sub-queries. It also positions itself relative to a sibling by declaring it is an alias of contextfetch_research kept for existing setups.

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

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

Gives a strong explicit recommendation ('You SHOULD pass your own sub_queries... for better coverage') and explains the fallback when omitted. It does not, however, tell the agent when to prefer this over contextfetch_research, contextfetch_search or contextfetch_answer, so the alternative-selection guidance is only partial.

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 openWorldHint=true, so safety and open-world scope are covered. The description adds useful behavior — Markdown conversion with table preservation and a filtering mode that shrinks the response — but says nothing about limits, truncation, or what happens on JS-rendered or paywalled pages.

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, with the core capability front-loaded and the optional mode explained second. Nothing could be cut without losing information.

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

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

For a two-parameter, annotated, read-only fetch tool, the description covers purpose, content types, output shape, and the optional filtering mode — enough to call it correctly. The remaining gap is operational edge cases, which matters somewhat given the open-world hint but is not required to invoke it.

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

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

Schema coverage is 100%, so both parameters are already documented in the schema. The description's explanation of `query` (returns only relevant passages instead of the whole page) is a slight reframing rather than new semantics; `url` gets only the implicit 'must be public' constraint already 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 (fetch a public web page) and names concrete content archetypes (docs, articles, GitHub files, arXiv papers) plus the output format (clean Markdown, tables preserved). It does not distinguish itself from the nearby crawl/map siblings, so an agent must still infer that this is the single-page reader.

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 second sentence establishes a clear conditional: pass `query` for relevant passages instead of the whole page, which is genuine usage guidance for that parameter. There is no explicit 'use this instead of X' routing against siblings such as contextfetch_crawl or contextfetch_search, and no stated when-not 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?

Annotations establish that this is a read-only, open-world call, so the safety profile is covered. The description adds real behavior beyond that: results exclude the source domain, and the return payload is titles, URLs and the most relevant passages rendered as Markdown. That return-shape disclosure is genuinely useful and not present in the structured fields.

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

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

A single sentence that front-loads the core action, adds intent examples in a compact parenthetical, and closes with the return format. Nothing is wasted and no backtracking is required.

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, and the description compensates by summarizing the return payload. For a two-parameter read-only lookup tool with full annotation coverage, an agent has enough to call it correctly; only pagination/truncation limits for the passage text are 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 coverage is 100% with both parameters fully documented, including the 1-25 range and default for num_results, so the schema does the heavy lifting. The description mentions the URL input implicitly but adds no format constraints or extra meaning beyond what the schema already states, making the baseline 3 correct.

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

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

States a specific verb+resource: finding pages similar to a given URL, with parenthetical examples of the intent (alternatives, related docs, competing libraries). This clearly distinguishes it from contextfetch_search and contextfetch_extract_url in spirit, though it never names a sibling explicitly, which keeps it just short of a 5.

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

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

The examples ('alternatives, related docs, competing libraries') imply when the tool is useful, and the source-domain exclusion hints at intended use. However there is no explicit comparison against the many sibling search/research tools, nor any stated preconditions (e.g. URL must be public/crawlable), so usage is only implied.

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 flag this as non-read-only, open-world, non-idempotent, and the description adds real context beyond them: the 'one per network' rate limit and the no-sign-up flow, which explains why repeat calls may not be idempotent. It stops short of describing the returned key format or failure 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 short sentences, front-loaded with what the tool returns and followed by the required post-call action; every clause carries 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 no output schema, the description does enough: it says what the key grants, that it is auto-applied this session, and how to persist it. Minor gaps remain about the response shape and what happens if a key already exists.

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?

Zero parameters, so there is nothing for the description to disambiguate; the 4 baseline applies and no parameter confusion is possible.

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

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

States a specific verb and resource (get a free ContextFetch API key) plus concrete scope (2,500 searches, one per network, no sign-up). It is clearly distinct from the search/research/crawl siblings, though it never names a sibling to route against.

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?

Implies the call is for obtaining credentials and tells the agent what to do with the result (use it this session, hand it to the user for CONTEXTFETCH_API_KEY), but never states when to call it versus checking contextfetch_balance or how to behave on repeat calls.

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 cover read-only and open-world safety, and the description adds real context beyond them: a 1-credit cost, the source precedence (robots.txt before /sitemap.xml), and page-link fallback. It stops short of describing the response shape or what happens when no sitemap exists, so 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?

Two dense sentences, zero filler: the mechanism and scope come first, the sibling routing second, the cost last. The 5,000 cap is the only mild restatement of schema.

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

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

For a 4-param read-only tool with no output schema, the description covers sourcing, same-site restriction, limit, and billing — enough to call it correctly. It leaves the response format (bare URL list?) implicit, which is a minor but real 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 description coverage is 100%, so url, limit, include_paths, and exclude_paths are already documented including ranges and regex semantics. The description only restates the limit cap and that url may be any page; it says nothing about the include/exclude filtering that the schema carries. 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?

Specific verb and resource: "List a website's URLs without fetching its pages," with the exact sources named (robots.txt sitemap, else /sitemap.xml, plus start-page links). The scope qualifier "same site only" and the limit cap make it unmistakable against page-returning siblings.

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

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

Explicitly routes the agent: "Use it to find the right pages before contextfetch_extract_url or contextfetch_crawl," naming both the alternative tools and the sequencing condition. No inference required to pick this tool over its 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?

Annotations only cover read-only and open-world, yet the description discloses a great deal more: concurrent execution, URL dedupe, cross-encoder ranking, the exact return format (numbered [n] sources with query-pruned verbatim passages, no generated text), and the billing model (1 credit per sub-query). The default sub-query derivation rules are spelled out, so the agent can predict behavior when it omits the 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?

Purpose is front-loaded in the opening clause and every sentence carries information. The parenthetical explaining default sub-query derivation is long and reads almost like spec text, but it is genuinely useful rather than filler, so it slightly dilutes an otherwise tight structure.

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, and the description fully compensates by describing the return shape (Markdown evidence pack with numbered sources and verbatim passages) and the cost model. For a 3-parameter, read-only aggregation tool, an agent has everything needed to call it correctly and to anticipate the response.

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

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

Schema coverage is 100%, so the baseline is 3; the schema already documents all three parameters including ranges and defaults. The description does add genuine meaning for sub_queries ('distinct angles', plus the fallback derivation algorithm), but says nothing about num_results_per_query beyond what the schema supplies.

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 precise verb and resource ('Research a question in one call') plus the concrete artifact returned (a Markdown evidence pack), with operational mechanics (5 concurrent searches, URL dedupe, cross-encoder ranking) that make it hard to confuse with a plain search. However, it never names or contrasts any sibling tool such as contextfetch_deep_research or contextfetch_search, leaving the differentiation implicit rather than stated.

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

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

Gives real context: 'Pass your own sub_queries (distinct angles on the question) for better coverage' tells the agent how to get the best result, and the credit cost per sub-query informs the cost/coverage trade-off. It stops short of explicit when-to-use/when-not guidance or naming the alternative tools an agent should pick instead.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description meaningfully adds that results are cross-encoder pruned and therefore token-cheaper than raw pages, which tells the agent what comes back. It does not mention rate limits, pagination, or freshness, so it is good 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?

Two tight sentences with zero filler; the core value proposition is front-loaded before the use-case list. 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?

With no output schema, the description usefully compensates by describing the return shape (title, URL, relevant passages). Combined with full schema coverage and annotations, an agent has enough to call it, though domain-filter interaction and result-count behavior are left to 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 all four parameters including the domain include/exclude lists and the 1-25 range are fully documented in the schema. The description adds no parameter syntax or format detail beyond that, so 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?

States a specific verb+resource (search the web) plus its distinctive output (LLM-ready Markdown with title, URL, pruned passages). It does not name any sibling (e.g. contextfetch_research or contextfetch_answer) to draw a boundary, so it is clear but not sibling-differentiated.

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?

"Use for current events, documentation, APIs, research and fact checking" gives concrete when-to-use contexts, which is more than implied usage. It stops short of stating when NOT to use it or which sibling supersedes it (e.g. deep_research for multi-step work), so no exclusions or alternatives are offered.

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