Clevelandart

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

Annotations already indicate readOnlyHint, idempotentHint, and openWorldHint. The description adds that it scores visibility per model, returns raw responses, and notes cost implications (BYO key for Anthropic). It does not contradict 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, focused paragraph that immediately states the core action. It is concise with no unnecessary words, and the key information is front-loaded.

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

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

Despite lacking an output schema, the description explains the return structure: 'per-model {score, confidence, signals, raw_response} + a combined view'. It covers all parameters and use cases, making it complete for a tool of moderate complexity.

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

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

Schema coverage is 100%, so parameters are well-described in the schema. The description reinforces parameter meanings (e.g., 'entity' as the thing to ask about, '_apiKey' for Anthropic) but does not add significant new semantics.

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 entity awareness and scores visibility (0-100). It specifies the verb 'probe', the resource 'LLMs', and the output: per-model scores. It distinguishes from siblings like 'scan_competitor_ai_presence' by focusing on multi-model scoring and mentions use cases.

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

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

The description provides context for when to use: 'AI-marketing audits, pre-launch brand checks, competitive monitoring'. It mentions default model and optional Anthropic key. However, it does not explicitly state when not to use it or compare to alternatives like 'ask_pipeworx'.

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, and not destructive. The description adds useful behavioral context by explaining that it routes to many underlying tools, fills arguments, and returns structured answers with stable pipeworx:// 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 verbose with promotional phrases like 'PREFER OVER WEB SEARCH' and 'START HERE', but it is well structured and every section adds routing guidance, examples, or alternative tool comparisons. It is longer than necessary but not unfocused.

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 adequately explains the output: 'returns the structured answer with stable pipeworx:// citation URIs.' It also covers example questions, alias handling, and when to step up to other tools, providing enough context for an agent to use it effectively.

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 primary parameter 'question' is well described, including its natural-language usage and accepted aliases. The alias parameters (q, text, input, query, prompt) each have descriptions clarifying they are aliases, which adds value beyond the raw 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 identifies the tool as a general-purpose factual question router: 'Routes the question to the right one of 5,801 tools across 1517 verified sources' and gives concrete examples. It also distinguishes itself from sibling tools like ask_pipeworx_grounded and deep_research.

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

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

The description explicitly says to prefer this tool over web search for factual questions and lists the exact conditions under which alternatives should be used: ask_pipeworx_grounded for hallucination-resistant answers, deep_research for broad/multi-part questions. This leaves little ambiguity about when to select this tool.

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

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

Annotations already cover readOnly, idempotent, and non-destructive behavior. The description adds useful context: it is a full working router, falls back to nothing, and currently matches ask_pipeworx exactly because no candidate is active. It doesn't elaborate on potential differences when a candidate is under test, but the beta nature is implicit.

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

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

The description is moderately long but each sentence adds value: it explains beta status, current state, usage guidance, and comparison with the stable router. There is minimal redundancy and no fluff, so it is appropriately sized for the information it conveys.

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

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

The description relies on knowledge of ask_pipeworx, but that is a sibling tool and the pointer 'Use it exactly like ask_pipeworx' is sufficient for an agent that has access to the sibling. It also provides additional context like the number of tools (5,801) and the explicit mention that it's a full working router, making it complete enough for its intended use as a beta alternative.

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 explicitly states that all six parameters (query, q, prompt, text, input, question) are aliases for 'question', and the main parameter description says 'Your question or request in natural language. Accepts query, q, prompt, text, input as aliases.' This fully clarifies the semantics of every parameter, leaving no 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 this is a beta version of ask_pipeworx, a universal router, and explains its role as an experimental variant for testing candidate routing. It mentions it is identical to ask_pipeworx and currently matches it exactly, which clarifies its purpose as an alternative router, though it doesn't explicitly say 'answers questions by routing to tools'.

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

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

The description provides explicit when-to-use guidance: 'Use it exactly like ask_pipeworx when you want the newest routing' and explains that results are compared against the stable router to decide merges. This gives a clear condition for selecting this tool over the stable version, though it doesn't mention when NOT to use it (e.g., when stability is preferred).

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 already cover readOnly, idempotent, and non-destructive behavior, so the description doesn't need to add side-effect information. It does describe the output format (answer with evidence, refusal reasons) which adds some behavioral transparency beyond the annotations, but not significantly more than the baseline.

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 verbose and repetitive, repeating the routing and extraction process twice and listing refusal reasons redundantly. While it is structured in three sentences, the redundancy makes it less concise than necessary, and it could be streamlined to focus on the key differentiator of groundedness.

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 provides sufficient context for the tool: it explains the high-stakes usage scenario, the output format including evidence and refusal reasons, and the condition under which to use it. Given the simplicity of the tool (single required parameter) and lack of output schema, this description is complete enough for an agent to use it correctly.

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

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

The schema already provides 100% coverage with parameter descriptions and aliases. The description adds no extra semantic meaning beyond what is already in the input schema, so it meets the baseline but does not exceed it.

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

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

