Trove

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

The description discloses key behaviors: default free model, optional paid Anthropic probing, per-model return format, and user pays directly for Anthropic. Annotations already declare readOnlyHint, idempotentHint, and non-destructive; the description adds cost and model selection details beyond the annotations.

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

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

The description is two sentences plus a usage note, front-loading the purpose and then detailing options. Every sentence adds value without unnecessary 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?

Despite no output schema, the description explains the return format (per-model score, confidence, signals, raw_response + combined view) and covers all parameters with usage context. It also lists concrete use cases, making it complete for a 4-param tool with high schema coverage.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining 'entity' with examples, listing supported models, clarifying that '_apiKey' is only needed for Anthropic, and describing 'context' as disambiguation aid. This goes beyond the schema descriptions.

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 it probes LLMs and scores visibility (0-100) per model, with a specific verb ('probe') and resource. It distinguishes from siblings like 'scan_competitor_ai_presence' by focusing on multi-model scoring and brand/product visibility.

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

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

The description explicitly lists use cases (AI-marketing audits, pre-launch brand checks, competitive monitoring) and explains when to use the Anthropic model (BYO key). It does not explicitly state when not to use this tool or mention alternatives, but the 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?

Beyond the read-only and idempotent annotations, the description discloses substantial behavior: routing across thousands of sources, argument filling, stable citation URIs, fast single call, and tier compatibility. It also hints at limitations by contrasting with ask_pipeworx_grounded's hallucination resistance, though it does not explicitly state failure modes or rate limits.

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

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

The description is long but information-dense and front-loaded with the most critical guidance. Each sentence adds distinct context, from use-case prioritization to alternatives and example queries, though it could be tightened without losing key details.

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

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

For a broad, high-level tool with no output schema, the description provides comprehensive context: supported domains, route selection, examples, and sibling escalation paths. It does not detail output format beyond 'structured answer with citations,' but given the schema covers input and examples, overall completeness is strong.

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

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

Schema coverage is 100% and each parameter alias is described, so the baseline is 3. The description reinforces that the question is natural language but adds little beyond the schema, which already explains aliases and the required 'question' property. Examples in the schema provide illustrative parameter values.

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 explicitly states the tool routes questions to the right one of 5,529 tools across 1,455 verified sources and returns a structured answer with citations. It clearly identifies the resource and action, and distinguishes it from web search and sibling tools like ask_pipeworx_grounded and deep_research.

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

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

The description gives explicit when-to-use guidance ('PREFER OVER WEB SEARCH', 'START HERE for most questions') and when-not-to-use, naming alternatives for grounded single answers and broad multi-part research. It also clarifies edge cases like breaking news and provides concrete example queries.

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

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

The description discloses the beta nature, candidate routing improvements, the current inactive state, and that results are compared against the stable router. It also clarifies fallback behavior ('this IS a full working router'). These are valuable behavioral details beyond the annotations (readOnly, openWorld, idempotent) and do not contradict them.

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

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

The description is front-loaded with 'Beta version of ask_pipeworx' and uses four concise sentences covering identity, current state, usage, and fallback. Each sentence adds necessary context without redundancy.

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

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

Given the tool's experimental nature and lack of output schema, the description covers the relationship to the stable router, current behavior, usage guidance, and fallback. It provides sufficient context for an agent to understand and invoke the tool correctly.

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

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

The schema has 100% coverage, documenting the required 'question' parameter and all aliases. The description only repeats that it accepts the same arguments as ask_pipeworx without adding new parameter semantics. 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 this is a beta version of ask_pipeworx, an identical universal router, and highlights its experimental edge. This distinguishes it from siblings like ask_pipeworx and ask_pipeworx_grounded by focusing on the beta status and candidate routing improvements.

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

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

It explicitly says 'Use it exactly like ask_pipeworx when you want the newest routing,' providing a clear conditional usage. It also explains that it currently matches ask_pipeworx exactly. However, it does not explicitly state when not to use it or name a stable alternative, though the contrast is 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?

The description adds significant behavioral context beyond the annotations: return structure, explicit refusal reasons, evidence extraction, and the cost of an extra LLM call. It complements the readOnly/openWorld/idempotent hints without contradiction.

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

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

The description is concise yet information-dense, structured logically from mechanism to return format to usage guidance. Every sentence earns its place, including the cost trade-off and refusal taxonomy.

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 no output schema, the description explains return values, refusal reasons, and when to use the tool. It covers routing, execution, and failure modes, making it fully self-contained for a complex 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% with 6 parameters that are all aliases for 'question'. The description mentions natural language input but doesn't add meaning beyond what the schema already provides, so 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 this is a hallucination-resistant answer mode that extracts answers using only tool results, returning evidence and refusals. It explicitly distinguishes itself from the sibling ask_pipeworx by emphasizing groundedness and high-stakes use, making the purpose unmistakable.

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

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

Provides explicit usage context: use when answers will be quoted/cited/acted on and facts must not be invented, and prefer ask_pipeworx for casual lookups. This directly guides when to choose this tool over the alternative.

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

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

