Rijksmuseum

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint false. The description adds valuable behavioral context: the tool is a probe, returns per-model scores, requires a BYO key for Anthropic (with direct payment), and defaults to a free model. 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?

Four sentences, front-loaded with the primary action and output. Every sentence adds unique value: purpose, default behavior, API key usage, return structure, and use cases. No wasted words.

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

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

Given the tool's complexity (4 parameters, no output schema), the description is complete. It lists return fields (score, confidence, signals, raw_response, combined view) and explains the dual-model behavior. Annotations cover safety, so no 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?

Schema coverage is 100%, so baseline is 3. The description adds meaning beyond the schema by explaining the default model, that `_apiKey` enables Anthropic probing, and that `context` helps disambiguate. This extra guidance helps an agent use parameters correctly.

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 probes LLMs and scores visibility (0-100) per model. It uses specific verbs and resources, and lists use cases like AI-marketing audits and brand checks. However, it does not explicitly differentiate from the sibling tool 'scan_competitor_ai_presence', which may have overlapping functionality.

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

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

The description gives clear usage context (AI-marketing audits, pre-launch brand checks, competitive monitoring) and explains when to use the API key for Anthropic probing. It does not explicitly state when not to use the tool or list alternatives, but the provided context is sufficient for an agent to decide.

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

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

Beyond the readOnly/openWorld/idempotent annotations, the description transparently states its internal behavior: it routes to one of thousands of verified tools, fills arguments, returns stable pipeworx:// citation URIs, and can handle live news data. This is precisely the kind of hidden-routing behavior an agent needs to know.

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 its strongest action note and uses concrete examples to make the guidance valuable and immediately actionable. It is slightly repetitive toward the end, especially the 'START HERE / even if web search could also answer' emphasis, but overall it earns its 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?

For a broad open-world tool with no output schema, the description covers everything essential: when to use it, what input is expected, what internal routing occurs, and what return format to expect. It also covers a wide enough domain list with six concrete example questions that an agent can confidently invoke it for most factual queries.

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 fully documents the question parameter and all five aliases with descriptions and examples, so there is little parameter-level burden on the tool description. The description reinforces usage with domain examples, but it does not add any new syntax or parameter semantics beyond what the schema already provides.

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

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

The description is specific and actionable: it takes a natural-language factual question, routes it to one of thousands of verified tools, and returns an answer with citations. It clearly scopes its purpose and tells the agent to use it over web search, though it does not explicitly differentiate itself from the sibling tools ask_pipeworx_beta and 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?

It gives explicit trigger phrases, domains, example questions, and an unambiguous 'prefer over web search even if web search could answer.' This is strong when-to-use guidance. However, it does not provide any exclusion or when-not-to-use guidance for the similarly named sibling variants, leaving some selection ambiguity.

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

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

Annotations already cover read-only, open-world, idempotent, and non-destructive behavior. The description adds meaningful context: experimental candidate routing status, current candidate retirement date, the comparison against the stable router, and confirmation that it is a fully working router rather than a fallback. It is transparent about the live experimental nature.

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

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

The description is compact and front-loaded with necessary context: beta status, identical behavior, current no-candidate state, and intended usage. It could be slightly trimmed, but each clause contributes useful information about experimental status and fallback behavior.

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

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

The description sufficiently acknowledges absent output schema details by stating the response shape matches ask_pipeworx. It also provides the current candidate status, fallback behavior, and usage alignment, which makes the tool’s behavior clear without needing an output schema. Context is complete for an experimental variant of a known tool.

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

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

Schema description coverage is 100%, so parameter semantics are adequately documented. The description only mentions 'same arguments' and 'question' handling, but does not add extra parameter meaning beyond what's in the schema. It does not hurt but also does not meaningfully improve schema-based parameter understanding.

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

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

The description clarifies ask_pipeworx_beta as a beta variant of ask_pipeworx, identifying it as a universal router with the same tool set, arguments, and response shape. It clearly distinguishes between the stable ask_pipeworx and this experimental edge, but it relies on similarity to the stable tool rather than a standalone action verb for its core 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?

It explicitly says to use it exactly like ask_pipeworx when you want the newest routing, which is a clear usage condition. It also names ask_pipeworx as the comparable stable router, though it does not explicitly state when to choose stable instead of beta. The absence of a current candidate is helpful context for immediate 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 cover read-only, idempotent, open-world, and non-destructive behavior. The description adds substantial detail beyond annotations: it fetches via routing, extracts only from the tool result, returns structured evidence on success, and returns an explicit refusal with a reason when data does not support an answer. It also discloses an extra LLM call cost, which is genuinely beyond the structured fields.

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

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