The description clearly states the tool's purpose as a 'hallucination-resistant answer mode' that extracts answers only from tool results. It specifies that it is for high-stakes reads and explicitly differentiates it from the standard ask_pipeworx tool, leaving no ambiguity about what it does.

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 tells when to use this tool: 'Use whenever an answer will be quoted, cited, or acted on' and when not to use it: 'prefer ask_pipeworx for casual lookups.' This provides clear, actionable guidance on selecting between the two similar 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?

The description adds extensive behavioral context beyond annotations: it details fan-out logic, response shapes (market, analysis, evidence), resolver contract (confidence levels, suggestions), safety mechanisms (low-confidence suppression, closed market handling), and resolution-rule risk. Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, which are not contradicted.

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 very long and detailed, which provides thorough information but at the cost of conciseness. It is well-structured with labeled sections, but the verbosity may overwhelm an AI agent scanning for key facts.

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

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

Despite lacking an output schema, the description comprehensively explains all response fields (market, analysis, evidence, resolver contract, parent_event, news fields, safety guards, resolution rules). It covers edge cases (closed markets, wide spreads, rate limits) and provides actionable guidance.

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 covers all 3 parameters with descriptions and examples. The description further clarifies parameter semantics (e.g., market can be slug/URL/text, depth enum behavior, include_raw impact on response size), adding moderate value beyond the schema.

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

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

The description clearly states the verb ('Research') and resource ('a Polymarket bet') with specific actions (pulling Pipeworx data, resolving, classifying, fanning out). It distinguishes from siblings by being tailored to Polymarket bet research, while siblings like ask_pipeworx are for general Q&A.

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

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

The description explicitly lists use cases ('should I bet on X', etc.), providing clear context for when to invoke. However, it does not explicitly mention when not to use this tool versus alternatives like polymarket_edges.

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

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

Annotations already declare read-only, open-world, idempotent. Description adds details: pulls latest 10-K data from SEC EDGAR/XBRL with correct fiscal year handling, FAERS data for drugs, sorted results, citation URIs. 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?

Description is a single dense paragraph that packs a lot of information efficiently. It could be slightly more structured for scanning, but every sentence adds value and it is appropriately sized.

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

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

Despite no output schema, description explains return format (paired data + citation URIs), sorting behavior, and handles edge cases (off-calendar fiscal years). All relevant aspects are covered for a 2-parameter tool.

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

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

Schema coverage is 100%, but description adds meaning beyond enum values: explains that 'values' should be tickers/CIKs for companies or drug names, and provides examples. This clarifies parameter semantics effectively.

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

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

Description uses specific verbs ('compare', 'side-by-side comparison') and clearly identifies resources (companies or drugs). It distinguishes from sequential lookups and includes trigger phrases that help an agent recognize when to use this tool.

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

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

Explicitly states 'ALWAYS PREFER over sequential single-pack lookups when comparing entities', providing clear when-to-use guidance. It also includes example queries that indicate context of use.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive. The description adds return fields and scope (CMA collection), which is useful but not rich behavioral detail like pagination or matching semantics. 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, front-loaded with purpose and returns. The third sentence slightly repeats earlier points, but overall it is efficient and every sentence adds value.

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

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

Given the output schema and rich annotations, the description adequately covers purpose, return fields, and search semantics. Minor gap: the example with 'abstract' suggests query may not always be a name, but the description only mentions name matching, creating slight ambiguity.

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 explicitly says 'by name', giving meaning to the query parameter which lacks a schema description. The limit parameter is already described in the schema. Thus the description compensates for the 50% schema coverage and clarifies the key 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 clearly states it searches creator records by name, returns specific fields (id, name, role, dates, nationality), and answers which artists match a name. This distinguishes it from sibling tools like get_artwork or exhibitions, which focus on different resources.

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: it is for searching creator/artist records in the CMA collection by name. It does not explicitly exclude alternatives or name sibling tools, but the context is unambiguous enough that an agent would know when 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?

Beyond the readOnly/openWorld/idempotent annotations, the description discloses substantial behavioral traits: non-open-web scope, parallel facet decomposition, gap-recovery and iterative hops, contradictions scanning, citation fetchability, semantic excerpting, expected latency, and paid depth tier. No annotation contradiction exists.

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

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

The description is front-loaded and well organized, but it contains noticeable redundancy, repeating the decompose/route/return packet idea twice and restating the ask_pipeworx comparison in multiple places. It could be tightened without losing key information.

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

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

Despite having no output schema, the description thoroughly explains the returned findings packet fields (evidence, confidence, source, fetched_at, citation_uri, hop, contradictions, gaps), covers multi-step behavior, limitations, timing, and account requirements. There are no significant missing contextual details for correct invocation.

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

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