Description goes far beyond annotations: details fan-out, response shapes, resolver contract, parent event extraction, news fallback handling, safety short-circuits for low-confidence and closed markets, wide spread warnings, and cancellation rule parsing. Annotations already declare readOnly, idempotent, openWorld, non-destructive; description adds substantial behavioral context with no contradictions.

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

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

Very long but well-structured with labeled sections. Every sentence adds information, but some redundancy (e.g., repeating status values). For a complex tool, length is justified, but could be more concise without losing clarity.

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?

Covers response shapes, market match confidence, parent events, news fields, safety, closed markets, wide spreads, and cancellation rules. Given no output schema, the description carries the full burden and does so thoroughly, leaving no obvious gaps for an agent to misinterpret.

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%. Description adds meaning for all three parameters: explains market input formats, depth effect (quick vs thorough fan-out), and include_raw effect (summarized vs full payloads). This adds value beyond the schema's enum descriptions.

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 it researches Polymarket bets by pulling Pipeworx data, specifying three input formats and what it returns (evidence packet + market-model comparison). It distinguishes from sibling tools like polymarket_arbitrage and polymarket_edges by focusing on a single bet with data fan-out.

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

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

Explicitly states use cases: 'should I bet on X', 'what does the data say about Y', 'is there edge in Z'. Provides guidance on inspecting market_match_confidence before trusting analysis. Does not explicitly list when not to use or alternative tools, but the context of siblings implies differentiation.

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 declare readOnlyHint, idempotentHint, openWorldHint, destructiveHint. Description adds details: sourced from SEC EDGAR/XBRL for companies, FAERS/FDA for drugs, handles off-calendar fiscal years, sorted by primary metric, returns citation URIs.

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?

Single-paragraph description is dense but effective; front-loads purpose with trigger phrases. Could be slightly more structured but no fluff.

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

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

No output schema, but description explains return format (paired data + citation URIs) and ordering. Covers all necessary context given complexity and rich annotations.

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 covers 100% of parameters. Description adds meaning: explains type-specific data (company vs drug), and clarifies values format (tickers/CIKs for company, names for drug).

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

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

Description clearly states it performs side-by-side comparison of 2-5 companies or drugs, with specific trigger phrases. Distinguishes from sibling tools like entity_profile which handles single entities.

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 advises ALWAYS PREFER this over sequential single-pack lookups when comparing entities, giving clear when-to-use guidance.

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

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

Annotations supply readOnlyHint, openWorldHint, idempotentHint. The description adds substantial context beyond that: account/payment requirements, decomposition into facets, parallel routing to 5,529 tools, the findings packet structure, gaps[] for unanswered facets, never-invented assurance, depth-specific behaviors, contradictions[] scan, semantic excerpting, and expected latency. No contradiction exists.

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

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

The description is long but extremely dense with actionable information. Every sentence adds value (account requirements, alternatives, output format, edge cases). It could benefit from bullet points or clearer paragraph separation for scannability, but it earns its length for a tool of this complexity.

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

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

Given no output schema, the description thoroughly explains what the caller receives (findings packet, citations, gaps, contradictions). It also covers edge cases (breaking news leads to empty gaps), performance expectations (15-90s), and prerequisites (sign-in). It is complete enough for an agent to select and invoke the tool confidently.

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 already covers both parameters 100%, so baseline is 3. The description adds meaningful usage semantics: the question parameter can be broad/multi-part ('decomposition is the point'), and depth:'thorough' requires a paid plan. This goes slightly beyond what the schema's enum description states.

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

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

The description opens with a specific verb+resource: 'Grounded multi-source research across Pipeworx's 1455 STRUCTURED data sources... in ONE call.' It clearly distinguishes itself from open-web search and from sibling ask_pipeworx, and states it is 'NOT open-web 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 explicitly states when to use the tool: 'Best for broad/multi-part questions over structured data.' It also names alternatives and exclusions: 'For a single lookup use ask_pipeworx,' and 'For BREAKING or colloquial CURRENT-NEWS... prefer ask_pipeworx.' This goes beyond implied usage and lists both use and non-use cases.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable behavioral context beyond annotations: it returns top-N results with full input schemas and curated examples, and each result is ready to call directly without a second lookup. No contradiction with annotations.

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

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

The description is concise—a single paragraph with no wasted words. It front-loads the core purpose, then lists use cases, return format, and usage timing. Every sentence adds value.

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

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

Given the tool's complexity (discovery with multiple parameters and rich return), the description is complete: it explains the type of input (natural language), the output format (top-N tools with schemas), and the call strategy (use first). No output schema exists, but the description adequately covers what the agent needs to know.

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% (6 parameters fully described). The description does not add significant new parameter-level detail beyond the schema, but the schema itself clearly documents the query aliases and limit. According to guidelines, baseline is 3 when coverage is high, and the description does not detract.

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

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

The description starts with a clear verb-object pair ('Find tools by describing the data or task') and lists numerous specific domains (SEC filings, FDA drugs, etc.), making the tool's purpose immediately obvious. It also distinguishes itself from sibling tools by being a discovery tool rather than a specific query or analysis 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?