The description is long but every sentence earns its place: purpose, routing, output contract, refusal taxonomy, usage conditions, and cost trade-off. It is front-loaded with the main differentiator and avoids filler or repetition.

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

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

Given that there is no output schema, the description compensates fully by documenting the success and refusal response shapes, including evidence, confidence, source, fetched_at, and refusal_reason. Use-cases, exclusions, alternatives, and cost trade-offs are all covered, so the agent can select and invoke the tool correctly without external 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 reported at 100%, so the parameters themselves are already fully documented in the schema. The description does not add additional parameter-level meaning, which is acceptable but not exceptional. This is the minimum viable score given complete schema coverage.

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

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

The description clearly identifies a distinct answer mode: hallucination-resistant grounded answering for high-stakes reads. It uses concrete verbs like 'extracts' and 'returns', differentiates from ask_pipeworx by noting the same routing but stricter evidence-only extraction, and explicitly names the refusal behavior that separates it from casual lookup tools.

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

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

The description gives explicit guidance on when to use: whenever the answer will be quoted, cited, or acted on, and the agent must not invent facts. It also states when NOT to choose it: casual lookups should prefer ask_pipeworx because this mode costs an extra LLM call. This is a clear and complete usage policy.

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

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

The description provides extensive behavioral details beyond annotations, including resolution logic (low-confidence matches, closed markets, wide spreads), response structure, source fan-out examples, and cancellation risk. Annotations already indicate read-only, idempotent, non-destructive behavior, and the description adds rich context 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 long but well-structured with sections (e.g., 'RESPONSE SHAPES', 'RESOLVER CONTRACT'), front-loading the core purpose. Each section adds necessary detail for a complex tool, though some repetition could be trimmed. Generally 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 complexity and lack of an output schema, the description fully covers the tool's behavior: how it resolves markets, classifies bets, fans out to data sources, returns evidence, handles edge cases (low confidence, closed markets, wide spreads), and explains cancellation rules. No gaps are apparent.

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

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

Schema description coverage is 100%, so the baseline is 3. The description repeats the parameter details already in the schema (e.g., depth options, include_raw behavior) and adds usage examples, but does not introduce significant new 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 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' This specifies a unique verb-resource combination and distinguishes from sibling tools like polymarket_edges or polymarket_arbitrage, which have different purposes.

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 usage contexts are given: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' This clearly defines when to use the tool, though it does not explicitly state when not to use it or compare to 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 read-only, open-world, idempotent, non-destructive. The description adds significant detail: for company type, it pulls latest 10-K financials with correct fiscal year handling; for drug type, pulls FAERS, FDA, and trial counts. It also mentions result sorting by primary metric and return of paired data with citation URIs. 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 detailed but every sentence adds value, starting with example queries to immediately convey purpose. No fluff; each sentence contributes to understanding when and how to use the tool.

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

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

Given the tool's complexity (two entity types with different data sources) and no output schema, the description is highly complete: it explains input parameters, data sources, sorting, and output format (paired data + citations). Nothing essential is missing.

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

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

Schema coverage is 100%, and the description adds meaning beyond the schema by explaining what data each type provides (company: financials from SEC; drug: adverse events, approvals, trials) and that values must be tickers/CIKs for company or drug names. It also states constraints like min 2, max 5.

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

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

The description clearly states it performs side-by-side comparison of 2-5 companies or drugs, with specific example queries like 'compare X and Y' and 'head to head'. It distinguishes itself from sibling tools like entity_profile by explicitly noting it replaces 8-15 sequential lookups.

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 'ALWAYS PREFER over sequential single-pack lookups when comparing entities', providing clear when-to-use guidance. It also explains the context of comparing multiple entities versus individual 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?

Even with readOnly/openWorld/idempotent annotations, the description adds rich behavioral context: it states that findings never fill gaps by inventing data, that citations are stable/downloadable records, that standard and thorough include contradictions[] scans, that large records are semantically excerpted, and that latency ranges 15-60s upward to 90s for thorough. This far exceeds annotation coverage.

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 long, every clause earns its place: account prerequisite, alternative routes, core capability, output packet, use-case fit, depth behavior, contradictions, and latency are all organized. The most decision-critical information is placed first, so an agent can quickly decide whether which tool should be called.

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?