Although the schema already describes both parameters, the description adds meaningful depth semantics: quick=3 single-hop, standard=3 default with gap recovery plus contradictions, thorough=6 paid with iterative lead-chasing. It also clarifies that broad/multi-part questions are appropriate, enriching the schema's natural-language guidance.

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 action ('grounded multi-source research across Pipeworx's 1517 STRUCTURED data sources') and clearly distinguishes it from open-web search and from ask_pipeworx. It names the sibling tool it is not, making selection 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?

Explicit guidance is given for when to use this tool vs alternatives: best for broad/multi-part structured-data questions; use ask_pipeworx for single lookups and for breaking/news topics. The account-required caveat and fallback to ask_pipeworx further clarify the appropriate invocation 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 indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds that the tool returns top-N tools with full schemas and curated examples, ready to call directly without a second lookup. No contradiction and no additional behavioral concerns need flagging.

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 front-loaded with a clear purpose statement and includes examples and output details in 4 sentences. Each sentence earns its place. Minor redundancy in mentioning aliases (already documented in schema) but does not significantly detract from 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?

The tool has 6 parameters (mostly aliases) and no output schema. Description covers input format (natural language query), output format (top-N tools with names, descriptions, full input schemas, curated examples), and usage context. All necessary information for an agent to correctly invoke the tool is provided.

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

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

Input schema has 100% description coverage for all 6 parameters, including aliases and limit. Description does not add meaning beyond what the schema provides; it merely restates the alias pattern. Baseline 3 is appropriate 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?

Description uses specific verb 'Find tools by describing', lists covered domains (SEC filings, FDA drugs, etc.), and explicitly states it returns top-N relevant tools with schemas. It distinguishes from siblings by instructing to call this FIRST when exploring options, clearly differentiating its discovery purpose from other tools that perform specific tasks.

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

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

Provides explicit usage context: 'Use when you need to browse, search, look up, or discover what tools exist for' followed by domain examples. Also includes guidance to 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' Does not describe when not to use, but the context is clear enough for an agent to decide.

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

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

Even though annotations already indicate readOnly/idempotent/non-destructive behavior, the description adds substantial context: fan-out across many sources, USPTO patents soft-failing after sunset, FDA results expected empty for small-molecule-only companies, GDELT→GNews fallback, source-level success/failure reporting, and resolved:false behavior for private companies. Nothing contradicts 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 information-dense: every sentence carries a distinct constraint, fallback, or output detail. It is front-loaded with purpose and usage examples, and source-specific caveats are grouped cleanly. Minor verbosity in the output enumeration prevents a 5.

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

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

For a tool with no output schema and many external sources, the description is remarkably complete. It enumerates return fields, explains why empty sections are expected in specific cases, documents source failures, and includes URI examples. An agent has enough context to call it correctly and interpret normal and edge-case results.

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

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

Schema coverage is 100%, so the schema already documents both parameters and their accepted shapes. The description largely repeats what the schema says about ticker/CIK/name and the interchangeable type values; it adds execution examples but not much new parameter-level semantics. A 3 reflects the high baseline set by 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 is explicit: it produces a 'full cross-source profile of a US public company in ONE parallel call' and gives several concrete user-intent examples ('Tell me about X', 'research Acme', 'brief me on Tesla'). It also distinguishes itself from chaining single-pack SEC/XBRL/news lookups, making its scope and value clear relative to sibling tools.

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

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

The description provides direct triggering examples and a categorical rule: 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view.' It also states accepted input forms (ticker, CIK, company name) and how private companies are handled, so the agent knows both when to use it and what to expect.

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 behavioral details beyond the annotations: it specifies the return fields (CMA id, title, opening/closing dates, venue) and the scope of coverage ('shows mounted at and organized by the museum'). This complements the readOnlyHint and idempotentHint annotations without contradicting them.

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

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

The description is three sentences, front-loaded with the core purpose, and each sentence adds value: what it does, what it returns, and what question it answers. No redundant or filler content.

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

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

Given the simple 2-parameter schema, comprehensive annotations, and presence of an output schema, the description adequately covers the tool's purpose, scope, and return format. The lack of pagination or sorting details is acceptable because the schema and output schema handle such specifics.

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?

Only the 'limit' parameter has schema description; 'query' lacks one. The description compensates by explicitly stating the search is by 'title keyword', clarifying the meaning of 'query'. With 50% schema coverage, this partial compensation is sufficient, though not exhaustive.

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 the Cleveland Museum of Art's exhibition history by title keyword, and specifies the exact question it answers ('whether the Cleveland Museum of Art has shown an exhibition on a subject, and when it ran'). This distinguishes it from siblings like search or get_artwork by narrowing the scope to exhibitions and the museum.

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

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

The description provides clear context for when to use the tool: searching exhibition history at a specific museum by keyword. It does not explicitly name alternative tools or exclusionary conditions, but the scope is well-defined enough that an agent can infer appropriate use cases. No explicit 'when not to use' guidance 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?

Annotations already convey destructiveHint=true and idempotentHint=true. The description adds minimal context beyond stating it deletes a memory, which is consistent. No contradiction, but limited added value.

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

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

The description is extremely concise with two sentences—one for purpose and one for usage guidance. No wasted words, efficient and clear.

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

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

For a simple tool with one parameter, no output schema, and adequate annotations, the description covers the purpose, usage context, and relationship to siblings completely.

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 the parameter 'key' described as 'Memory key to delete'. The description does not add additional semantics beyond what the schema already provides, so baseline score 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 action ('Delete a previously stored memory by key') with a specific verb and resource. It distinguishes from sibling tools 'remember' and 'recall', making its purpose 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?

Provides explicit when-to-use scenarios: stale context, task completion, clearing sensitive data. Also references pairing with remember and recall. Lacks explicit when-not-to-use, but the positive guidance is strong.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive. Description adds concrete behavior: fetches page, extracts content, emits standard markdown. No contradictions. Provides moderate additional context beyond annotations.

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

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

Two sentences with no waste. First sentence front-loads purpose and output format; second sentence lists use cases. Efficient and 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?

Despite no output schema, description explains return format as a text blob. Two parameters with full schema coverage, no nested objects. Complete enough for the tool's complexity.

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

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

Schema coverage is 100% and descriptions are already in the schema. Description only adds implicit context (e.g., default/max for max_links is already in schema). No extra meaning beyond what schema provides; 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 the tool generates a production-ready llms.txt file for any URL, explains the process, and lists specific use cases. It uniquely describes its function, distinguishing it from sibling tools like scan_competitor_ai_presence.

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 three explicit use cases (client indexing, own project, competitor auditing) but does not mention when not to use or alternatives. Clear context, no 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 declare readOnlyHint, openWorldHint, idempotentHint true and destructiveHint false. The description adds minimal behavioral context beyond the identifier format, but does not contradict 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?

Extremely concise single sentence that front-loads the key information. 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 lookup tool with rich annotations and output schema, the description is complete. It covers the essential usage pattern.

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 examples. The description adds minor clarification on identifier formats, but does not significantly extend 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 retrieves a single artwork using an identifier (accession number or numeric id). It is specific and distinguishes from sibling tools like search or entity_profile.

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

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

The description implies usage when a specific artwork identifier is known, but does not explicitly state when to use or avoid this tool vs alternatives. No exclusions or when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the agent knows this is a safe, non-destructive read. The description adds behavioral context by specifying that only active subscriptions are listed by default and listing the exact return fields, which is helpful but not essential given 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 consists of two sentences that are front-loaded with the core functionality and return fields. It is concise and every sentence provides value.

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

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

Given the tool's simplicity (one optional parameter, excellent annotations, no output schema needed because return fields are listed), the description is complete. It covers purpose, return fields, and usage hints without leaving 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% (one boolean parameter with description). The description does not add any additional semantic information about the 'include_inactive' parameter beyond what the schema already provides. Baseline is 3 due to high coverage.

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

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

The description clearly states it lists the caller's active subscriptions and enumerates the return fields (id, type, params, created_at, last_fired_at, fire_count). This distinguishes it from sibling tools like 'subscribe' and 'unsubscribe'.

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

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

The description provides context on when to use: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' It clearly recommends using this before adding a subscription or to find an id for unsubscription, though it doesn't explicitly mention 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?

The description discloses rate limiting ('5 per identifier per day'), free/quota behavior, the claim_token workflow, and that the team reads digests daily. These behaviors go well beyond the annotations, which only say the operation is not read-only/idempotent/destructive. No contradiction exists.

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

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

The description is lengthy but dense, with every sentence serving a purpose: purpose, scope limits, token workflow, rate limits, and quota clarification. It is front-loaded with purpose and usage. It loses one point for being slightly sprawling, but it remains highly informative.

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 four parameters, nested objects, and no output schema, the description carries heavy responsibility. It fully compensates by explaining the return token, rate limits, pairing scope, and what should/shouldn't be included. It is complete for an agent to decide when and how to invoke this tool.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds workflow meaning beyond the schema: it explains how to use claim_token later to read status, instructs users not to paste end-user prompts, and clarifies the 'other' type via the enum descriptions. This elevates the contribution.

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

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

The description opens with a specific verb and resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It clearly distinguishes this tool from siblings like ask_pipeworx or search by framing it as a feedback/reporting channel for Pipeworx tools specifically.

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 when-to-use guidance is provided for bug, feature/data_gap, and praise cases. It also gives a clear exclusion: only for tools served by this Pipeworx connection, and tells users to file elsewhere for other MCP servers. This is exemplary usage guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint. Description adds caching behavior (5min-1h), data source (CF analytics-engine), and privacy (no PII), which are valuable 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?

Description is three sentences plus a bullet list, all front-loaded. Every sentence adds information—no redundancy or filler 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 read-only analytics tool, the description covers its function, parameters, caching, and privacy. Lacks output schema details (e.g., structure of top tools/packs), but is still adequate given simplicity.

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

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

Schema covers 100% with enum and description. Description adds semantic guidance: 'Shorter windows surface what's hot right now; longer windows show steady-state demand,' enhancing the parameter's meaning.

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

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

The description states it returns 'top tools, top packs, and total call volume over a recent window,' using specific verb–resource mapping. It distinguishes from sibling tools like ask_pipeworx and discover_tools by focusing on trending analytics rather than direct Q&A or general discovery.

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

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

Explicitly lists three use cases (hot data sources, canonical tool confirmation, alignment check). While no 'when not to use' is given, the clarity of use cases combined with sibling context provides adequate guidance.

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

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

Annotations indicate read-only, idempotent, and non-destructive behavior. The description exceeds this by detailing behavioral traits such as partition checks, semantic anchor for similarity, partition filters, fill check with realizable edge, and the response structure. 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 thorough but slightly verbose. It is well-structured, starting with the main purpose and then detailing each mode. While every sentence adds value, it could be trimmed slightly without losing information. Front-loaded with 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?

Despite no output schema, the description thoroughly explains the response fields: opportunities array, partition_check object, fill_check details. It also references a sibling tool for custom sizing (polymarket_fill_risk). For a complex arbitrage detection tool, the description is complete and actionable.

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 described. The description adds significant meaning beyond the schema, explaining the difference between 'event' (single-event mode) and 'topic' (cross-event mode), and provides examples of valid inputs. It also describes how each mode works and what to expect.

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 arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' It distinguishes itself from sibling tools like polymarket_edges by specifying its unique detection methods. The verb 'find' and resource 'arbitrage opportunities' are 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 explicit guidance on when to use each parameter: 'Call with NO args for a trending_scan... pass event for... or topic for...' It recommends event mode for specific markets and explains the differences. However, it does not compare this tool to siblings like polymarket_edges, which could help agents choose between them.

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

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

Annotations provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint false. The description adds extensive behavioral context: details on three model families, diagnostics, caching, and what segments exist. No contradictions with annotations.

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

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

The description is long and dense with technical details (e.g., Greek letters, specific thresholds). While front-loaded with purpose, it could be more concise. Every sentence adds value but the volume is high.

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 rich annotations, the description is very complete. It covers what each segment returns, diagnostics, caching behavior, and edge cases like Fed bets. Provides all needed context for optimal 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%, so baseline 3. The description explains high-level knobs like 'tradeable-edge filters' and adds context for parameters like min_partition_leg_kelly that goes beyond schema descriptions. However, it doesn't systematically cover each 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 clearly states the tool scans Polymarket markets and returns opportunities where Pipeworx data disagrees with market price. It uses a specific verb ('scan', 'return') and resource ('Polymarket markets'), and distinguishes from siblings like polymarket_arbitrage by focusing on disagreement with external data.

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 it's built for 'what should I bet on today' and helps agents discover without paging hundreds of markets. It mentions knobs and filters but lacks explicit comparisons to sibling tools or when-not-to-use scenarios.

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

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

Annotations already indicate read-only, idempotent, non-destructive. Description adds extensive behavioral context: 60-day snapshot TTL, snapshot dates depend on cache-miss, response structure (tracked, expired, snapshot_dates), edge_pp_net sign convention, and decay computation. 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?

Description is front-loaded with purpose, then structured response details and limitations. Every sentence adds value, but some implementation details ('snapshots are written when polymarket_edges runs on a cache-miss') could be condensed without loss.

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, description thoroughly explains return values (tracked, expired, snapshot_dates) and limitations (TTL, decay computation). All aspects are covered 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 description coverage is 100%, so baseline is 3. Description adds minimal extra: for 'days' it mentions max 30 (schema says clamp 2-30), for 'window' it lists examples matching schema. Does not significantly enhance 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?

Description clearly states the tool's purpose: 'Edge persistence and decay telemetry' answering 'how long has this edge existed and is it shrinking?' It specifies the resource (edges from polymarket_edges snapshots) and distinguishes from sibling polymarket_edges by focusing on historical time-series rather than current snapshot.

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

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

Description provides context for when to use: 'a fresh wide edge and a 3-week-old wide edge are different trades'. It implies usage for historical persistence analysis but does not explicitly mention when not to use or compare to alternatives like polymarket_edges or polymarket_arbitrage.

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, idempotentHint) are consistent with a read-only check. Description adds rich behavioral context: warns about partial basket fills converting arb into unhedged directional position (dominant loss mode), details output fields like forced_directional_risk. 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 dense and informative, front-loaded with main purpose. However, it is long and could be better structured with clearer paragraph separation for modes. Every sentence earns its place, but a slight loss for length.

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

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