Explicit guidance is given: 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This tells the agent exactly when to use this tool versus alternatives. The description also implies that for a single known task, a more specific sibling tool should be used.

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

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

Annotations already indicate read-only, idempotent, open-world. Description adds rich detail: fans out across SEC, XBRL, USPTO, news, GLEIF; returns specific fields; notes patent soft-fail due to API sunset. No contradiction.

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

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

Single paragraph, but every sentence earns its place. Could be slightly more structured (e.g., bullet points), but front-loaded with examples and purpose. Minor loss for density.

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

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

Despite no output schema, description thoroughly enumerates all return fields (CIK, filings with URIs, fundamentals sorted, patents, news, LEI). Covers constraints and fallback behavior. Complete for the tool's complexity.

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

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

Schema coverage is 100%, but description reinforces and adds context: 'Pass ticker "AAPL" or zero-padded CIK "0000320193"' and clarifies that type only supports company currently. Adds value 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?

Description clearly states it returns a 'full cross-source profile of a US public company in ONE parallel call' and distinguishes from sibling chaining tools. Examples like 'tell me about X' make the purpose immediately obvious.

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 explicit when (user asks for holistic view) and when-not (if only have name, use resolve_entity first). It also specifies to prefer this over chaining single-pack lookups.

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 provide destructiveHint=true and idempotentHint=true. The description reinforces the destructive nature and adds usage context (clearing sensitive data), adding value beyond annotations.

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

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

Two concise sentences with front-loaded purpose, zero wasted words. Every sentence adds value.

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

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

Given a simple tool with one parameter, no output schema, and good annotations, the description adequately covers purpose, usage, and pairing. It lacks mention of behavior on missing key but is complete enough for typical use.

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

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

Schema coverage is 100% for the single parameter 'key', with a clear description. The tool description adds no additional parameter information beyond what the schema provides, so baseline score of 3 is appropriate.

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

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

The description 'Delete a previously stored memory by key' uses a specific verb (delete) and resource (memory by key), clearly distinguishing the tool from siblings like 'remember' and 'recall'.

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

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

Explicitly states when to use: 'when context is stale, the task is done, or you want to clear sensitive data' and directs pairing with 'remember' and 'recall' as alternatives.

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

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

Annotations already indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds internal behavior details: fetches the page, extracts title/description/key links, emits standard llms.txt format. This is consistent and provides useful context beyond annotations.

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

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

Two concise sentences plus a bullet list. The first sentence states the core purpose, the second explains the process, and the bullet list provides use cases. No superfluous content.

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

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

Given the tool's complexity, full parameter coverage in schema, and thorough annotations (readOnly, idempotent), the description sufficiently explains the output format (standard llms.txt markdown) and action flow. No output schema 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% with both parameters well-documented (url and max_links with types and descriptions). The description does not add additional parameter details, so 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 specifies the verb 'generate', the resource 'llms.txt file', and the scope 'for any URL'. It distinguishes itself from sibling tools like 'scan_competitor_ai_presence' by focusing on file generation rather than auditing or analysis.

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

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

The description explicitly enumerates three use cases: getting a client's site indexed, drafting for own project, and auditing competitor crawling. This provides clear context but does not state when not to use it or name specific alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds useful behavioral context by listing return fields and the optional parameter 'include_inactive', going beyond the annotations.

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

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

Two concise sentences: first defines purpose and return, second gives usage 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?

The tool is simple (one optional boolean, no output schema). The description fully covers purpose, return fields, usage, and parameter, making it complete for agent 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% for the sole parameter. The description does not add meaning beyond what the schema provides for 'include_inactive', so 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 verb 'list', the resource 'subscriptions', and scope 'caller's active'. It also enumerates returned fields, distinguishing it from sibling tools like 'subscribe' and 'unsubscribe'.

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

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

The description explicitly says when to use the tool: 'review what you're monitoring before adding more or to find an id to cancel'. It does not exclude alternatives but provides clear 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?

Even though annotations are all false (no useful hints), the description discloses rich behavioral context: rate-limited to 5 per identifier per day, free and doesn't count against quota, returns a claim_token that can be used later to read resolution status, and team reads digests daily. It also warns against pasting end-user prompts, which is a practical behavioral constraint not captured in annotations.

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

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

Though longer than a one-liner, every sentence serves a purpose: purpose, when-to-use, scope exclusion, claim-token mechanism, roadmap impact, rate limit, and quota exemption. The description is front-loaded with the core purpose and avoids redundancy, making it appropriately sized for the behavioral complexity it conveys.

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 must convey return behavior, and it does: 'Filing without an account returns a claim_token' and 'pass it back later... to read whether it was fixed and what changed.' It also covers rate limits, alternatives, and structured context (tools/packs), leaving the agent fully equipped to use the tool correctly without needing to infer anything.

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

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