Since there is no output schema, the description compensates by specifying the findings packet fields: verbatim evidence, confidence, source, fetched_at, stable citation, explicit gaps[], contradictions[], hop field, and citation_uri. It also covers expected latency and limitations; an agent has sufficient information to invoke the tool and interpret 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 already provides full 100% description coverage, including detail on quick/standard/thorough and the natural-language nature of the question. The description adds the paid-plan constraint for 'thorough' and latency expectations, but it does not materially change or extend the meaning of the parameters themselves. 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 identifies a specific verb+resource: 'Grounded multi-source research across Pipeworx's 1,472 STRUCTURED data sources' delivered in one call. It also distinguishes itself from open-web search and from ask_pipeworx by scope: broad/multi-part research versus single lookup.

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 provides selection guidance: 'If you are not signed in, use ask_pipeworx instead', 'For a single lookup use ask_pipeworx', and 'Best for broad/multi-part questions over structured data'. It also calls out that depth='thorough' requires a paid plan, so agents can route around that condition.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, covering safety. The description adds behavioral details: returns top-N most relevant tools with full schemas and examples, 'ready to call directly, no second schema lookup needed.' This is beyond the annotations. However, it doesn't mention rate limits or pagination; still, the description adds value.

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 with four sentences. Each sentence contributes: purpose, usage timing, output description, and a call to use first. It is front-loaded with the core action. It could be slightly shorter by condensing the domain list, but the examples add value. No repetition or 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?

Given no output schema, the description explains the return value: list of tools with names, descriptions, full schemas, and examples. It covers when to call (first) and what to expect. It doesn't explain error handling or limitations, but the complexity is moderate. The description is complete enough for an agent to understand usage.

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

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

Schema coverage is 100%, so baseline is 3. The description provides example queries ('analyze housing market trends') and lists aliases, but the schema already documents these. The description adds context by listing many domains as examples, but this is not strictly parameter semantics. No new meaning beyond schema for individual parameters.

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

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

The description starts with 'Find tools by describing the data or task' which is a specific verb+resource combination. It clearly states the tool's function: returning relevant tools based on a natural language query. The description distinguishes this tool from siblings by emphasizing discovery over direct question-answering (e.g., ask_pipeworx) and listing diverse data domains. The title 'Discover Tools' aligns with the 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?

The description explicitly says 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This provides a clear when-to-use instruction. While it doesn't explicitly state when not to use it, the context strongly implies it's for exploration before selecting a specific tool. The absence of exclusion statements prevents a score of 5.

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

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

Annotations provide readOnlyHint, openWorldHint, idempotentHint. Description adds details on parallel execution, fan-out behavior, specific return fields (CIK, filings with URIs, fundamentals sorted, patents soft-fail), and current limitation on entity type.

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 well-structured with examples, usage guidance, source list, return fields, and limitations. Every sentence is meaningful, though slightly verbose. Front-loaded with example queries.

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 (multiple sources, no output schema), the description is highly complete. It specifies all return components, includes URIs, sorting, and mentions patent API sunset. No missing critical information for an agent to invoke it correctly.

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

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

Schema coverage is 100% but description adds value by clarifying value can be ticker or CIK (with zero-padded example), explains type only supports company, and reiterates names not supported. This extra context justifies a 4.

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

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

The description clearly states the tool provides a 'full cross-source profile of a US public company' with numerous example queries. It distinguishes itself from sibling tools by specifying it fans out across multiple sources (SEC, XBRL, USPTO, news, GLEIF) and contrasts with chaining single-pack lookups.

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 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups' and instructs to use resolve_entity for names. Provides clear input format (ticker or CIK) and notes names not supported.

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 adds context about memory deletion and when to use, but doesn't disclose additional behavioral traits like 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?

Two concise sentences: first states action, second provides usage scenarios and pairing. Every sentence adds value with no redundancy.

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

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

For a simple 1-parameter tool with annotations and no output schema, the description fully covers purpose, usage, and context. 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 coverage is 100% with 'key' already described. The description does not add extra meaning 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 clearly states 'Delete a previously stored memory by key', specifying the verb and resource. It distinguishes from siblings by mentioning pairing with '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 provides when to use: context stale, task done, clear sensitive data. Also suggests pairing with remember and recall, indicating 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 indicate read-only, idempotent, non-destructive behavior. The description adds that it fetches the page, extracts title/description/key links, and emits standard llms.txt markdown, providing operational 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 three sentences, front-loaded with the main purpose, followed by process and use cases. 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?

