Openverse

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

Adds significant behavioral context beyond annotations: default model is free, Anthropic requires user-provided key with pass-through to api.anthropic.com, returns per-model and combined results, and mentions cost implication for Anthropic calls. 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 moderately sized with key action front-loaded. Every sentence is informative, though the second sentence is long and packs multiple details. Remains efficient without unnecessary words.

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

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

Covers tool purpose, default/modified behavior, return format (per-model and combined view), and use cases. With no output schema, the description compensates well. Does not mention limits or pagination, but adequate 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% (baseline 3), but description adds value by providing examples for entity, listing supported models, explaining _apiKey's bypassing cost structure, and clarifying context role in disambiguation. This raises the score above baseline.

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

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

The description clearly states the tool probes LLMs for knowledge about an entity and scores visibility (0-100) per model. It specifies default model, optional Anthropic with API key, and return format. This distinguishes it from siblings like 'ask_pipeworx' which answer questions, as this tool provides a visibility score.

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 lists use cases: AI-marketing audits, pre-launch brand checks, competitive monitoring. Explains when to use _apiKey for Anthropic. Does not directly compare to siblings but implies context. Lacks explicit when-not-to-use statements.

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 discloses that the tool auto-fills arguments, routes to a huge internal tool registry, and returns stable pipeworx:// citation URIs. This is meaningful behavioral disclosure for a black-box router. It does not mention failure modes, latency, or coverage limits, but given the strong annotation safety profile that gap is minor.

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, the description is tightly structured: preference, domain list, routing behavior, trigger phrases, examples, and a 'START HERE' pointer. Every sentence carries selection-relevant information; there is no filler.

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

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

Given the rich annotations and a one-parameter schema, the description covers inputs, domains, routing behavior, and return format via the explicit mention of structured answers and stable citation URIs. No output schema exists, so that return-format sentence is valuable. It still does not address how the tool handles unanswerable questions or when to prefer a sibling variant, which costs a point.

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 documents the question parameter and all aliases at 100% coverage, so the baseline is 3. The description adds practical semantics by listing natural-language trigger phrases and examples, and by saying the tool 'fills arguments', which tells the agent to supply only the user's question.

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

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

The description states a specific behavior: route a natural-language question across 5,798 tools/1,517 sources, fill arguments, and return a structured answer with pipeworx:// citations. It is unmistakably a factual Q&A tool and is framed as the default over web search. However, it never distinguishes itself from the sibling variants ask_pipeworx_beta or ask_pipeworx_grounded, so it stops short of full sibling differentiation.

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 strong when-to-use guidance: 'PREFER OVER WEB SEARCH', 'Use whenever the user asks...', and 'START HERE for most questions', plus concrete trigger phrases and domain examples. What is missing is an explicit when-not-to-use statement or pointers to sibling alternatives such as deep_research or ask_pipeworx_grounded for specialized cases.

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

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

Annotations already mark the tool read-only, open-world, idempotent, and non-destructive, so the description's burden is lower. It adds significant behavioral context: live candidate routing improvements, no active candidate as of the stated date, fallback to nothing, and the fact that this is a fully working router rather than a stub. This prevents false assumptions about reliability and stability.

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 front-loads the beta identity and scope, and later sentences earn their place by explaining the current no-candidate state and the no-fallback nature. There is mild redundancy between 'identical universal router' and 'Use it exactly like ask_pipeworx,' and the specific date will age, but the overall structure is effective.

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 what the tool is, its current operational state, when to use it, and its safety profile via annotations, and the schema covers parameters. The main gap is the response shape: it is only referenced as being the same as ask_pipeworx, not described, and there is no output schema to fill in that detail.

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

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

Schema coverage is 100%, so all six parameters, including the aliases, are already documented. The description only says 'same arguments' as ask_pipeworx and does not add extra semantic detail beyond what the input schema already provides, so the baseline 3 is appropriate.

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

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

The description clearly identifies the tool as a beta variant of ask_pipeworx with the same 5,798 tools, arguments, and response shape, which distinguishes it from the stable sibling. It does not spell out the user-facing function in standalone terms—'ask a question and get a routed answer'—but the router framing and sibling reference make the purpose clear.

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 to use it exactly like ask_pipeworx when the newest routing is wanted and notes that results are compared against the stable router. It also discloses that no candidate is currently active, so behavior currently matches ask_pipeworx exactly, and labels the tool as the experimental edge, which implies when not to prefer it.

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

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

Beyond the annotations (readOnly, idempotent, non-destructive), the description discloses crucial behavior: it returns a structured success object with evidence as verbatim quote, and an explicit refusal object with specific refusal_reason enums. It also reveals the cost tradeoff ('Costs one extra LLM call'), providing transparency beyond what annotations cover. 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 front-loaded with its core value proposition ('Hallucination-resistant answer mode for high-stakes reads') and every subsequent sentence adds distinct information: routing scope, extraction rule, return/refusal shapes, use cases, and cost comparison. It is moderately long but has zero filler.

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

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

Given the tool's complexity (routing across thousands of tools, high-stakes use, possible refusal), the description is self-sufficient. It documents the return contract, refusal reasons, and selection criteria. With only one simple question parameter and no output schema, nothing critical 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?

The input schema has 100% description coverage for the single required 'question' parameter, including aliases, so the baseline is 3. The description does not add any parameter-specific semantics; it focuses on behavior and routing, which is fine because the schema already fully documents the parameter.

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

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