Given no output schema, the description provides comprehensive return field details for both modes, including edge cases (thin_legs, forced_directional_risk) and explains the 'verdict' field. It fully covers the tool's behavior and usage context.

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

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

Schema coverage is 100%, but description adds significant meaning beyond schema: explains size_usd interpretation for single vs basket, side defaults and auto-detection, event for basket mode, market for single mode. Also documents output structure in detail, compensating for missing output 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 checks realizable vs theoretical edge against live order book depth. It distinguishes single-market and basket modes with specific verbs ('walks the ladder', 'returns top_of_book, vwap_fill_price') and is different from sibling tools like polymarket_arbitrage or 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 states 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500' and explains why partial fills cause directional risk. Clear context on when to use and what alternatives (polymarket_arbitrage, polymarket_edges) exist.

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 reveals extensive behavioral caveats: compatibility_codes semantics, temporal alignment unknowns, gross vs net spread, unpaired/unsclassified legs, skipped counters, and the explicit statement that pairing is keyword-based rather than verified by a shared resolution source. This is far more than annotations alone provide and sets clear expectations about result reliability.

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 it is well-structured with clear sections (modes, response, safety fields, fees note, skipped counters) and front-loads the core purpose. Every sentence contributes meaningful operational or safety information rather than filler, though the density could be trimmed without losing critical caveats.

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

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