The input schema already provides 100% coverage with detailed descriptions for every parameter, so the baseline is 3. The description adds value beyond the schema by giving a concrete example of claim_token usage ('pass it back later as pipeworx_feedback({claim_token:"pwfb_…"})') and by framing the type values within real use-case narrative, which helps an agent choose correctly. This extra guidance justifies a 4 rather than a 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 opens with a clear verb+resource ('Tell the Pipeworx team something is broken, missing, or needs to exist') and then enumerates concrete categories (bug, feature/data_gap, praise). This distinguishes it from all sibling research, search, and subscription tools, making the tool's purpose unmistakable.

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

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

Usage conditions are explicitly stated: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog... or when something worked surprisingly well (praise).' It also provides a clear exclusion for non-Pipeworx MCP servers and directs users to file with that server instead, which is exactly the kind of when-to-use vs. when-not-to-use guidance needed.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds behavioral context: data derivation from CF analytics-engine, no PII, and caching (5min-1h). This goes beyond annotations, though it omits details on rate limits or error handling.

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

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

The description is concise with three sentences plus a bullet list of use cases. Information is front-loaded with the main action, and every sentence adds value without redundancy.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers purpose, data source, privacy, caching, and use cases. It does not detail the return format, which might be inferred, but otherwise is complete for an AI agent's needs.

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 one enum parameter 'window' and its description. The description adds semantic value by explaining how different windows serve different purposes (hot right now vs. steady-state demand), enhancing 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 returns 'top tools, top packs, and total call volume' over a specified window. It uses specific verbs and resources, and distinguishes itself from siblings by focusing on trending usage data rather than general search or discovery.

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

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

The description provides three explicit use cases (discovering hot data sources, confirming canonical tools, aligning use case with trends). It implies when to use but does not explicitly state when not to use or provide alternatives, though the sibling list offers 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?

Annotations declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description builds on these with detailed behavioral context: monotonicity checks, partition checks, semantic anchor, placeholder filter, fill check against live CLOB depth, and guidance on when not to trade. No contradiction with annotations.

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

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

The description is well-structured with clear sections for each mode and additional checks, but it is somewhat verbose. Could be slightly tightened without losing 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?

Despite no output schema, the description thoroughly explains the response fields (opportunities[], partition_check, fill_check) and covers edge cases like placeholder filtering and Jaccard similarity. It is complete for a complex arbitrage detection 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% (both parameters documented). The description adds significant value beyond the schema: it explains the purpose and behavior of each parameter (event vs topic modes), provides examples, and describes the algorithms triggered by each.

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 and resource: 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' It distinguishes the tool from siblings like polymarket_edges and polymarket_fill_risk by focusing on arbitrage detection and explains three distinct modes (no args, event, topic) with specific use cases.

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

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

The description explicitly states when to use each mode: 'Call with NO args for a trending_scan', 'event (recommended for a specific market)', 'topic (for cross-event scanning).' It also provides examples of slugs and seed questions, and directs users to polymarket_fill_risk for custom sizing.

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 declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false, and the description adds beyond: cache behavior (cached 1h at KV level), diagnostics for empty segments, and a warning about Fed bets being unreliable without paid data. No contradictions with annotations.

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

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

The description is thorough but verbose (over 300 words), mixing core purpose, model details, knobs, and output structure. While every sentence adds value, the density may overwhelm agents. It is well-structured with segments but lacks brevity.

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, the description thoroughly explains the response structure (by_segment, fed_candidates, _diagnostics), key fields (edge_pp_net, kelly_fraction), and caching behavior. It covers all essential aspects for correct invocation and interpretation of 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?