The description states a specific verb-resource pair ('answer mode') and precisely defines the behavior: extracts the answer using ONLY the tool result, with explicit refusal when unsupported. It clearly distinguishes itself from the sibling ask_pipeworx by highlighting the grounding/refusal mechanism and the extra LLM call.

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 states when to use: 'Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts' and gives concrete examples. It also states when NOT to use it: 'prefer ask_pipeworx for casual lookups,' directly naming the alternative and the condition that selects it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the tool's safety profile is clear. The description adds that it returns related audio for a given ID, which is consistent but does not elaborate on behavior beyond that. Since annotations cover the main behavioral traits, a score of 3 is appropriate.

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

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

The description is extremely concise at two sentences, front-loading the command-like phrasing and use case. Every word 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?

Given the tool has a single parameter, an output schema (which explains return values), and strong annotations, the description covers the essential purpose and parameter meaning. It is complete for a simple read-only similarity 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?

The only parameter 'id' has 0% schema description coverage, but the description explains it as an 'Openverse audio ID' and the input schema includes an example. This adds necessary meaning beyond the bare schema, compensating for the lack of schema descriptions.

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

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

The description clearly states the tool finds audio similar to a given Openverse audio ID, using phrases like 'Find audio similar to [X]' and 'more sounds like this'. It distinguishes from sibling tools like search_audio (keyword search) and get_audio (single retrieval) by specifying similarity exploration.

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 for similarity exploration in CC audio', providing clear context for when to use the tool. While it does not state when not to use it, the purpose is distinct from siblings and the guidance is sufficient.

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 (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false) are fully consistent. The description adds extensive behavioral details: fan-out patterns, resolver contract, parent extractor, news fallback logic, safety short-circuits, illiquid spread handling, and cancellation rule parsing. 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 lengthy but well-structured with clear sections (CLASSIFIERS, FAN-OUT, RESPONSE SHAPES, etc.) and front-loaded core action. Every section adds necessary detail, though could be slightly more concise without losing information.

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

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

Given the tool's complexity (multiple fan-out paths, resolver, safety checks) and lack of output schema, the description covers all necessary aspects: input formats, response shapes, edge cases (closed markets, low confidence, wide spreads), and cancellation rule risk. Fully informative for agent 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%, baseline 3. Description supplements each parameter: market input types are explained in depth, depth enum with quick/thorough meaning, include_raw with usage guidance. Adds value beyond schema definitions.

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 researches Polymarket bets by pulling Pipeworx data, specifying input types (slug, URL, question) and output (evidence packet + comparison). It distinguishes from sibling tools like polymarket_edges and research tools through unique fan-out and resolver details.

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

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

The description provides explicit use cases ('should I bet on X', 'what does the data say about Y', 'is there edge in Z') and guidance on checking fields like market_match_confidence and parent_event. It lacks explicit when-not-to-use, but the safety mechanisms and closed-market handling implicitly guide appropriate 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 declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds significant context: details data sources (SEC EDGAR/XBRL for companies, FAERS for drugs), explains fiscal year handling, sorting by primary metric, and 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 somewhat long but every sentence earns its place, covering usage examples, data details, and edge cases. Front-loaded with clear triggering phrases. Minor room for tightening but 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?

Despite no output schema, the description explains return format (paired data + citation URIs) and sorting behavior. Covers edge cases (off-calendar fiscal years) and provides complete guidance for a comparison tool with two parameter types and varied data sources.

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

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

Schema coverage is 100% with both parameters described. The description adds meaning beyond schema: explains each enum value's data pulled, gives concrete examples for values (tickers vs drug names), and specifies constraints like max 5 items.

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 in one parallel call, with specific examples like 'compare X and Y' and 'X vs Y'. It distinguishes itself from sequential single-pack lookups, fulfilling the 'specific verb+resource' and sibling differentiation criteria.

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

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

Explicitly advises 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' Provides clear guidance on when to use this tool versus alternatives, which is a top-score behavior.

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

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

Even though annotations already mark this as read-only, open-world, idempotent, and non-destructive, the description adds substantial behavioral context: account requirements, latency, parallel decomposition, gaps[] behavior, never-invented findings, fetchable citation URIs, contradictions[] for deeper depths, and semantic excerpting. There is no contradiction with 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 long but dense, and nearly every sentence contributes useful behavioral or selection information. It is reasonably front-loaded with auth requirements and the ask_pipeworx alternative, though some depth semantics are repeated from the schema, adding a little redundant 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 complex tool with no output schema, the description is remarkably complete: it covers auth, expected latency, input suitability, output packet contents, citation resolution, gap handling, contradiction behavior, and depth-dependent execution. An agent has enough information to invoke it correctly and interpret its 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 documents both 'question' and 'depth' in rich detail, including depth variants, facet counts, and the paid thorough tier. The description mostly reinforces those details rather than adding new parameter meaning, with only minor added context about multi-step questions resolving in one call.

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

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

The description clearly states the tool performs grounded multi-source research over Pipeworx's structured data sources in one call, using verbs like 'research' and 'decomposes' with a concrete resource. It also explicitly distinguishes itself from open-web search, which makes its purpose unmistakable.

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

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

Usage guidance is explicit: the tool is best for broad/multi-part structured-data questions, and the description names ask_pipeworx both for users who are not signed in and for single-lookup use cases. It clearly states what the tool is not for, giving an agent actionable selection criteria.

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, destructiveHint=false, idempotentHint=true. The description adds that results include full input schemas with curated examples and are ready to call directly, which is valuable 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 compact yet comprehensive, with examples and clear guidance. Every sentence adds value, and it is well-structured for quick understanding.

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

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