There is no output schema, so the description carries the full burden of explaining return semantics. It thoroughly covers response contents, compatibility codes, temporal alignment, fees, skipped comparisons, confidence flags, and the meaning of null alignment. The operational context is complete enough for an agent to invoke the tool and interpret results 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 input schema already documents all three parameters with 100% coverage, so the baseline is already solid. The description adds valuable parameter semantics by explaining the topic mode's ten pre-mapped shortcuts, clarifying that explicit ticker/slug overrides replace the topic-mapped side, and stating that both modes run the same matcher. This goes beyond the schema's field-level 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 opens with a specific verb and resource: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It clearly distinguishes this tool from related siblings like polymarket_arbitrage and polymarket_edges by centering on the Kalshi–Polymarket comparison and the token-overlap matching semantics.

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 by defining two explicit modes — topic shortcuts vs explicit kalshi_event_ticker + polymarket_event_slug — and notes that both modes behave identically. It also gives practical guidance that pre-mapped topics are not necessarily tradeable and that compatibility warnings should be read. However, it does not explicitly contrast this tool against sibling alternatives for when to choose it instead of them.

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

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

Annotations already cover read-only, idempotent, non-destructive nature. Description adds scoping by identifier and behavior of omitting key to list all, which is valuable context.

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

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

Three concise sentences that are front-loaded with main action, then provide examples and relationship to siblings. No wasted words.

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

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