The input schema has 100% coverage with descriptions, but the tool description adds real-world context for critical parameters like slippage_pp (Polymarket zero fees but bid/ask depth of 20-50bp) and min_partition_leg_kelly (explains why min_kelly doesn't filter partition arbs). This adds significant value beyond the schema.

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

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

The description clearly states the tool's purpose: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It further elaborates on the five model families and three response segments, making the purpose very specific and distinguishing it from sibling tools like polymarket_arbitrage.

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

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

The description explicitly positions the tool for 'what should I bet on today' and details how knobs like min_liquidity and max_spread_pp filter out non-tradeable edges. While it lacks explicit when-not-to-use guidance, it provides enough context for appropriate use.

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

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

Annotations already declare safety (readOnly, idempotent, non-destructive). The description adds important behavioral details: 60-day snapshot TTL, daily close computation, and response structure (tracked, expired, snapshot_dates). No contradictions.

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

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

The description is thorough but somewhat verbose. It is front-loaded with the core purpose and uses clear structure, but some details (e.g., full response field explanations) could be condensed without losing meaning.

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

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

Given two parameters, full schema coverage, no output schema, and rich annotations, the description provides complete context: response fields, limitations (TTL, daily closes), and parameter behavior. The agent can select and invoke this tool accurately.

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 covers both parameters with descriptions. The description adds value by specifying defaults (14 days, '1wk') and constraints (clamp 2-30, available window families), and explains the 'window' concept as a snapshot family.

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: persistence and decay telemetry for polymarket edges. It answers a specific question ('how long has this edge existed and is it shrinking?') and distinguishes itself from siblings like polymarket_edges by focusing on time-series analysis.

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 strong usage context, including an example distinguishing fresh vs. old edges and parameter defaults. It lacks explicit when-not-to-use or alternative tool mentions, but the context from sibling tools and the detailed explanation compensate.

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

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

The description adds substantial behavioral context beyond annotations: it explains walking the order book ladder, specific return fields (top_of_book, vwap_fill_price, slippage_pp, etc.), basket mode details (thin_legs, forced_directional_risk), and critical risks like converting arb into directional positions. No contradiction with annotations.

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

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

The description is well-structured with sections for single-market and basket modes, front-loaded with purpose. While long, every sentence serves a purpose; slight redundancy in some phrases prevents a perfect score.

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

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

Given the tool's complexity and lack of output schema, the description provides a comprehensive list of return fields for both modes, covers edge cases (thin legs, forced directional risk), and explains critical caveats. It is fully adequate for the agent to understand the tool's 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%, so baseline is 3. The description adds meaning beyond schema by explaining side default for basket (auto based on partition sum), how size_usd is interpreted (settlement notional for baskets), and usage details for each parameter, justifying a score above baseline.

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 as a 'Realizable-vs-theoretical edge check against live CLOB order-book depth' and distinguishes between single-market and basket modes, differentiating it from sibling tools like polymarket_arbitrage and polymarket_edges.

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 specifies when to use: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' Also warns against partial fills and unhedged directional positions, providing clear context for usage.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds essential behavioral details: compatibility_warning triggers, temporal alignment flag, skipped_cross counters, and the realistic caution that pre-mapped ≠ tradeable. No contradictions.

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

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

The description is lengthy but well-structured and front-loaded. Each sentence serves a purpose (modes, response, safety fields). Minor redundancy ('pre-mapped ≠ tradeable' repeated from earlier warning) but overall efficient for the complexity.

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

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

Given the complexity (3 optional params, no output schema), the description covers all important aspects: modes, response structure, safety/compatibility fields, and limitations. It is complete and self-contained.

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 descriptions for each parameter. The description enriches this by listing the topic enum values, explaining that explicit tickers override the topic side, and providing example tickers. Adds significant clarity 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?

The description clearly states it computes cross-venue spreads and distinguishes itself by explaining the two modes (topic shortcuts vs explicit tickers) and what the response contains. It is specific about the resource and action.

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

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

The description explains when to use each mode and warns that most pre-mapped topics return compatibility_warning, indicating when not to rely on spreads. It does not explicitly compare to sibling tools, but usage 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?

Annotations already declare readOnlyHint and destructiveHint. The description adds behavioral details: listing all keys when omitted, scoping to identifier, and pairing. No contradiction.

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

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

Three concise sentences with no wasted words. Front-loaded with action, then usage, then extra context. Efficient.

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

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

Given the simple tool with one optional parameter and good annotations, the description is fully adequate. It explains core function, usage, scoping, and relations to siblings.

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 has 100% coverage for the one parameter. The description repeats the omission behavior but adds no new semantic details 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 a saved value via remember or lists all keys, using specific verbs and resources. It distinguishes from siblings like remember and forget by mentioning the pairing.

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

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

The description provides clear usage context: looking up prior context without re-deriving. It mentions scoping and pairing with remember/forget, but does not explicitly state when not to use 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?

The description explains that setting mark_read=true flags events as read, which is a side effect (state modification). However, the annotations declare readOnlyHint=true, indicating no state changes. This contradiction undermines transparency. The description adds some behavioral context (e.g., return fields, polling suitability) but the annotation conflict is severe.

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

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

The description is concise: five sentences, each adding essential information. It front-loads the purpose and progressively details parameters and behavior. No wasted words or redundancy.

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

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

Given the tool has 5 optional parameters, no output schema, and annotations, the description covers return fields, filtering, and polling. However, the annotation contradiction creates incompleteness: the agent cannot reliably infer whether the tool mutates state. This gap reduces 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?

Schema coverage is 100%, so baseline is 3. The description adds examples (e.g., 'sec_8k' for type) and explains the effect of mark_read and unread_only, which goes beyond the schema descriptions. This provides moderate added 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?

The description clearly states the tool 'pull fired events from your subscription feed' with a specific verb and resource. It specifies the return fields (source, citation_uri, raw payload) and filtering options. Although siblings are not explicitly differentiated, the purpose is unambiguous and distinct from sibling tools like 'list_subscriptions' or 'recall'.

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 'polls work fine' and provides an alternative REST endpoint for scripts and dashboards. It implies usage patterns through parameter descriptions (e.g., mark_read for read tracking). However, it does not explicitly contrast with sibling tools or state when not to use this tool.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds significant behavioral context: fan-out to multiple data sources (SEC, GDELT, GNews, USPTO), fallback logic, and the patent API sunset in May 2025 causing soft-fails. This goes well beyond what annotations provide.

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

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

The description is relatively long (three sentences) but every sentence adds value: first sentence provides usage examples, second details data sources and fallbacks, third explains return format and alternative tool. It is front-loaded with example queries, making it efficient despite length.

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

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

Despite lacking an output schema, the description clearly explains the return structure: changes[] grouped by source, total_changes count, and pipeworx:// citation URIs. This covers all necessary context for a complex multi-source tool, making it complete for agent decision-making.

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 the description enriches parameter semantics significantly: it explains that 'since' accepts ISO dates or relative shorthand (with examples like '30d'), clarifies that 'value' can be a ticker or zero-padded CIK, and notes that 'type' currently only supports 'company'. This adds meaning beyond the schema.

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

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

The description clearly states the tool provides a change feed for a company, returning filings, news, and patents. It explicitly distinguishes itself from the sibling tool 'entity_profile' which returns static profiles, ensuring the agent knows when to use this 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 explicit use cases ('What's new with X', 'latest on Y') and directs the agent to use 'entity_profile' for static profile requirements. It also details fallback mechanisms (GDELT→GNews) and the soft-fail for patents, giving clear guidance on tool behavior.

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

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

Discloses scoping by identifier, persistence for authenticated users, and 24-hour retention for anonymous sessions. This goes beyond annotations (idempotentHint=true, destructiveHint=false) and adds valuable behavioral context.

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

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

Description is four sentences, well-structured with purpose first, then usage guidance, then behavioral details. No redundancy or unnecessary 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?

Covers purpose, usage, persistence, scoping, and retrieval (via recall). No output schema exists, but description adequately explains the storage action and its effects. No 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 provides 100% coverage with descriptions for both parameters. Description adds example keys and values, but this is marginal given the schema already explains purpose. 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?

Description uses specific verb 'save' and clarifies that data is reused across conversations/sessions. It lists concrete examples (resolved ticker, target address, etc.) and distinguishes from sibling tools recall and forget.

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 explicitly states when to use: 'when you discover something worth carrying forward'. It suggests pairing with recall and forget, but does not explicitly list when not to use it versus 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?

The description goes far beyond the annotations by disclosing specific behaviors: every identifier is labeled with its source, unresolved identifiers are explicitly reported under 'unresolved' rather than omitted, and LEI/FIGI enrichment degrades gracefully if external sources are unavailable. It also mentions cascading through multiple internal lookup endpoints. These details add significant transparency beyond the readOnlyHint and idempotentHint annotations.

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

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

The description is well-structured and front-loaded with user intent examples, immediately making the purpose clear. Although longer than a typical description, every sentence carries meaningful information about what the tool does, its use cases, and edge cases. The SUPPORTED TYPES section is organized, and the degradation note adds important context without redundancy.

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

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

Given the tool's complexity (two entity types, multiple identifiers, external dependencies), the description is highly complete. It explains what each type returns, how unresolved identifiers are handled, and how failures degrade gracefully. Since there is no output schema, the description fully covers return values and error behavior, making it sufficiently complete for an AI agent to use 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?

Although the schema already describes both parameters, the description enriches the semantics substantially. For the 'type' parameter, it explains what each enum value returns in detail (e.g., company returns CIK + ticker + LEI + FIGI, drug returns RxCUI + ingredient + brand). For 'value', it provides accepted formats and examples. This adds meaning beyond the schema's terse descriptions, which only list acceptable values.

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: resolving user-spoken names to canonical/official identifiers required by other tools. It includes specific example queries and explicitly differentiates it from other tools by saying 'Use FIRST whenever you have a name but need an ID.' The supported types (company, drug) are detailed with specific ID types, distinguishing it from siblings like entity_profile.

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

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

The description provides explicit usage guidance: 'Use FIRST whenever you have a name but need an ID.' It also explains when to choose this tool over manual lookups, noting it 'replaces 2-3 manual lookups.' While it doesn't name a specific alternative, the 'Use FIRST' directive clearly indicates when to use it, and the supported types give context for appropriate input formats.

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, idempotentHint, and destructiveHint false, so the safety profile is clear. The description adds value by explaining that the tool probes each entity with 'ai_visibility_check' and returns a ranked list, providing behavioral context beyond annotations.

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

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

The description is a single paragraph that efficiently conveys purpose, behavior, and usage context. It is front-loaded with the main action and includes an example. Slightly more structured formatting (e.g., bullet points) could improve scanability, but it is 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?

The description explains what the tool returns (ranked list with score, confidence, signal density) despite no output schema. It also clarifies that it uses 'ai_visibility_check' internally. It does not mention error handling or dependencies, but the annotations and schema provide sufficient context.

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 all parameters described in the input schema. The description does not add new parameter-level information, but it reinforces the usage pattern (e.g., first entity as subject). Baseline 3 is appropriate given the comprehensive schema.

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

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

The description uses a specific verb 'Compare' and resource 'AI visibility' across multiple entities, and distinguishes itself from sibling tools like 'ai_visibility_check' (single entity) and 'compare_entities' (generic). The example query 'does Claude know about us as well as our competitors?' clarifies the intended use case.

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

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

The description explicitly states when to use this tool ('competitive AI-marketing audits') and implies an alternative ('ai_visibility_check' for single entity checking). It does not explicitly state when not to use it, but the 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?

Annotations already provide readOnlyHint, idempotentHint, and non-destructiveHint. The description adds value by detailing the composite nature, partial failure handling (graceful degradation with sources_failed), and bundlephobia timing (5-30s first measurement). No contradictions.

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

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

The description is front-loaded with the core purpose ('Composite... check in ONE call') in the first sentence. While lengthy, every sentence provides unique information (e.g., ecosystem scope, return summary, failure behavior). Could trim minor wording but overall efficient.

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

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

With no output schema, the description fully covers return structure (summary block with fields, per-advisory detail, links, alternative versions), ecosystem scope (NPM v1), and error handling (partial failures, sources_failed). This is comprehensive for a composite scanning 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 has 100% coverage with descriptions for both `package` and `version`. The description adds concrete context: that scoped packages like '@types/node' are accepted for `package`, and `version` defaults to latest published. This improves usability beyond the schema alone.

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 it's a composite check for adding npm packages, fanning out across deps.dev and bundlephobia. The verb 'scan' and resource 'dependency' align with tool name. It distinguishes from siblings like 'scan_competitor_ai_presence' or 'search' by specifying its holistic npm package evaluation purpose.

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

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

Explicitly states when to use: when an agent asks 'is X safe/popular/small' or 'what does adding lodash cost me'. It also specifies the scope (NPM only) and directs users to 'deps.dev:version' for other ecosystems (PyPI/Maven/Cargo/Go), effectively telling when not to use this tool.

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

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

Annotations already indicate readOnly, openWorld, idempotent, and non-destructive nature. The description adds value by specifying that results include ids, titles, creators/sources, dates, and links, and hints at cross-tool workflow (pass id to work). No contradictions.

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

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

The description is a single sentence with a parenthetical, front-loading the core action and key details. Every word serves a purpose, 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 no output schema, the description adequately explains return values and a notable workflow hint. Could mention pagination or sorting, but overall complete for a search tool with 4 params and 1 required.

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 parameter descriptions. The description adds meaning by specifying what the query returns (ids, titles, etc.), which enriches understanding beyond the schema alone.

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 'Search the Trove collection by keyword' with a specific verb and resource, and differentiates from siblings like search_within and deep_research by focusing on the Trove collection. It also lists return fields.

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 finding items in Trove and hints at a workflow (pass id to work), but does not explicitly state when to use this tool vs alternatives like search_within or deep_research, nor does it provide exclusions or prerequisites.

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

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

Annotations already indicate readOnly, openWorld, idempotent, non-destructive. Description adds algorithm details (BGE-base-en, cosine, 500-char windows), 200K char cap with truncation flagging, and offset for verification.

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?

Concise with front-loaded purpose. Every sentence adds unique value (use case, pairing, algorithm, cap). 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?

Covers purpose, parameters, algorithm, cap, and pairing. Lacks explicit output format details (passages with offsets and scores) but implied. Output schema absent but not critical.

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 reiterates text max and query examples but adds no new semantic meaning 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?

The description clearly states the verb 'search within', specifies the resource as a fetched record (e.g., SEC 10-K body, article), and distinguishes from siblings like ask_pipeworx_grounded.

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

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

Explicitly states when to use: 'when the record is too big to cram into the prompt'. Pairs with a sibling tool (ask_pipeworx_grounded). No explicit when-not, but clear 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?

Beyond annotations (readOnlyHint=false, idempotentHint=true), the description adds valuable behavioral details: OAuth requirement, anonymous/BYO limitation, return of subscription id, one-time webhook secret, auto-disable after 10 failures, SMS cap of 10/day, and phone verification requirement. No contradictions with annotations.

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

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

The description is well-structured with clear sections for purpose, prerequisites, supported types, and delivery channels. It uses bullet points and examples efficiently. Every sentence adds value, and critical information (like OAuth requirement) is front-loaded.

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

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

Given the tool's complexity (3 parameters, nested objects, multiple types and delivery channels) and the absence of an output schema, the description provides comprehensive information: it states the return value, explains each type in detail, and covers all delivery channel nuances. No major gaps remain.

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

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

With 100% schema coverage, the baseline is 3. The description significantly enriches parameter understanding by providing concrete examples for each type, explaining nested objects (e.g., items codes for sec_8k, topic for polymarket_edge), and detailing delivery channel requirements, formats, and limitations well beyond the schema descriptions.

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 it creates a proactive monitoring subscription and returns the new subscription id. It specifies the verb 'subscribe' and the resource (alert stream), and implicitly distinguishes from sibling tools like list_subscriptions and unsubscribe by focusing on creation.

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

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

The description provides clear context for when to use this tool, including prerequisites (Pipeworx OAuth account) and supported subscription types with examples. However, it does not explicitly mention when not to use it or contrast it with alternatives like recent_alerts for pulling alerts.

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

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

Annotations already indicate read-only, open-world, idempotent, and non-destructive behavior. The description adds that the tool returns exact tool + argument shapes from a live catalog of thousands of tools, providing valuable behavioral context beyond what annotations convey.

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

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

The description is a single paragraph that front-loads common user prompts and packs useful information without redundancy. Slightly verbose but each sentence earns its place, and the structure is clear.

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, the description thoroughly explains the return type (category-bucketed example questions), the purpose (onboarding), and the optional parameter. Together with the rich sibling list and annotations, it provides complete context for effective use.

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

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

Schema coverage is 100% with a single optional parameter. The description goes beyond the schema by listing example values and explaining that omitting the parameter gives a full cross-category spread, enriching the semantic meaning.

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

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

The description clearly states it is the onboarding entry point for a newly connected agent, returning category-bucketed example questions. It uses specific verbs like 'return' and 'suggest question ideas', and distinguishes from siblings like ask_pipeworx (answer questions) and discover_tools (list 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?

Explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do for you' and provides guidance on when to pass the optional topic parameter. It also mentions meta-tools as alternatives, offering clear context for selection.

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

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

The description adds important behavioral details beyond annotations: ownership enforcement, deactivation vs deletion, and historical event retention. No contradiction with annotations (idempotentHint=true aligns with deactivation).

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 informative sentences with no fluff. The first sentence front-loads the action, and each subsequent sentence adds value without redundancy.

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

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

For a simple tool with one parameter and no output schema, the description covers the key behavioral aspects (ownership, deactivation, historical availability). Missing error-handling details (e.g., invalid id) are minor given the tool's straightforward nature.

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 describes `id` as a subscription uuid from subscribe. The description does not add further parameter details beyond what the schema provides, so baseline score 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?

The description uses a specific verb ('Cancel') and resource ('subscription'), clearly stating the action and scope (by id, ownership enforced). It effectively distinguishes the tool from siblings like `subscribe` and `list_subscriptions`.

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

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

The description provides clear context: only cancel your own subscriptions and the effect on historical events. While it lacks explicit comparisons to alternatives, the ownership note offers practical guidance for when to use the tool.

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

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

Annotations declare readOnlyHint, idempotentHint, and destructiveHint=false, but the description adds critical behavioral context beyond that: it warns that could_not_verify means the check did not happen and 'must not be shown as one' (i.e., as evidence), and explains unsupported as a coverage limitation. It also discloses the underlying pipeline (NL parsing → entity resolution → data lookup → comparison), which is far more than annotations provide.

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

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

The description is fairly long but every sentence serves a purpose: examples, routing, return payload, error semantics, and pipeline replacement. It is front-loaded with the most important information (what it does) before going into details. One minor redundancy: 'Replaces 4–6 sequential calls' could be omitted without losing core meaning, but it still adds value by framing efficiency.

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 carries the full burden of explaining the return value, and it does: verdict types, actual value with citation, reasoning, and error semantics. It also covers the two distinct categories of claims (financial vs. other) and how they are routed. For a tool with 2 params, multiple verdicts, and error states, this description is complete enough for an agent to select and invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions 'exact percent-delta math' and 'capped at 5' which relates to tolerance_pct, but the schema already explains tolerance_pct and its default in detail. The description adds no new parameter-level meaning beyond what the schema provides, so a 3 is appropriate.

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

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

The description opens with concrete natural-language triggers and states a specific verb+resource: 'natural-language claim verification against authoritative sources.' It clearly distinguishes from sibling tools like search or ask_pipeworx by framing the tool as a fact-checker that returns a verdict, not just information. The 'Replaces 4–6 sequential calls' line further positions its unique purpose.

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

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

Explicitly states 'Use whenever the agent needs to check whether something a user said is factually correct,' which is clear when-to-use guidance. It also explains the two routing paths (SEC EDGAR for company financials, grounded pipeline for anything else), giving the agent a decision procedure. The distinction between could_not_verify and unsupported gives important usage guardrails.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, covering behavioral safety. The description adds no new behavioral context (e.g., rate limits, authentication details, what 'full details' includes), so it provides minimal added value beyond the annotations.

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

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

The description is a single, front-loaded sentence with no redundant words. Every part serves a purpose: verb, resource, source of id. It is highly efficient.

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

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

Given the simple tool (2 params, no output schema, annotations cover safety), the description is adequate but incomplete: it does not explain what 'full details' includes or the return format. Without an output schema, more detail about the response would improve 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?

Schema description coverage is 100%: both 'id' and '_apiKey' have descriptions. The description text adds only a minor clarification ('a Trove work id from search'), which is already implied by the schema's 'id' description. Since schema does most of the work, a baseline of 3 is appropriate.

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

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

Description clearly states verb 'Fetch' (retrieve) and resource 'full details for one Trove item by id'. It specifies the id type as 'Trove work id (from search)', distinguishing it from tools like 'search' that return lists. However, it does not explicitly differentiate from other single-item retrieval tools like 'entity_profile', so a slight deduction.

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

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

No explicit guidance on when to use this tool versus alternatives. The phrase '(from search)' implies the id comes from search results, but there is no mention of when not to use it or which sibling tools serve different purposes. The agent must infer usage context from the description alone.

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