Given the tool's role as a discovery tool, the description covers usage, examples, and output behavior (returns top-N tools with schemas). No output schema is needed, so completeness is high.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description briefly mentions aliases but does not add significant meaning beyond what the schema provides.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It lists specific use cases (SEC filings, financials, etc.) and distinguishes from siblings by focusing on tool discovery rather than direct data retrieval.

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

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

Explicit guidance provided: 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' It also includes examples of when to use, making it easy for the 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/idempotent annotations, the description explains important runtime behavior: parallel fan-out across sources, soft-fail for the USPTO API sunset, expected empty results for FDA biologics when the company lacks them, GDELT-to-GNews fallback, and source success/failure reporting.

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 information-rich, with no filler, but it is one long wall of text. A structured layout with bullet-style separations or explicit return-field groupings would make it easier for an agent 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?

With no output schema, the description carries the full burden of explaining the return shape, and it does so thoroughly: CIK, filings, fundamentals, patents, contracts, FDA products, hiring, news, LEI, and sources_used/sources_failed. It also covers edge cases like private companies and empty sections.

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

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

Schema description coverage is 100%, and the description largely restates what the schema already says: `type` accepts company/ticker interchangeably and `value` can be a ticker, CIK, or company name. It adds examples but no meaningful new parameter semantics beyond what the schema provides.

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

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

The description states a specific verb and resource: it builds a full cross-source profile of a US public company. It opens with concrete user-phrasing examples (e.g., 'Tell me about X', 'brief me on Tesla') and clearly distinguishes itself from single-pack SEC/XBRL/news 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?

It explicitly says to prefer this tool over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view. It also specifies acceptable inputs (ticker, CIK, company name) and the expected behavior for private companies.

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 include destructiveHint: true, idempotentHint: true. The description adds context about why to delete (stale context, done task, sensitive data), which goes beyond the annotations. 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 two sentences, front-loaded with the purpose, and each sentence contributes value without redundancy.

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

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

For a simple tool with one required parameter and no output schema, the description fully covers purpose, usage conditions, and companion tools.

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

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

Schema coverage is 100% with one parameter 'key' described as 'Memory key to delete.' The description does not add additional meaning beyond what the schema provides.

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

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

The description clearly states 'Delete a previously stored memory by key,' specifying the verb (delete) and resource (memory). It distinguishes from siblings by explicitly mentioning '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?

The description provides explicit scenarios for use: 'when context is stale, the task is done, or you want to clear sensitive data,' and advises pairing with remember and recall, offering clear guidance on when and how to use the tool.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds specifics: fetches the page, extracts title/description/key links, and outputs standard llms.txt markdown. It also clarifies the output is a single text blob for site-root placement, which is beyond what annotations provide.

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

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

Three sentences: purpose, process/output, use cases. Front-loaded with the core action, no unnecessary words. Every sentence earns its place.

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

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

Given the tool's simplicity, annotations cover safety, schema covers parameters, and the description explains the process and output format. No output schema exists but the description compensates by specifying the output is a text blob in llms.txt format. Complete for its complexity.

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

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

Schema coverage is 100%, with well-described parameters (url example, max_links default/max). The description does not add new syntactic details but reinforces the purpose (extracting title/description/key links) which is already implied. Baseline 3 is appropriate.

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

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

The description clearly states the tool generates a production-ready llms.txt file for any URL, specifying the process (fetch, extract, emit) and the resource (llms.txt). It distinguishes from siblings like scan_competitor_ai_presence by focusing on creating the file itself.

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 lists three specific use cases (client site indexing, own project drafting, competitor auditing), providing clear context for when to use. However, it does not explicitly mention when not to use or alternative tools, though no obvious alternative exists among siblings.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint false. Description adds value by listing specific metadata fields returned (license, duration, attribution, source), complementing annotations 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?

One sentence, 16 words, front-loaded with verb and resource. Every part is essential; 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 tool with one parameter and an output schema, the description covers what the tool does, when to use it, and key return fields. No gaps remain given the complexity.

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

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

Single parameter 'id' is described as 'UUID' in the description, adding meaning beyond the schema's bare type string. Schema has 0% description coverage, so description compensates adequately by clarifying the expected format.

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

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

Description clearly states 'Fetch full metadata for a single Openverse audio record by UUID', specifying the action, resource, and identifier. Distinguishes from sibling tools like 'search_audio' (searching) and 'audio_related' (related records).

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 'Use after search_audio for licensing details', providing clear context for when and why to use this tool. Does not explicitly state when not to use, but guidance is sufficient.

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 context about the returned metadata fields and the tool's role in providing licensing details, which is useful beyond annotations. 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?

Two sentences, each with a clear purpose. The first describes the tool's function and input, the second provides usage context. No unnecessary words.

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

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

Given the simple tool (single parameter, output schema present) and comprehensive annotations, the description covers the essential aspects: purpose, usage guidance, and return value hints. It is complete for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'by UUID' but does not elaborate on the format or constraints of the 'id' parameter. The example in the schema helps, but the description adds minimal value beyond stating the parameter is a UUID.

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 action ('Fetch full metadata'), the resource ('Openverse image record'), and the identification method ('by UUID'). It lists example metadata fields (license, attribution, source, dimensions), distinguishing it from sibling tools like 'search_images' and 'get_audio'.

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

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