For a tool with few parameters and no output schema, the description covers purpose, process, and use cases. It could mention output format more explicitly but already states 'standard llms.txt markdown format' and 'single text blob', which is sufficient.

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 detailed descriptions for both parameters. The description only implicitly references the 'url' parameter but does not add new meaning. Baseline 3 is appropriate as the schema handles semantics adequately.

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 generates an llms.txt file for a URL, specifying the verb 'Generate' and the resource 'llms.txt file'. It distinguishes from sibling tools by focusing on AI crawler indexing, a unique function among siblings like ai_visibility_check.

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 scenarios: 'getting a client's site indexed by AI, drafting llms.txt for your own project, or auditing how an AI crawler would see a competitor.' While it doesn't explicitly state when not to use it, the context is clear and no alternative tools are suggested.

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 provide readOnlyHint, idempotentHint, destructiveHint. Description adds return fields (id, type, params, etc.) and mentions default active subscriptions plus optional include_inactive, enhancing transparency 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 sentences covering purpose, returns, and usage. No redundant words, front-loaded with key info.

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 list tool with one optional boolean param and no output schema, description covers purpose, returns, and usage. Could mention pagination if exists, but not essential.

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

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

Input schema has 100% coverage describing 'include_inactive'. Description does not add additional meaning beyond schema, 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 clearly states 'List the caller's active subscriptions' with specific verb and resource. It distinguishes from siblings like 'subscribe' and 'unsubscribe' by focusing on listing, and mentions the 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?

Explicitly advises to use this tool before adding more subscriptions or to find an id to cancel, implying when not to use. Siblings 'subscribe' and 'unsubscribe' handle add/cancel actions.

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

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

With all annotations false, the description fully discloses behavioral details: rate limit of 5 per identifier per day, the fact that filing returns a claim_token, the claim_token's later use to read resolution status, and that feedback directly affects the roadmap. It also notes the tool is free and does not count against quota, going well 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 dense but every sentence earns its place: purpose, when-to-use, exclusions, token handling, rate limits, and quota impact. It is front-loaded with the primary action and then efficiently covers edge cases 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?

The tool has no output schema, so the description compensates by explaining what a filing returns (claim_token), how to subsequently check status and changes, and the daily digest behavior. Combined with the fully documented input schema, this gives the agent everything needed to invoke the tool correctly.

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

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

Schema coverage is 100% so the baseline is 3. The description adds practical param usage: how to format the message ('don't paste the end-user's prompt'), and clarifies claim_token usage with an example invocation. This extra guidance about message intent and token usage adds meaningful 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 opens with 'Tell the Pipeworx team something is broken, missing, or needs to exist,' which is a specific verb and resource. It clearly distinguishes the tool from sibling research/query tools by emphasizing it is for feedback about Pipeworx tools only, stating 'ONLY for tools served by this Pipeworx connection.'

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

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

The description explicitly lists when to use: for bugs, feature/data gaps, and praise. It also gives a strong exclusion: 'if the tool came from a different MCP server ... file it with that server instead,' and explains how to handle uncertainty by referencing the tool list. It even details the claim-token workflow for checking prior feedback.

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

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

Beyond the annotations (readOnly, openWorld, idempotent), the description adds concrete behavioral details: caching (5min-1h), data source (CF analytics-engine), no PII, self-aggregating. 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 three sentences, front-loaded with the core purpose, each sentence adding distinct value (what, use cases, technical detail). 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?

Despite no output schema, the description adequately explains the return structure (top tools, top packs, total call volume) and caching behavior. For a simple read-only tool with annotations covering safety, it is complete.

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

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

Schema has 100% coverage for the single parameter 'window', but the description adds semantic guidance: defaults to 24h, shorter windows for what's hot now, longer for steady-state demand. This helps the agent choose the right 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 returns trending data (top tools, top packs, call volume) over a specified window, with a specific verb+resource combination. It distinguishes itself from siblings like discover_tools by focusing on real-time popularity of tools themselves.

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 tool, alignment check) and explains the self-aggregating nature. It does not explicitly state when not to use, but the positive guidance is strong.

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, openWorldHint, idempotentHint, destructiveHint. Description adds rich behavioral details: partition check logic, semantic anchor (Jaccard similarity >= 0.30), partition filter (placeholder slugs, >20% placeholder fraction null), fill check against live CLOB depth, and conditions for valid trades. 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?

Description is long but well-structured with paragraphs and bolded terms. Every sentence adds value, though a few sections could be slightly more concise. Front-loaded with core purpose.

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 complexity (multiple modes, logic, fill check) and no output schema, the description thoroughly explains response structure, edge cases (placeholder slugs, low similarity), fill check, and custom sizing via another tool. Comprehensive and complete.

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

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

Schema descriptions already cover both parameters well (event: slug/URL; topic: seed question). Description adds significant value by explaining each mode's behavior, providing examples, and detailing the response structure and trade signals. Schema coverage is 100%, so baseline 3, but extra context elevates to 5.

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

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

Clearly states the tool finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. Distinguishes between three modes (no args, event, topic) and differentiates from sibling tools by mentioning fill risk 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?