Given one optional parameter, no output schema, and annotations covering safety, the description fully explains behavior, scoping, and sibling context.

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

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

Schema coverage is 100%, so baseline 3. Description adds meaning by explaining the two modes (retrieve vs list) and the origin of saved values ('via remember').

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

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

Clearly states the tool retrieves a saved value or lists all keys. Mentions pairing with 'remember' and 'forget' siblings, distinguishing 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?

Provides explicit use cases (look up ticker, address, notes) and pairs with sibling tools. Lacks explicit when-not-to-use guidance, but usage context is clear.

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

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

The description describes setting mark_read:true to flag events as read, which implies a state change. However, the annotations declare readOnlyHint:true and destructiveHint:false, creating a contradiction. According to guidelines, this yields a score of 1.

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

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

The description is four well-structured sentences. The first sentence states the purpose, followed by return fields, filtering options, and special behavior. Every sentence adds essential information without redundancy or verbosity.

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 five optional parameters, no output schema, and use case (polling for alerts), the description covers all key aspects: purpose, return fields, filtering, mark_read effect, and an alternative access endpoint. It lacks explicit mention of pagination or error handling but is sufficiently complete for this context.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by specifying return fields (source, citation_uri, raw event payload), giving an example filter value ('sec_8k'), clarifying that 'since' expects an ISO timestamp, and explaining the effect of 'mark_read'. This exceeds 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 uses specific verbs ('Pull fired events from your subscription feed') and clearly states the resource (recent alerts) and the action. It distinguishes this tool from siblings like 'list_subscriptions' by focusing on 'recent alerts' specific to subscription feed events.

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

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

The description provides clear usage context: it's for pulling the most recent alerts from a subscription feed, with optional filtering by type and since timestamp. It mentions mark_read behavior and confirms polling works. However, it does not explicitly state when not to use it or name alternatives 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?

Discloses multi-source fan-out (SEC, GDELT→GNews fallback, USPTO soft-fail), return structure (changes[] grouped by source, total_changes, citation URIs), and rate-limiting fallback. Complements annotations (readOnly, idempotent) with operational 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 paragraph packs examples, behavior, parameter details, and alternative tool. Slightly dense but well-organized with front-loaded examples.

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

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

Despite no output schema, description adequately explains return shape. Covers all parameters, fallbacks, and soft-fail scenarios. No gaps for 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?

Adds significant value beyond schema: 'since' parameter explained with examples ('2026-04-01', '7d', '30d') and recommendation '30d' or '1m'. 'value' clarifies ticker or CIK. 'type' notes only 'company' supported.

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

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