Explicitly states 'Use after `search_images` for licensing details', providing clear when-to-use guidance and linking to a sibling tool, which helps the agent understand the correct workflow.

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 behavior. The description adds that it finds 'related images for a given Openverse image ID,' which is consistent with annotations. It could optionally mention result variability or limitations, but overall no contradictions and adequate transparency.

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

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

The description is extremely concise, using a common user phrasing pattern ('Find images similar to [X]') and a single additional sentence for context. Every word 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?

Given the tool's simplicity (1 parameter, output schema present), the description covers purpose, usage context, and input semantics completely. The agent has enough information to select and invoke this tool correctly.

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

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

The single parameter 'id' has no description in the schema (0% coverage), but the description clarifies it is an 'Openverse image ID,' adding crucial meaning beyond the type. This effectively tells the agent what value to provide.

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

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

The description clearly states the verb ('find'), the resource ('images similar to [X]'), and the specific input ('Openverse image ID'). It distinguishes itself from sibling tools like 'search_images' by focusing on visual-similarity exploration rather than keyword search.

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

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

The description explicitly mentions 'Use for visual-similarity exploration in CC content,' providing clear context for when to use it. It implies that this tool is for finding similar images given an ID, contrasting with search-based siblings, but does not explicitly state when not to use it.

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

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

Annotations already declare readOnlyHint and destructiveHint=false. Description adds context on return shape and the optional parameter, 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 well-structured sentences, no filler, all information is relevant and front-loaded.

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

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

Given the simple tool nature, description covers purpose, return fields, usage guidance, and the parameter effect. No missing information.

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 the single parameter with 100% description. Description does not add extra meaning beyond the schema, 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?

Description clearly states it lists the caller's active subscriptions and specifies the return fields. It distinguishes from sibling tools like subscribe and unsubscribe by focusing on read-only listing.

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: 'review what you're monitoring before adding more or to find an id to cancel'. However, it does not explicitly exclude other uses or mention alternatives.

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

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

The annotations are all false (not read-only, etc.), and the description compensates by disclosing rate limits (5 per day), the claim_token flow, that it's free and doesn't count against quota, and that the team reads digests daily. It also clarifies what happens without an account, which goes beyond the structured 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 long but front-loaded and every sentence carries necessary information. It avoids fluff, using precise terminology and concrete examples. The structure flows from purpose to usage to details, making it easy to digest.

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 lack of an output schema, the description explains the main output (claim_token) and its follow-up use. It also covers edge cases (no account, rate limit, cross-server reports) and prerequisites, making the tool safe and predictable for an 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?