Explicitly tells when to use each mode: no args for trending scan, event for specific markets, topic for cross-event scanning. Recommends event mode for specific markets and explains why cross-event catches patterns single-event misses. Also advises when not to trade and points 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?

The description discloses significant behavioral details beyond annotations: it explains the three response segments (MODEL_DRIVEN, STRUCTURAL_ARBITRAGE, CONCENTRATED_LONGSHOT), caching at KV level for 1 hour, and diagnostic information. Annotations already confirm read-only, idempotent, non-destructive nature, so the description adds valuable operational context.

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

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

The description is front-loaded with the purpose and is well-structured with clear sections for models, opportunity details, knobs, and response format. While it is lengthy, each sentence adds value given the tool's complexity. A slightly more concise summary could improve readability.

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, no output schema, and high parameter count, the description covers all essential aspects: what it does, how it works (models, segments), what each opportunity includes, tradeable-edge filters, response structure, diagnostic info, and caching behavior. It is fully 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 detailed parameter descriptions, so the baseline is 3. The description adds no additional meaning to the parameters themselves but provides context on output structure and internal model logic, which indirectly aids parameter understanding.

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

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

The description clearly states the tool scans Polymarket markets to return opportunities where Pipeworx data disagrees with market price. It specifies the verb 'scan' and the resource 'Polymarket markets', and distinguishes itself from siblings like polymarket_arbitrage by focusing on Pipeworx-driven edge detection.

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

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

The description frames the tool as for 'what should I bet on today' and mentions discovering opportunities without paging hundreds of markets. However, it does not explicitly state when to use this tool versus alternatives like polymarket_arbitrage or polymarket_edge_tracker, nor does it provide exclusions.

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

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

The description adds rich behavioral context beyond annotations: it details the response structure (tracked, expired, snapshot_dates), explains the signed edge_pp_net value, and discloses snapshot creation conditions (cache-miss gaps). Annotations already indicate idempotent and read-only behavior, which the description supports.

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

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

The description is dense and technically precise, front-loaded with a clear question. Each sentence provides necessary information, but it could be slightly more concise. It earns a 4 for effective communication.

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, two parameters, and no output schema, the description is remarkably complete. It explains the full response format, the meaning of all fields, and important limitations like snapshot TTL and decay computation. No gaps are evident.

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 both parameters have descriptions. The description adds value by explaining defaults (days=14, window='1wk'), constraints (days clamped 2-30), and the purpose of the window parameter (snapshot family). It goes beyond the schema's inline 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 the tool's purpose: providing edge persistence and decay telemetry from daily snapshots. It answers a specific question about edge longevity and distinguishes itself from sibling tools like '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?

The description explains when to use the tool (to understand edge persistence and decay) and provides context on data limits (60-day TTL, snapshot gaps). It implies alternatives but does not explicitly name them, so a slight deduction.

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 (readOnlyHint, openWorldHint, idempotentHint, destructiveHint). It explains the live order-book check, ladder walking, verdict output (clean|degraded|cannot_fill), and warns about forced directional risk in basket mode. 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 requirements, single-market mode, basket mode, and a usage note. It is slightly verbose but every sentence adds necessary context. A minor reduction in length would improve conciseness.

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 thoroughly enumerates the return values for both modes (top_of_book, vwap_fill_price, slippage_pp, etc. for single-market; theoretical_sum, realizable_sum, capture_ratio, profit_usd, per-leg fill, thin_legs, etc. for basket). This level of detail makes the tool complete for an AI agent to understand the output.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by explaining the two modes (market vs event), the auto-detection of side for baskets, and the interpretation of size_usd for buys vs sells. It also mentions clamp range (10–1,000,000). These details go 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 performs a 'realizable-vs-theoretical edge check against live CLOB order-book depth' and specifies two distinct modes (single-market and basket). It also explicitly distinguishes itself from sibling tools like polymarket_arbitrage and polymarket_edges by providing a usage directive.

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 advises using this tool 'before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500' and explains the risks of not doing so (theoretical overround not capturable, partial basket fills creating unhedged positions). This provides clear when-to-use and when-not-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?

The description details behavioral traits beyond annotations: two modes, response components, safety fields for compatibility, temporal alignment, and counters for skipped comparisons. It also notes that real spreads are rarer than the macro list suggests. No contradiction with readOnlyHint and idempotentHint.

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 but well-structured with clear sections (TWO MODES, RESPONSE, SAFETY FIELDS). Every sentence adds information, though there is slight redundancy in the warning about pre-mapped topics. Overall, it earns its 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?