Description opens with clear query examples ('What's new with X') and states 'change feed for a company in the last N days...'. It distinguishes from sibling entity_profile for static profiles. Verb and resource are specific.

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 entity_profile instead when you want the static profile', providing clear alternative. Also implies usage for temporal monitoring vs static retrieval.

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 idempotent and non-destructive behavior. Description adds useful context about key-value pairs being scoped by identifier and session duration (24h for anonymous), which annotations do not cover.

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

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

Description is concise, well-structured, and front-loaded with purpose, then usage, then behavioral details. Every sentence adds value.

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

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

Completely covers storage behavior, persistence, pairing with other tools, and typical use cases. No output schema exists, but the tool's effect is adequately explained.

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 provides descriptions with examples for both parameters. Description reinforces meaning but adds little new information beyond what is in the input schema.

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

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

Description clearly states the tool saves data for reuse, gives concrete examples (tickers, addresses, preferences), and distinguishes from sibling tools recall and forget.

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

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

Explicitly says when to use (discover something worth carrying forward) and mentions alternatives (recall, forget), but does not explicitly state when not to use.

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

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

Annotations already establish read-only, idempotent, and non-destructive behavior, and the description adds substantial context: internal cascading lookups, graceful degradation when GLEIF/OpenFIGI are unavailable, explicit `unresolved` reporting, and returning `figi_candidates` instead of asserting an ambiguous match. This far exceeds annotation-only 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 front-loaded with examples and the core purpose, then organized by supported entity type with operational caveats. It is long, but nearly every sentence carries practical value; only minor redundancy keeps it from a 5.

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 covers resolution behavior, ambiguity handling, unresolved fields, degradation, input variants, and identifier provenance. An agent receives enough context to both invoke the tool correctly and interpret its likely outcomes.

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 covers both parameters, but the description adds crucial semantics: accepted input forms for company (ticker, CIK, ISIN, or name), drug examples, and the important constraint to pass only the entity name, not the full noun phrase. This materially prevents incorrect invocations.

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: resolve user-spoken names to canonical/official identifiers that other tools require as input. It also distinguishes itself from siblings by explicitly framing its role as the name-to-ID gateway, rather than a profile or search tool.

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

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

It gives explicit guidance: 'Use FIRST whenever you have a name but need an ID,' and enumerates example user phrasings that trigger the tool. It does not name sibling alternatives or state when not to use it, so it stops short of a complete when/when-not specification.

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, openWorldHint. The description adds specific behavioral details: probes each entity, ranks by score, returns confidence and signal density. Does not mention API key requirements or potential latency, but overall adds value beyond annotations.

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

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

Two sentences plus an example. Front-loaded with the main purpose. Every sentence adds value without redundancy.

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

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

With no output schema, the description partially explains the output (ranked list with score, confidence, signal density). It covers the core functionality but doesn't detail error handling or exact output structure. Given the annotations, it is fairly complete.

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

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

Schema has 100% coverage, but the description adds that the first entry in entities is treated as the 'subject' for narrative, and that models can be omitted for default. This provides context 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 verb 'compare' and resource 'AI visibility' are specific and clear. The distinction from sibling ai_visibility_check (single entity) is implied by 'across multiple entities'. The example question reinforces the competitive audit use case.

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

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

States it's useful for competitive AI-marketing audits, with a concrete example. Does not explicitly say when not to use or name alternatives, but the context is clear enough for selecting this tool over a single-entity check.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description adds behavioral details: partial failures degrade gracefully, bundlephobia first measurement can take 5-30s, and sources_failed lists timeouts.

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 somewhat long (4 sentences) but each sentence adds valuable information. Front-loaded with core purpose, then usage, then behavior. Minor redundancy could be trimmed, but overall efficient.

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

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

Given no output schema, the description adequately explains return values (summary block, advisories, links, alternatives), timing, and error handling. Covers all necessary context for a composite tool.

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

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

Schema coverage is 100% (both parameters described). Description adds value by mentioning scoped packages accepted and default version behavior, going beyond the schema's basic 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 a specific verb+resource ('composite check for adding npm package') and distinguishes from siblings by noting NPM-only scope and mentioning alternative tools for other ecosystems.

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

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

Explicit usage guidance: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me".' Also clarifies NPM-only scope and fallback for other ecosystems, providing clear when-to-use and when-not-to-use.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the tool's safety is clear. The description adds that filters are optional, which is useful but not essential behavioral context.

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

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

The description is a single short sentence that front-loads the core action and lists filters. Every word is meaningful 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?

While there is an output schema, the description omits important parameters like 'query' and pagination (skip, limit). It covers only a subset of filters, leaving out core search functionality. More detail would improve completeness.

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

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

Schema description coverage is 86%, so the schema already documents parameters well. The description only lists some filters (type, artist, has_image, cc0) without adding new meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'Search' and the resource 'artworks', listing optional filters. It distinguishes its purpose from sibling tools like 'search_within' by focusing on artworks.

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

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

The description mentions optional filters but provides no guidance on when to use this tool versus alternatives like 'search_within' or other search tools. No exclusions or context are 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?

The description goes beyond annotations by detailing the embedding model (BGE-base-en), scoring method (cosine), window size (500-char overlapping), character cap (200K), and truncation behavior. No contradiction with annotations (all safe hints).

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

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

Single, well-structured paragraph with key information front-loaded. Every sentence adds value without redundancy.

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

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

For a simple tool with no output schema, the description covers input constraints, output format (passages with offsets and scores), and practical use case. Pairs well with sibling tool. Complete for an agent to use correctly.

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

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

Schema coverage is 100% with good descriptions. The description adds extra context (e.g., 'text you already pulled', query examples, max length) that enriches 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 explicitly states 'Semantic search INSIDE a fetched record' and provides concrete examples (SEC 10-K body, article). It clearly distinguishes from general search or other tools by specifying it works on text already retrieved.

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

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

The description advises using when 'the record is too big to cram into the prompt' and mentions pairing with ask_pipeworx_grounded for a workflow. It lacks explicit when-not-to-use statements but provides clear context for 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?

Provides extensive behavioral details beyond annotations: requires OAuth account, phone verification for SMS, 10/day cap for SMS, auto-disable webhook after 10 failures, and returns subscription ID. Annotations indicate write, openWorld, idempotent, non-destructive, and the description aligns and enriches these hints.

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

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

Front-loaded with main purpose, but description is lengthy due to comprehensive information. Every sentence adds value, but could be slightly more structured (e.g., bullet points for types). Still effective and well-organized.

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 all necessary context: supported types with examples, parameter format, delivery options, return value, prerequisites (OAuth), and constraints (SMS cap, webhook auto-disable). No output schema, but description explains return. Complete for a tool of this 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?

Adds substantial meaning to all parameters: explains enum values with concrete examples, details type-specific params format, and describes delivery channel constraints (phone verification, SMS cap, webhook signing). Schema coverage is 100%, but description provides actionable examples and constraints.

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

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

Clearly describes creating a proactive monitoring subscription to a live-data event stream, returning a subscription ID. Distinguishes itself from sibling tools like 'list_subscriptions' and 'unsubscribe'.

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

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

Specifies usage context (proactive monitoring, requires Pipeworx OAuth account) and lists supported types and delivery channels. Does not explicitly state when not to use it or mention alternatives beyond implied pull 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, openWorldHint, idempotentHint, and destructiveHint. Description adds that it returns question examples with tool+argument shapes and serves as an onboarding entry point, providing useful 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 verbose but each sentence adds value; it lists example questions first, then what is returned, then usage instructions. Could be slightly more concise but remains clear.

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

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

Given the simple input schema (no output schema, one optional param), the description is complete: it explains purpose, usage, scenarios, and even lists the categories and mentions meta-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?

The description explains that the optional `topic` parameter focuses on a specific area (e.g., finance, pharma) and that omitting it gives a cross-category spread, adding meaning beyond the schema's description of 'optional focus area'.

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 is an onboarding entry point that returns category-bucketed example questions, distinguishing it from sibling tools by specifying it should be used first to learn what Pipeworx can do.

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

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

Explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do for you' and provides guidance on calling with no arguments or with a `topic` parameter to focus, indicating when to use and how.

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 that the row is deactivated, not deleted, and historical events remain. Adds behavioral nuance beyond annotations (destructiveHint: false aligns). 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 efficient sentences covering all key points with no fluff. Slightly 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?

For a single-parameter tool with annotations, the description covers purpose, ownership, and behavioral nuance. Lacks return value details, but no output schema expected.

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

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

Schema coverage is 100%; description adds ownership context for the 'id' parameter but otherwise relies on schema. 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?

Explicit verb 'Cancel' plus specific resource 'subscription by id'. Clearly distinguishes from siblings like 'subscribe' and 'list_subscriptions'.

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

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

States ownership enforcement ('you can only cancel your own subscriptions'), providing clear context. No explicit when-not-to-use, but adequate for given complexity.

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 readOnly/openWorld/idempotent, but the description adds critical behavior: the distinction between could_not_verify and unsupported, the requirement not to present could_not_verify as evidence, the error structure verification_error, and the two verification pipelines (SEC EDGAR/XBRL vs grounded). 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 long but every section adds value: query examples, usage trigger, pipeline distinction, return values, error semantics, and performance note. It is front-loaded and well-structured; could be trimmed but not at the cost of essential behavioral nuance.

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

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

No output schema, but the description fully compensates by listing the verdict enum, the return value with citation, reasoning, and the caller-facing error semantics. It also explains fallback routing, making it 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 100% for the two parameters; the description adds no extra detail about claim/tolerance_pct beyond the schema. Baseline 3 applies 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 states a clear purpose: natural-language claim verification against authoritative sources, with explicit example query phrasings and a defined set of verdicts. It distinguishes itself from sibling tools by focusing on fact-checking a claim, not general search or research.

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

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

It states when to use the tool ('Use whenever the agent needs to check whether something a user said is factually correct') and explains the two internal paths (financial vs other claims). It doesn't explicitly name alternatives or when not to use it, but the trigger is unambiguous.

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