The input schema already provides 100% coverage of all four parameters with descriptions. The description adds extra semantic value by explaining the claim_token usage with a concrete example and how it differs from the initial filing, plus clarifying the 'type' enum values with examples. This goes beyond the schema, so a score above baseline is warranted.

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 ('Send') and resource ('Pipeworx Feedback') and immediately clarifies the purpose: reporting bugs, missing features, or praise. It distinguishes from sibling tools by limiting scope to Pipeworx connection tools, and explicitly enumerates what types of feedback are captured.

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 provides explicit use cases ('when a tool returns wrong/stale data', 'when a tool you wish existed isn't in the catalog') and explicit exclusions ('ONLY for tools served by this Pipeworx connection... if the tool came from a different MCP server... file it with that server instead'). This is model guidance at its best, with clear alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds valuable context: data source (CF analytics-engine), privacy (no PII), and caching behavior (5min-1h), with 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 compact yet thorough, using bullet points for use cases and front-loading the core output, with no unnecessary words.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description fully covers what it returns and how it behaves, making it 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 semantic guidance for the window parameter, explaining the trade-off between short and long windows (hot vs steady-state).

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

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

The description clearly states the tool returns top tools, top packs, and total call volume over a window, distinguishing it from sibling tools like discover_tools or ask_pipeworx.

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?

Three specific use cases are listed (discovering hot data sources, confirming popular tool, aligning use case) which provide clear context, though no explicit when-not-to-use or sibling comparison is given.

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

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

Description discloses extensive behavioral details beyond annotations: fill check logic, Jaccard similarity threshold, partition filter for placeholder slugs, response structure (opportunities, partition_check). Annotations already declare readOnlyHint, idempotentHint, and non-destructive nature, and the description adds valuable 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 detailed but dense and unstructured as a single paragraph. It contains many important details but could be more concise and better organized (e.g., using bullet points or sections) to aid quick comprehension.

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

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

Given the tool has no output schema, the description thoroughly describes the response (opportunities array with fields, partition_check details) and covers edge cases (fill check, similarity filter, placeholder filter). It also links to the related fill risk tool for custom sizing, making it 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 already describes both parameters with 100% coverage. The description adds value by explaining accepted input formats (slug or full URL for event; seed question for topic) and briefly describes the behavior for each, enhancing the agent's understanding beyond the schema.

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

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

The description clearly states the tool's purpose as finding arbitrage opportunities via monotonicity violations and partition-sum checks. It distinguishes three modes (no args, event, topic) and explains each, differentiating it from sibling tools like polymarket_edges and polymarket_fill_risk.

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: no args for trending scan, event for specific markets, topic for cross-event scanning. It recommends event mode and explains trade-offs. It lacks explicit exclusion for when to use sibling tools like polymarket_fill_risk, but does mention it for custom sizing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description goes far beyond by detailing the caching strategy (KV level, 1h), the exact scoring methodology per segment, edge calculation including slippage and Kelly fractions, and diagnostics for empty segments. No contradictions found.

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 large paragraph that, while comprehensive, is verbose and lacks structural elements like bullet points or section headers. Every sentence adds value, but the density of technical detail may challenge agent parsing. A more structured format 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?

Given the tool's complexity (9 parameters, no output schema) and the richness of the sibling tools, the description is exceptionally complete. It covers expected response structure (segments, diagnostics, edge fields, 24h warning, Fed note) and explains why certain components are excluded. This compensates fully for the missing output schema.

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

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

Schema coverage is 100% with descriptions for all 9 parameters. The description adds significant value by providing examples (e.g., min_kelly: 0.005 = 0.5% of bankroll), explaining default behaviors, and relating parameters to the methodology (e.g., max_spread_pp and min_liquidity as 'tradeable-edge filters'). This enriches the schema detail.

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 and returns opportunities where Pipeworx data disagrees with market price. It explicitly positions itself for 'what should I bet on today' and distinguishes from siblings by mentioning it doesn't require paging and by structuring output into three segments (model_driven, structural_arbitrage, concentrated_longshot). The purpose is specific and unambiguous.

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

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

The description provides clear context on when to use the tool (discovering opportunities without paging) and explains tradeable-edge knobs like min_liquidity and max_spread_pp. It notes that Fed bets surface but are excluded from ranking. However, it does not explicitly state when not to use it or point to specific sibling alternatives, though the context 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?

The description adds significant behavioral context beyond annotations: limits (60-day TTL, snapshot start date), data source (daily closes not intraday), and detailed response fields. Annotations already indicate readOnly, openWorld, idempotent, and non-destructive, which are consistent.

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

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

The description is structured with purpose, details, and limits, but it is somewhat lengthy. Every sentence adds value, though some rephrasing or condensing could 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?

Given the absence of an output schema, the description thoroughly explains the response structure (tracked[], expired[], snapshot_dates[]) and their subfields. It also covers limitations and edge cases, making it complete for effective use.

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

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

Schema coverage is 100% with descriptions for both parameters. The description mostly reiterates the schema (defaults, allowed values) without adding new semantic info. No contradiction.

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: edge persistence and decay telemetry from daily snapshots. It answers a specific question about edge longevity, distinguishing it from sibling polymarket_edges which likely provides current edges only.

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 implicitly differentiates from polymarket_edges by focusing on historical trends versus current snapshots. It does not explicitly state when to use alternatives, but the distinction is clear given the sibling list.

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, open-world, idempotent, non-destructive. Description adds rich behavioral detail: walks order book ladder, returns fill metrics, and warns about partial basket fills converting arbitrage into directional positions. No contradiction with annotations.

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

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

Somewhat long (10+ lines) but every sentence adds value. Uses uppercase headers for modes. Could be slightly more structured with bullet points, but remains clear and efficient given the complex information.

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

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

No output schema but description enumerates all return fields for both modes (top_of_book, vwap_fill_price, slippage_pp, etc. for single; theoretical_sum, capture_ratio, profit_usd, thin_legs, etc. for basket) and explains risks (thin legs, forced directional risk). Complete for a risk-check tool.

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

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

Schema coverage 100% but description goes beyond: explains default values (side default buy_yes for single, auto for basket; size_usd default 1000), interprets basket size as settlement notional, and states clamp range (10–1,000,000). All parameters are meaningfully elaborated.

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 'Realizable-vs-theoretical edge check against live CLOB order-book depth', specifies two modes (single-market and basket), and distinguishes from sibling tools polymarket_arbitrage and polymarket_edges.

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

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

Explicitly says 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500', explains why (theoretical overround not capturable, partial fills cause directional risk), and specifies required parameter choice between `market` and `event`.

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

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

Annotations already mark the tool as readOnly, openWorld, idempotent, and non-destructive. The description adds substantial behavioral context beyond that: Kalshi fees are not modeled, spreads are gross rather than net, compatibility_warning can be non-empty even with matched_pairs, unclassified legs are never paired, temporal_alignment null means unknown rather than aligned, and pairs are keyword-matched rather than source-verified. This is exactly the kind of edge-case transparency that an agent needs.

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 and dense, but the complexity of the tool justifies it. It is front-loaded with the core purpose, followed by mode selection, response shape, and safety semantics in a logical flow. Some repetition exists around temporal_alignment_unknown and compatibility codes, but the content is almost entirely load-bearing, so it remains appropriate rather than bloated.

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

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

With no output schema, the description carries the full burden of explaining return values and safety semantics. It thoroughly covers top_spreads_pp, flags[], compatibility_warning/codes[], skipped_unclassified, low_confidence_pairs, temporal_alignment, fees_note, and the skipped cross-type/subtype counters. It even warns about the rarity of real cross-venue spreads. Nothing essential for correct invocation or interpretation 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?

The input schema already provides 100% coverage with clear descriptions and examples for topic, kalshi_event_ticker, and polymarket_event_slug. The description adds value by explaining how the parameters select the two modes, that both modes run the identical token-overlap matcher, and that the explicit ticker/slug override the topic-mapped side. This raises it above the baseline 3 for full 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 opens with a specific, unambiguous statement: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It goes beyond a bare noun phrase by explaining the core output (leg-by-leg prices and top_spreads_pp) and clearly distinguishes this tool from sibling Polymarket tools by emphasizing cross-venue comparison rather than single-venue analysis.

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

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

The description gives clear context for both invocation modes: use the 10 pre-mapped topics for shortcuts, or provide explicit kalshi_event_ticker and polymarket_event_slug for custom pairings. It also warns that pre-mapped topics are often not tradeable and that gross spreads should not be treated as real edge. However, it does not explicitly name alternatives among siblings such as polymarket_arbitrage or polymarket_edges, so it lacks explicit when-not-to-use guidance against those tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint false. Description adds value by disclosing scoping to user identifier and the list-all-keys behavior when key is omitted. No contradictions.

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

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

Two sentences, front-loaded with main action, no redundant words. Every sentence adds necessary context.

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 simple tool with one parameter, rich annotations, and no output schema, the description covers purpose, usage, scoping, and pairing. No gaps for an agent to understand invocation.

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

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

Schema coverage is 100% with a clear description for the 'key' parameter. The tool description restates the omit-for-list behavior already in the schema. No additional parameter meaning beyond what schema provides.

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

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

Description clearly states the tool retrieves a saved value or lists all keys when omitted. Verb 'retrieve' and 'list' with resource 'memory key/value' are specific. Distinguishes from sibling tools 'remember' and 'forget'.

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

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

Explicitly describes when to use: to look up previously stored context without re-derivation. Mentions scoping and pairing with 'remember' and 'forget' for alternative actions. No explicit exclusion of other tools, but context is clear.

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

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

Annotations already declare read-only, idempotent, non-destructive. Description adds value by detailing returned fields (source, citation_uri, payload) and mark_read side effect on subsequent calls. No contradictions.

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

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

Two sentences, front-loaded with primary purpose, no filler. Every clause 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?

Covers core use cases (filter, mark_read, polling), describes return fields despite no output schema. Omits mentioning unread_only parameter, but schema describes it. Sufficient for typical use.

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

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

Schema coverage is 100%, but description adds functional context beyond schema fields, e.g., explaining that mark_read ensures 'the next call only shows newer ones'. Redundancy minimal.

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

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

The description states specific verb 'pull' and resource 'fired events from your subscription feed', clearly 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?

Provides explicit filtering options (type, since), explains mark_read effect, and mentions alternative access (URL for scripts/dashboards). Lacks explicit when-not-to-use, but context is clear.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds detailed behavioral context: parallel fan-out to multiple sources, fallback logic, soft-fail for USPTO, and return structure (changes[], total_changes, 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 a single well-organized paragraph that front-loads example queries, then efficiently explains functionality, parameters, return format, and sibling differentiation. There is no wasted text; every sentence contributes essential information.

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

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

Given the tool's complexity (multiple sources, fallback, time windows) and lack of output schema, the description fully covers return values, error handling (soft-fail), parameter semantics, and usage context. It is complete enough for an agent to invoke correctly.

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

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

Schema coverage is 100%, and the description adds significant meaning: it explains the `since` parameter formats (ISO date, relative shorthand), provides example values, and recommends typical usage. It also clarifies that `value` accepts ticker or CIK. This goes beyond the schema descriptions.

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

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

The description clearly states the tool purpose: 'change feed for a company in the last N days/weeks/months in ONE parallel call.' It lists specific data sources (SEC EDGAR, GDELT→GNews, USPTO) and explicitly distinguishes from the sibling 'entity_profile' tool by advising when to use each.

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: it gives example queries, explains fallback behavior (GDELT preferred, GNews when rate-limited), notes USPTO soft-failure, and recommends typical monitoring windows ('30d' or '1m'). It also directs users to 'entity_profile' for static profile needs.

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 a write operation (readOnlyHint=false), idempotent, not destructive. The description adds critical behavioral detail: scoped by identifier, persistence duration (authenticated vs anonymous), and cross-session storage. 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?

Three concise sentences front-load the main purpose, then provide usage context, then storage details. No unnecessary words; every sentence adds distinct 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?

For a simple 2-param write tool with annotations, the description covers purpose, usage, storage semantics, persistence, and links to siblings. It is sufficiently complete for an agent to use correctly without additional clarification.

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 helpful examples for key (e.g., 'subject_property') and clarifies value type ('any text'), adding marginal value. Examples reinforce proper usage.

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

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

Description clearly states the tool saves data for reuse across conversations/sessions. It uses a specific verb ('save') and resource ('data'), and distinguishes itself from siblings by explicitly pairing with recall (retrieve) and forget (delete).

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

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

Explicit guidance on when to use: 'when you discover something worth carrying forward' with concrete examples (ticker, address, preference). It also tells the agent to pair with recall and forget, providing clear alternatives and when-not-to-use context.

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

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

Annotations already mark it read-only, open-world, idempotent, and non-destructive. The description adds substantial behavioral context: ambiguous matches return figi_candidates instead of asserting, unresolved identifiers are explicit, enrichment degrades gracefully, and identifiers are source-labelled.

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 the length is justified by two entity types, multiple identifier sources, and edge-case caveats. The most actionable guidance is front-loaded, though some later detail is dense and could be trimmed without losing essential 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?

With no output schema, the description carries the full burden of explaining results, and it does so thoroughly: ambiguous matches, unresolved fields, source labels, graceful degradation, and the return of RxCUI/ingredient/brand for drugs. An agent has enough context to call 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?

Though schema coverage is 100%, the description adds decisive meaning beyond the schema: company value accepts ticker, CIK, ISIN, or name; drug value accepts brand or generic name; and it warns to pass the bond issuer exactly as printed rather than the full noun phrase. This materially reduces misuse risk.

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

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

The description opens with concrete query examples and states the core action: resolving a user-spoken NAME to canonical/official identifiers. It clearly positions the tool as the input provider for other tools, which distinguishes it from profile/compare 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?

It gives an explicit trigger: 'Use FIRST whenever you have a name but need an ID.' It also defines supported entity types and input forms. However, it does not name alternative tools or state when not to use it, leaving some substitution logic implicit.

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

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

Annotations declare readOnlyHint=true and idempotentHint=true, indicating safe, non-destructive, repeatable behavior. The description adds value by detailing the internal mechanism (probes each entity with ai_visibility_check, ranks by score, surfaces most/least recognized) and the return metrics (score, confidence, signal density). 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 three sentences with no wasted words. It opens with the core purpose, adds procedural detail, and closes with a concrete example use case. Every sentence earns its place.

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

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

For a multi-entity comparison tool without an output schema, the description adequately explains the operation, internal dependency, and return structure (ranked list with metrics). It could be slightly improved by noting the required range of entities (2-8), but that is covered in the parameter schema description.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds only minor clarification about the 'entities' parameter (treats first entry as subject) and repeats schema-level info. It does not elaborate on 'models', '_apiKey', or 'context' beyond what is already in the schema.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, naming the specific action (probe, rank, surface) and giving a concrete use case example. It distinguishes itself from its sibling tool ai_visibility_check (which checks a single entity) and compare_entities (which likely compares general attributes).

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

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

The description implies usage for competitive AI-marketing audits ('does Claude know about us as well as our competitors?') and mentions it uses ai_visibility_check internally. However, it does not explicitly state when to use this tool versus alternatives, nor does it list any conditions where it should not be used.

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

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

Annotations declare safety and idempotency; description adds significant behavioral context: partial failures, bundlephobia timeout, sources_failed field, and graceful degradation. 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?

Dense but well-structured; every sentence adds value. Slightly long but appropriate for a composite tool. Front-loaded key information.

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

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

For a complex composite tool with no output schema, description fully compensates: details return fields, partial failure handling, ecosystem scope, and timeout behavior. Complete for agent decision-making.

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

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

Schema covers both parameters with 100% description. Description adds context about default version behavior and what the composite call returns, enhancing understanding 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?

Clear verb ('scan') and resource ('npm package') with specific composite nature combining deps.dev and bundlephobia. Distinct from sibling tools by focusing on npm ecosystem check in one call.

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: for questions about safety, popularity, size, or cost of adding an npm package. Also clarifies NPM-only and directs to deps.dev:version for other ecosystems.

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 convey read-only, idempotent, and non-destructive behavior. The description adds context about Openverse sourcing and filter capabilities (license, source) but does not disclose pagination behavior, rate limits, or result size limits (page_size parameter).

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

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

Two sentences efficiently convey purpose, filters, and use cases. The first sentence immediately states the core function with example prompts, and the second adds filter and usage context. No redundant information.

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

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

Given 6 parameters with no schema descriptions, the description covers the main purpose and filter capabilities. However, it omits details on pagination (page_size) and exact license values, which would be helpful for full parameter understanding. An output schema exists which likely documents return structure, reducing the need for that in the description.

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

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

With 0% schema description coverage, the description partially compensates by mentioning filter criteria (license, source) and including examples with page, license, and license_type. However, it does not explain page_size, valid license values, or license_type options in detail, leaving ambiguity.

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

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

The description clearly states the tool searches Creative-Commons-licensed audio via Openverse, specifying music, sound effects, and podcast clips. It distinguishes from sibling tools like 'get_audio' (retrieval) and 'audio_related' (related content) by its search-and-filter function.

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 example prompts ('Find royalty-free...') and explicit use cases ('Use for video/podcast/game soundtracks'). It implies when to use (for legally reusable audio) but does not explicitly mention when not to use or contrast with alternatives.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds value by disclosing that it searches multiple open repositories, filters by license and commercial-use, and is a read operation. No contradictions; it enriches behavioral context beyond annotations.

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

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

The description is moderately concise but includes multiple example phrasing and lists, making it slightly verbose. It is front-loaded with purpose but could be tightened without losing clarity.

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

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

Given the output schema exists and annotations are rich, the description covers usage, examples, and filters well. It does not explain return format (unnecessary due to output schema) but sufficiently addresses the tool's behavior and context for an AI 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 description coverage is 71%, so baseline is 3. The description adds some meaning by mentioning filters (license, size, commercial-use) but does not provide new details for all 7 parameters (e.g., source, page). It repeats some schema info without significant depth.

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: finding royalty-free/CC/public-domain images via Openverse. It specifies the verb 'search' and the resource 'Creative-Commons-licensed images across Wikimedia, Flickr, etc.', and distinguishes it from siblings like 'search_audio' and 'get_image' by focusing on legally-reusable images.

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 (e.g., for legally-reusable images for slides, blog posts) and provides example queries. However, it does not explicitly state when not to use it or name alternative tools beyond siblings. The context is clear but lacks direct 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?

Discloses return structure (passages with offsets and similarity scores), embedding method (BGE-base-en, cosine, 500-char windows), and input cap (200K chars with truncation flag). Annotations already indicate safety, but description adds rich behavioral details.

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, focused paragraph with key idea upfront ('Semantic search INSIDE a fetched record'). Every sentence adds value, no redundancy, well-structured.

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

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

Given no output schema, description adequately explains return format (passages with offsets, similarity scores) and behavior (truncation flag). Covers all relevant aspects for agent decision-making.

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

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

Schema coverage is 100% so baseline is 3. Description adds useful context: default limit value (5), range (1-20), and example queries for the query parameter, going beyond schema descriptions.

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

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

Clearly states it performs semantic search inside a fetched record, using action verb 'search' and specific resource 'INSIDE a fetched record'. Distinguishes from siblings like ask_pipeworx_grounded by highlighting its use for large records too big for prompts.

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: 'when the record is too big to cram into the prompt'. Mentions pairing with ask_pipeworx_grounded, implying alternative. Lacks explicit 'do not use' scenarios but provides clear context.

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

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

Annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=true) are consistent and the description adds significant behavioral detail: requires OAuth, delivery channel limits (10/day for SMS), webhook auto-disable after 10 failures, one-time secret. No contradictions.

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

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

Front-loaded with main purpose, then details. Descriptive but not bloated; every sentence adds value. Could be slightly more compact, but still effective.

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 3 parameters (2 required), nested objects, no output schema, the description is very complete: covers return value, account requirements, type-specific parameters, delivery channel options and limitations, edge cases. 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%, and the description adds rich context beyond schema: for type, lists examples and matching logic; for params, gives detailed JSON structures; for delivery, explains behavior like always-on feed, email/SMS/webbook constraints. Significantly enhances 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?

Clearly states the verb 'Create' and resource 'proactive monitoring subscription to a live-data event stream'. Distinguishes from sibling tools like list_subscriptions, unsubscribe, recent_alerts. Also specifies return value: 'Returns the new subscription 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?

Provides clear context on when to use (to subscribe for alerts), with detailed type and parameter guidance. Does not explicitly state when not to use, but mentions requirement for Pipeworx OAuth account (anonymous/BYO cannot persist) which implicitly indicates limitations. Could improve with explicit exclusions.

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

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

Annotations already indicate read-only, open-world, idempotent, non-destructive behavior. The description adds value by detailing that the output includes categorized examples with tool+argument shapes, and explains behavior with/without the 'topic' argument, going 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 well-structured starting with common user queries, then purpose, output format, and usage. It's informative but slightly long; could be trimmed slightly without losing meaning.

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

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

Given the tool's role as an onboarding discovery tool, the description fully covers what it returns, how to invoke it (with/without topic), and its purpose. No output schema exists, but the description adequately explains the output structure.

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

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

Schema coverage is 100% with a single parameter 'topic'. The description adds value by listing possible values ('finance', 'pharma', etc.) and explaining behavior when omitted, enriching beyond the schema's description.

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 specific verb 'returns' and resource 'category-bucketed example questions' with exact tool/argument shapes. It clearly distinguishes from siblings like discover_tools and ask_pipeworx by stating its role as the onboarding entry point.

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

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

Explicitly states 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools'. Provides clear context and implicitly differentiates from other tools by positioning as starting point.

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 (which indicate non-destructive, idempotent behavior), the description adds that the row is deactivated (not deleted) and that historical events remain available via recent_alerts, providing crucial behavioral details.

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, each adding distinct value: purpose, ownership constraint, and persistence behavior. No redundant or extraneous information.

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

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

Given the tool's simplicity (1 required param, no output schema), the description covers all necessary aspects: what it does, who can use it, and the actual effect on data.

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

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

The description does not add meaning beyond the input schema, which already fully describes the 'id' parameter (confirmed by 100% schema coverage). 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 verb 'cancel' and resource 'subscription by id'. It also specifies ownership enforcement and distinguishes the action from deletion, which differentiates it from sibling tools like 'subscribe' and 'list_subscriptions'.

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

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

The description explicitly states that ownership is enforced (you can only cancel your own subscriptions), providing clear context for when the tool is applicable. However, it does not mention when not to use it or suggest 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 readOnly, openWorld, idempotent, non-destructive behavior. The description goes further by explaining the two pipelines (structured fast path with percent-delta math vs grounded fallback), the exact verdict vocabulary, and the crucial distinction between could_not_verify (verification_error, no evidence) and unsupported (no source). This adds substantial behavioral context 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 long but every sentence earns its place: user-facing trigger phrases, scope, routing logic, return value specification, and an IMPORTANT caller warning about could_not_verify. It is structured with clear paragraphs and front-loaded with the most recognizable query patterns. 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?

There is no output schema, so the description fully carries the burden of explaining return values. It lists all verdicts, mentions the grounded/structured value with citation, explains the meaning of error-prone outcomes (could_not_verify, unsupported), and covers the routing behavior. For a tool of this complexity, this 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 description coverage is 100%, with both parameters (claim and tolerance_pct) already documented in detail, including examples for claim and the range/default behavior for tolerance_pct. The main description adds example claim strings but does not elaborate further on parameter semantics, so it stays at the baseline 3 as the schema does the heavy lifting.

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 natural-language example queries ("Is it true that…", "fact check") and defines the tool as "natural-language claim verification against authoritative sources." It clearly states the action (verify), the resource (authoritative sources), and the two routing paths (SEC EDGAR/XBRL for financial claims vs grounded pipeline for others), which distinguishes it from sibling tools like ask_pipeworx.

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

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

The description explicitly states when to use: "Use whenever the agent needs to check whether something a user said is factually correct." It also explains the automatic routing for different claim types and notes that the tool replaces 4–6 sequential calls, providing a clear use-case rationale. While it doesn't name alternative tools, the trigger condition is explicit and unambiguous.

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