Given no output schema, the description sufficiently explains the response structure (raw probabilities, top_spreads_pp, compatibility_warning, temporal_alignment, counters). It is comprehensive for the tool's complexity and parameter set.

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 parameters are already documented. The description adds value by explaining that the 'topic' parameter is a pre-mapped shortcuts list and that explicit tickers override the topic-mapped sides. This context improves usability.

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 computes cross-venue spread between Kalshi and Polymarket for the same resolving question. It distinguishes two modes (topic shortcuts and explicit tickers) and describes the response structure, making the purpose highly specific and distinguishable from sibling tools.

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

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

The description provides explicit guidance on when to use each mode, warns that most pre-mapped topics return compatibility warnings today, and explains safety fields to help the agent decide when the spread is meaningful. This offers clear when-to-use and when-not-to-use information.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint. The description adds valuable context about scoping (anonymous IP, BYO key hash, or account ID) and the behavior of listing keys when the key argument is omitted.

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

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

Three sentences efficiently cover purpose, usage context, and scoping. Front-loaded with core functionality, 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?

For a simple read tool with one optional parameter and no output schema, the description is adequately complete. It explains behavior, scoping, and sibling pairing, though it could briefly mention the return format (e.g., value or list of keys).

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 description essentially restates the schema's parameter documentation without adding new meaning, so 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?

Clearly states the verb (retrieve/list) and resource (values saved via remember), and distinguishes from sibling tools (remember, forget) by naming them and explaining their roles.

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

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

Provides explicit guidance on when to use (lookup stored context) and how it works (scoped to identifier), and directly pairs with remember and forget as alternatives for saving and deleting.

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, and destructiveHint=false. The description adds valuable context beyond annotations, such as the effect of mark_read:true in flagging events as read and the structure of returned events (source, citation_uri, payload). No contradictions observed.

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 communicates the tool's purpose, key features, and usage tips. Every sentence contributes meaningfully without redundancy, and the most critical information (what the tool does) 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?

Despite lacking an output schema, the description adequately explains return fields (source, citation_uri, payload) and filtering options. Given the tool's simplicity and the richness of annotations (which cover read-only and idempotent behavior), the description is sufficiently complete for effective agent 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?

All 5 parameters are documented in the schema with descriptions. The description enhances this by providing examples (e.g., 'sec_8k' for type, ISO timestamp for since) and explaining the behavior of mark_read (flagging events read). This adds practical 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: 'Pull fired events from your subscription feed. Returns the most recent alerts...' It specifies the resource ('subscription feed') and the action ('pull'), effectively distinguishing it from sibling tools like list_subscriptions or subscribe.

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 context on usage, stating 'Polls work fine' and noting an alternative endpoint for scripts/dashboards. However, it does not explicitly state when not to use this tool or compare it to other siblings for specific scenarios, leaving some ambiguity.

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

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

Beyond annotations (readOnlyHint, etc.), the description discloses fan-out behavior to SEC EDGAR, GDELT→GNews fallback, and USPTO with soft-fail note. It also states the return structure with changes grouped by source and 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?

The description is dense but well-structured, with examples and alternatives front-loaded. Every sentence adds value, though it could be slightly more 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 covers all necessary aspects given the parameter count and annotations. It mentions return shape and behavioral traits. Potential omission of pagination details, but overall complete.

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

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

Schema coverage is 100%, and the description adds meaningful usage context: for 'since' it explains ISO date and relative shorthand with recommended values; for 'value' it provides examples of ticker and CIK; for 'type' it clarifies only company is supported.

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 it is a 'change feed for a company in the last N days/weeks/months' and provides example queries like 'What's new with X'. It distinguishes from the sibling tool 'entity_profile' by directing users to use that for static profiles.

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

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

The description gives clear when-to-use guidance with example queries and explicitly advises against using it for static profiles, directing users to 'entity_profile' instead. It also describes the fan-out to multiple sources.

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 reveals significant behavioral traits beyond annotations: key-value scope by identifier, persistent storage for authenticated users, 24-hour retention for anonymous sessions. No contradiction with annotations (idempotentHint=true, destructiveHint=false).

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 concise (~5 sentences) with front-loaded purpose, followed by usage guidance, storage details, and companion tools. 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 simplicity (2 required params, no output schema), the description fully covers purpose, usage, persistence, and pairing with related tools. 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 coverage is 100% with clear descriptions for key and value. The description adds example conventions (e.g., 'subject_property') and valid values, but these are supplementary to already adequate schema documentation.

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: to save data for reuse across conversations or sessions. It provides concrete examples of what to store (e.g., resolved ticker, target address) and mentions companion tools (recall, forget) to distinguish its role.

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 the tool ('when you discover something worth carrying forward') and pairs it with recall and forget for retrieval and deletion, providing clear guidance on 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?

Beyond the annotations (readOnly, openWorld, idempotent, non-destructive), the description discloses graceful degradation (if GLEIF/OpenFIGI unavailable, EDGAR identifiers still return), internal cascading lookups, explicit handling of unresolved identifiers (under `unresolved`), and source labelling. These are behavioral traits not captured by annotations.

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

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

The description is dense and informative but is a single long paragraph. It could be better structured (e.g., bullet points for supported types). Every sentence does add value, but the length and lack of formatting make it harder to parse quickly.

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 covers return values, source attribution, unresolved handling, and failure modes. It also explains the tool's internal complexity and why it replaces multiple lookups, making it complete for an 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?

Schema coverage is 100%, providing baseline 3. The description adds significant value with concrete input examples (AAPL, CIK, ISIN, brand names), explains the ISIN-to-LEI mapping, and clarifies what each type returns. This goes beyond the schema's concise parameter 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 the tool's purpose: resolving user-spoken names to canonical identifiers. It uses specific verbs ('resolve') and nouns ('NAME', 'canonical/official identifiers'), and gives concrete query examples. It also differentiates from siblings by noting it supplies inputs other tools require and by saying 'Use FIRST whenever you have a name but need an ID.'

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 guidance: 'Use FIRST whenever you have a name but need an ID.' It also explains which types are supported (company, drug) and how the tool replaces multiple manual lookups. While it doesn't list when not to use it, the context makes the intended usage unambiguous.

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 annotations: it explains that each entity is probed with ai_visibility_check, results are ranked, and output includes score, confidence, signal density. No contradiction with annotations (readOnly, idempotent).

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

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

The description is three sentences, front-loaded with the main purpose, and every sentence adds value. No wasted words.

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

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

Given the complexity and absence of output schema, the description adequately explains the internal process (probes, ranks) and output fields (score, confidence, signal density). It is complete for an agent to understand what the tool does and what results to expect.

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

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

Schema coverage is 100%, so baseline is 3. The description adds minor extra semantics: 'first entry treated as subject for narrative' and that context disambiguates common names. This is helpful but not extensive.

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 compares AI visibility across multiple entities side-by-side, probes with ai_visibility_check, ranks by score, and surfaces most/least recognized. It distinguishes from the sibling ai_visibility_check which is for 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?

The description provides clear usage context: 'useful for competitive AI-marketing audits' and gives an example question. It implies when to use but does not explicitly exclude alternatives like compare_entities.

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. The description adds critical behavioral details: partial failures degrade gracefully, bundlephobia first measurement may take 5-30s, sources_failed lists timeouts, rest still returns. 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 a single, well-structured paragraph that front-loads the core purpose. While it is dense with information, each sentence contributes to understanding the tool's function, limitations, and output.

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 having no output schema, the description thoroughly details the return format: summary block, per-advisory detail, links, alternative versions, and behavior on partial failures. This makes the tool's output predictable for the agent.

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 two parameters. The description adds value beyond the schema by explaining that scoped packages (e.g., @types/node) are accepted and that version defaults to latest when omitted.

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's purpose: a composite check for npm packages aggregating data from deps.dev and bundlephobia. It uses a specific verb ('scan' or 'check') and resource ('npm package dependency'), and distinguishes from handling other ecosystems by directing to deps.dev directly.

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

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

Clear guidance on when to use: when an agent asks about safety, popularity, size, or cost of adding a package. Also explicitly states the NPM-only scope and directs for other ecosystems to use deps.dev:version directly.

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, non-destructive. Description adds rich behavioral details: BGE-base-en embeddings, cosine similarity, 500-char overlapping windows, 200K char cap with truncation flagging, and that passages include offsets and scores. This far exceeds annotation coverage.

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 is well-structured: purpose first, then usage, then technical details. Every sentence contributes meaning. Efficiently conveys complex information without waste.

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 explains return values (passages with offsets and scores), covers truncation behavior, and mentions embedding model. All relevant aspects are addressed for a complex search tool.

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

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

Schema covers 100% of parameters with descriptions. The description adds the default limit (5), range (1-20), and example queries for 'query' parameter, providing 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?

The description clearly states the tool performs semantic search inside a fetched record, using specific verbs and resources (e.g., SEC 10-K, article). It is distinct from siblings like ask_pipeworx_grounded, but does not explicitly differentiate from all siblings.

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

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

Explicitly states when to use (record too large for prompt) and pairs with ask_pipeworx_grounded for grounding. However, no explicit when-not-to-use or alternatives beyond the pair.

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 contradicts the annotation 'idempotentHint: true' by stating that each call creates a new subscription and returns a new ID, implying non-idempotent behavior. This serious inconsistency warrants a score of 1.

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

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

The description is well-structured with the purpose front-loaded, followed by bullet-pointed details. Every sentence adds value without redundancy, achieving high conciseness for the amount of information conveyed.

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 subscription types), the description covers all necessary aspects: authentication, type-specific params, delivery options, constraints (SMS cap, webhook signing), and the return value. No output schema exists, but the description adequately specifies the return.

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?

While the input schema already describes all parameters (100% coverage), the description provides valuable additional context with type-specific examples and delivery constraints (e.g., SMS cap, webhook HMAC signing), adding 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 uses a specific verb ('Create') and resource ('subscription to a live-data event stream'). It clearly states what the tool does and distinguishes itself from sibling tools like list_subscriptions 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 mentions prerequisites (OAuth account), supported subscription types with examples, and delivery options, but does not explicitly state when to use this tool versus alternatives like list_subscriptions. The context is implied but not explicit.

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, destructiveHint=false. The description adds value by explaining the return format: category-bucketed example questions with tool+argument shapes. It also clarifies that omitting the topic gives a cross-category spread. No contradiction.

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

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

The description is moderately long but well-structured: starts with example queries, explains return format, then usage instructions. Every sentence is informative. It is front-loaded with aliases. Could be slightly more concise but not overly verbose.

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 the return format (category-bucketed example questions with tool+argument shapes). Parameter count is 1 and schema coverage is 100%, so the description covers all necessary context. It also explains use cases and when to call.

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

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

Schema has one optional parameter 'topic' with description and values. Schema coverage is 100%, so baseline is 3. The description adds context by listing example topic values (finance, pharma, etc.) and explains that omitting gives full spread. 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 it is the onboarding entry point for a new agent, returning category-bucketed example questions. It lists aliases for what users might type, and specifies the action (suggest questions) and resource (Pipeworx capabilities). It distinguishes from sibling tools like 'ask_pipeworx' which are for directly asking questions, not suggestions.

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 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools.' It also explains optional topic parameter for focus. No when-not is given, but context implies not to use if already know what to ask. Siblings are listed for reference.

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 indicate non-destructive and idempotent behavior. The description adds crucial context: ownership enforcement, soft deactivation (not deletion), and that historical events remain accessible via 'recent_alerts'. This goes well 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 concise sentences with no unnecessary words. It front-loads the action and immediately follows with key behavioral constraints.

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

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

For a simple tool with one parameter, the description covers purpose, ownership, side effects, and post-condition (historical events remain via recent_alerts). No output schema is needed as the return value is 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 coverage is 100% and the schema already documents the 'id' parameter as a UUID from 'subscribe'. The description does not add additional meaning beyond restating that the ID is used. Baseline score of 3 applies.

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

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

The description clearly states the tool cancels a subscription by ID, with ownership enforcement. It distinguishes itself from the sibling 'subscribe' tool by being the inverse operation.

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: use when you want to cancel your own subscription. It references 'recent_alerts' for historical events, implying when not to use (if you need to preserve the subscription). No explicit exclusion of alternatives, but sufficiently clear for the use case.

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: it explains the distinction between could_not_verify (the check did not happen) and unsupported (no source found), details the internal routing to SEC EDGAR/XBRL vs. grounded pipeline, and notes the replacement of multiple sequential calls. This goes well beyond the read-only and idempotent hints.

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

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

The description is moderately long but well-structured, front-loaded with example trigger phrases and logically organized into purpose, routing, return values, and error semantics. It is dense but every sentence contributes, though it could be tightened without losing essential nuance.

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

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

For a complex verification tool with no output schema, the description is exceptionally complete. It enumerates all possible verdict types, what the return includes (value, citation, reasoning), explains the error condition could_not_verify, and clarifies the unsupported verdict. It also frames the tool as a replacement for multiple sequential steps, giving a full picture of its role.

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 already fully describes both parameters (100% coverage), so the baseline is 3. The description adds valuable extra context, especially for tolerance_pct: it explains the default (implied by wording, capped at 5) and provides guidance for hallucination detection (set 1–2). This goes beyond the schema details.

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 performs natural-language claim verification against authoritative sources, with concrete trigger phrases and examples. It identifies the resource (claim) and the verb (validate/verify), but it does not explicitly name sibling tools or contrast itself with them, so it misses the full distinction criterion.

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 it ('Use whenever the agent needs to check whether something a user said is factually correct') and describes the routing for company-financial claims vs. all other claims. However, it does not mention when not to use it or name specific alternatives, so it lacks exclusions.

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