Soilgrids

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

Annotations already declare readOnlyHint, openWorldHint, etc. The description adds context about free vs. BYO costs, and details the return structure (per-model fields + combined view). 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?

Four well-structured sentences with no redundancy. Front-loaded with the core action and immediately useful details.

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

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

Given moderate complexity, sufficient description of output and use cases. Could benefit from mention of pagination or rate limits, but not required for this read-only 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 baseline is 3. The description adds value by explaining the default model and clarifying the _apiKey requirement and cost implications.

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

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

The description clearly states the tool probes LLMs and scores visibility, with specific details about default model and key usage. However, it does not distinguish itself from similar 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?

Explicitly lists use cases ('AI-marketing audits, pre-launch brand checks, competitive monitoring'), but lacks guidance on when not to use or comparisons to alternatives.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds meaningful context beyond those annotations: it routes across many tools, fills arguments automatically, and returns structured answers with stable citation URIs. It does not go into failure modes or latency, but the core behavioral profile is transparent.

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

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

The description is long but front-loaded with a strong 'PREFER OVER WEB SEARCH' directive, followed by domains, trigger phrases, examples, and alternative-tool routing. It is organized and mostly earns its length, though there is some redundancy around the 'grounded' alternatives. This keeps it from being maximally concise while still being 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 having no output schema, the description tells the agent what to expect in return: a structured answer with stable pipeworx:// citation URIs. It also covers when to use the tool, when not to, which sibling to switch to, and gives concrete examples. For a single-free-text-input orchestration tool, this is a complete and actionable definition.

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

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

Schema description coverage is 100%, and the schema already documents that question is a natural-language request with multiple accepted aliases. The description adds examples of questions but no additional parameter-level semantics. Since the schema carries the parameter documentation burden, a baseline score of 3 is appropriate.

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

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

The description clearly states what the tool does: it routes natural-language questions to the appropriate one of 5,798 tools across 1,517 verified sources, fills arguments, and returns structured answers with stable pipeworx:// citation URIs. It distinguishes itself from siblings like ask_pipeworx_beta, ask_pipeworx_grounded, and deep_research by explaining how they differ. Domain lists and examples further pin down its intended scope.

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 is explicit about when to use this tool: prefer it over web search, use it for the listed factual question types, and start here for most questions. It also gives clear exclusions with named alternatives, such as recall for already-loaded evidence and ask_pipeworx_beta for single exact one-tool calls. This is strong routing guidance for an agent.

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 safety (read-only, idempotent, non-destructive). The description adds valuable behavioral context: it is a live experimental router, currently matching stable behavior, with results compared against the stable router, and it does not fall back to anything. 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?

Four sentences deliver clear information, but there is some redundancy between 'identical' and 'matches ask_pipeworx exactly' and 'Use it exactly like ask_pipeworx'. Still, the structure is front-loaded with the beta identity and the experimental nature, keeping it reasonably compact.

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 the current operational state, relationship to ask_pipeworx, and what happens when candidates are under test. It references ask_pipeworx for the response shape, which is acceptable given the sibling context, though it omits specifics about the response format for a standalone caller.

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

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

Schema coverage is 100%, with all parameters documented as aliases for 'question'. The description only repeats 'same arguments' without adding new meaning. Baseline 3 is appropriate since the schema carries the parameter documentation.

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

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

The description clearly states the tool is the beta version of ask_pipeworx, a universal router with identical tools, arguments, and response shape. It distinguishes itself from the stable ask_pipeworx by being the experimental edge, so an agent can tell them apart.

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 instructs to use it exactly like ask_pipeworx when the newest routing is desired, and implies the stable ask_pipeworx is the alternative for non-beta use. It also clarifies that currently no candidate is active, so behavior matches ask_pipeworx exactly.

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 discloses the full execution flow, the success and refusal response contracts with enumerated refusal reasons, and the additional LLM call cost. This is thorough behavioral disclosure and consistent with the annotations.

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

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

Every sentence earns its place: core purpose, mechanism, output and refusal contract, use cases, and cost comparison. The most decision-relevant information is front-loaded, and the rest is organized without 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?

Even with no output schema, the description defines the success and refusal response shapes, including evidence as a verbatim quote and the refusal reason enum. Combined with the input schema and annotations, an agent has everything needed to decide whether and how to call 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 schema already documents the question parameter, its natural-language expectation, and all aliases. The description adds high-level context about automatic tool routing and argument filling but no additional parameter-level syntax or constraints, matching the high-coverage 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 opens with a specific function: a hallucination-resistant, grounded answer mode for high-stakes reads. It clearly distinguishes itself from sibling ask_pipeworx by stating it extracts answers using only tool results and returns explicit refusals when data is insufficient.

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 when-to-use guidance: whenever an answer will be quoted, cited, or acted on and the agent must not invent facts, with concrete domains like financial verdicts, legal claims, and medical lookups. It also directs users to prefer ask_pipeworx for casual lookups because of the extra LLM call cost.

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 extensively discloses behavioral traits beyond annotations: resolution contract details (market_match_confidence, suggestions), parent event extraction, news fallback mechanisms, low-confidence short-circuit behavior, closed market handling, wide-spread warnings, and resolution-rule risk. Annotations already indicate read-only, open-world, idempotent, non-destructive; description adds complementary, not contradictory, details.

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

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

The description is very long and dense, but well-structured with clear sections (classifiers, fan-out examples, response shapes, resolver contract, safety, etc.). It front-loads the core purpose. However, it could be more concise by reducing redundant explanations, such as the repeated 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?

Given the tool's complexity (multiple data sources, resolver logic, parent events, news fallbacks, safety checks), the description covers all important aspects comprehensively. Despite lacking an output schema, it details response shapes (market, analysis, evidence, parent_event) and edge cases (low confidence, closed markets, illiquid spreads).

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

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

With 100% schema coverage, the description adds meaningful context beyond the schema: it elaborates on the 'depth' parameter's effect (quick vs thorough), clarifies the 'market' parameter accepts slug/URL/text, and explains the 'include_raw' parameter's impact on response size (vs. summary mode). This enriches understanding of how parameters affect behavior.

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 verb and resource ('Research a Polymarket bet by pulling the relevant Pipeworx data'), specifies multiple input types (slug, URL, question text), and lists detailed outputs (evidence packet, market-vs-model comparison). It distinguishes itself from sibling tools like polymarket_arbitrage and polymarket_edges through its unique capability of fanning out to category-specific data packs.

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

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

The description explicitly states when to use the tool: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' While it doesn't explicitly mention when not to use or provide alternatives, the context is clear and the tool's niche is well-defined among siblings.

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

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

Annotations already declare readOnly, idempotent, and non-destructive. Description adds behavioral context: for type 'company' it pulls latest 10-K revenue/net income/cash/debt via SEC EDGAR/XBRL with correct off-calendar fiscal year handling; for 'drug' it pulls FAERS adverse events, FDA approvals, and trial counts. It also notes results are sorted by primary metric and returns citation URIs, going beyond annotation info.

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

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

The description is concise yet packed with useful details. It starts with essential purpose and usage cues, then provides behavioral and parameter specifics in a well-organized flow. No unnecessary sentences; every sentence adds value.

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

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

Given the tool's complexity (two entity types, multiple data sources, up to 5 entities), the description covers key behavioral aspects, input formats, and retrieval logic. It mentions return type as paired data with citation URIs. However, it could briefly mention error handling or what happens when data is missing, but overall it is quite complete.

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

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

Schema coverage is 100% with clear parameter descriptions, but the description adds significant meaning: explains what data each enum value retrieves (company vs drug), specifies input formats (tickers/CIKs vs drug names), and reinforces min/max constraints. This enriches the schema significantly.

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

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

The description clearly states it performs side-by-side comparison of 2-5 companies or drugs, with concrete query examples like 'compare X and Y' or 'which is bigger'. It distinguishes itself from sibling tools like entity_profile by emphasizing batch comparison over sequential lookups.

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

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

Explicitly states 'ALWAYS PREFER over sequential single-pack lookups when comparing entities', providing direct guidance on when to use this tool. Also clarifies it is for comparisons, not single entity queries, differentiating it from entity_profile.

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, and non-destructive behavior, and the description adds substantial beyond-annotation context: account/paid-tier requirements, explicit gaps[] never invented, contradictions[] on standard/thorough, resolvable-citation guarantees, semantic excerpting, and latency expectations. No contradiction with annotations exists.

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

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

The description is long, but almost every sentence carries operational value, and the critical account prerequisite is front-loaded before capabilities. Some depth-related detail overlaps with the schema description, slightly extending length, but overall the structure is dense and purposeful.

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 supplies the required mental model: what the findings packet contains, how gaps and contradictions behave, which citations are returned, how large records are handled, and what latency to expect. It also covers prerequisites and alternatives, making it complete for safe and 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?

Schema coverage is 100%, so the baseline is 3; the description adds practical guidance about the question parameter accepting broad/multi-part natural language and clarifies depth behavior beyond the enum, such as the paid requirement for thorough and the gap-recovery/contradictions behavior. This is meaningful but not heavily additional.

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: grounded multi-source research across Pipeworx's 1517 structured data sources. It explicitly contrasts itself with open-web search and names ask_pipeworx as the single-lookup alternative, so an agent can distinguish it from sibling tools without inspecting schemas.

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

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

The description gives explicit when-to-use and when-not-to-use guidance: use ask_pipeworx if not signed in, use ask_pipeworx for single lookups, and use deep_research for broad/multi-part questions over structured data. The alternatives are named directly, leaving no inference required.

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 read-only, idempotent, non-destructive hints. Description adds that results include names, descriptions, full schemas with examples, ready to call directly—useful 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 packed with purpose, domains, return format, and usage hint. Slightly long but each part earns its place; could be tightened slightly.

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

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

No output schema, but description explains return format (top-N tools with schemas and examples). Input schema fully covered. Missing error handling, but adequate for a read-only discovery 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 baseline is 3. Description adds aliases for 'query', provides examples, and explains limit default/max, adding 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?

Description clearly states 'Find tools by describing the data or task', lists specific domains, and distinguishes from siblings (other tools are for direct tasks, this is for 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 says 'Call this FIRST when you have many tools available and want to see the option set', providing clear when-to-use guidance. Does not explicitly state exclusions, but context is sufficient.

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

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

The description discloses far beyond the annotations: parallel fan-out across multiple sources, `sources_used`/`sources_failed`, soft-fail behavior for patents, expected empty FDA results, name resolution via SEC EDGAR, and explicit handling of private companies. It also complements the readOnlyHint/openWorldHint/idempotentHint annotations without contradicting them. This is exemplary behavioral disclosure.

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

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

The description is dense and long, but nearly every clause carries operational value. It is front-loaded with user intent examples and the core 'one parallel call' message before diving into source and return details. A slightly more structured layout would improve scanability, but it earns a strong score.

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

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

For a complex fan-out tool with no output schema, the description covers input forms, source list, return fields, failure semantics, resolved/unresolved behavior, and expected edge cases. It gives an agent everything needed to invoke it correctly and interpret results. Nothing essential is missing.

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

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

Although schema coverage is 100%, the description adds meaningful semantics: `type` is clarified as interchangeable between 'company' and 'ticker', `value` can be a ticker, zero-padded CIK, or company name, and name resolution behavior is explained. Examples like 'AAPL', '0000320193', and 'Moderna' ground the parameter usage beyond the schema.

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

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

The description opens with concrete user phrasings and states the core function: 'full cross-source profile of a US public company in ONE parallel call.' It explicitly contrasts with chaining single-pack SEC/XBRL/news lookups, which differentiates it from narrower sibling tools. The resource and behavior are unmistakable.

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

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

It gives explicit guidance: 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view.' It also specifies acceptable input forms (ticker, CIK, company name), clarifies that private companies return resolved:false with a notes line, and notes expected empty results for certain industries. This is strong when-to-use and when-to-expect-what 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 destructiveHint=true and idempotentHint=true. The description adds context about use cases like clearing sensitive data, which goes beyond annotations. However, it does not discuss behavior for non-existent keys or confirm idempotency, though this is minor given the annotation coverage.

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

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

Two concise sentences, no filler. The first states the action, the second provides usage scenarios and context. 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?

The tool is simple with one parameter and no output schema. The description covers purpose, usage, and pairing. A minor gap is the lack of error handling mention (e.g., if key doesn't exist), but idempotency hint implies safe multiple calls.

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 one parameter 'key' is fully described in the schema as 'Memory key to delete.' The description adds no additional information about the parameter beyond the schema, meeting the baseline.

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

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

The description clearly states 'Delete a previously stored memory by key,' using a specific verb and resource. It also distinguishes itself from sibling tools 'remember' and 'recall' by mentioning pairing, establishing it as the inverse operation.

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

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

The description provides explicit when-to-use guidance: 'Use when context is stale, the task is done, or you want to clear sensitive data.' It mentions pairing with 'remember' and 'recall' but does not explicitly exclude alternatives or state when not to use it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds context by explaining the internal steps (fetch page, extract title/description/key links) and output format, which goes beyond the 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 concise with three sentences, no fluff, front-loaded with the core action. It efficiently conveys purpose, process, and use cases.

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

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

Given no output schema, the description adequately explains the output as a text blob ready for deployment. Annotations cover safety. Two parameters are fully described in schema and enhanced in description. No gaps remain for an agent to understand invocation.

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

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

Schema coverage is 100%, but the description adds value by stating the default (25) and maximum (50) for max_links, which is not in the schema. For url, it clarifies it should be a full URL with example. This enhances the schema info.

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

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

The description clearly states the tool generates a production-ready llms.txt file for any URL, specifying the output format (markdown) and use cases. This verb+resource pairing is specific and distinguishes it from siblings like 'scan_competitor_ai_presence' which have different purposes.

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

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

The description explicitly lists use cases: getting client sites indexed, drafting for own projects, auditing competitors. While it doesn't mention when not to use or alternatives, the sibling list contains no directly competing tools, so the guidance is sufficient.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. Description adds 'Keyless; may take several seconds to respond,' which is useful behavioral context beyond annotations. No contradiction.

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

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

Two sentences, no wasted words. Information is front-loaded: first sentence states purpose, second gives usage guidance and performance note.

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 zero parameters, no output schema, and comprehensive annotations, the description adds all needed context: what is listed, its purpose, and key behavioral trait (slowness). Complete for a simple listing 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?

No parameters exist, so parameter semantics baseline is 4. Description accurately states keyless nature.

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 lists soil properties with names and depth intervals from ISRIC SoilGrids, and explicitly differentiates from sibling 'soil_properties' by saying 'Use this to discover valid property codes for soil_properties.'

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 case: discover valid property codes for soil_properties. Also notes keyless and slow response, though no explicit when-not or alternatives beyond the sibling reference.

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

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

Annotations already provide readOnlyHint and idempotentHint. Description adds useful behavioral context: lists caller's own subscriptions, returns specific fields, and optional include_inactive filter. No contradiction.

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

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

Two sentences, front-loaded with purpose and return fields, no wasted words. 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?

Low complexity tool (1 optional param). Description plus annotations fully cover purpose, usage, safety, and return fields. No gaps.

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

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

Schema coverage is 100% with a single boolean parameter already described. Description does not add additional meaning for the parameter beyond schema, so baseline 3 is appropriate.

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

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

Description clearly states 'List the caller's active subscriptions' with specific verb and resource, and distinguishes from subscription-related siblings like subscribe and unsubscribe by mentioning usage for review and finding id to cancel.

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

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

Explicitly states when to use the tool: 'review what you're monitoring before adding more or to find an id to cancel.' Does not explicitly mention when not to use or name alternatives, but context is clear.

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

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

Annotations are all false, so the description carries the full burden. It discloses the claim_token mechanism ('Filing without an account returns a claim_token; pass it back later... to read whether it was fixed'), rate limiting ('Rate-limited to 5 per identifier per day'), and extras like 'Free; doesn't count against your tool-call quota.' These are beyond the annotation fields and help the agent understand side effects and constraints.

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

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

The description is long but every sentence serves a purpose: defining the tool, use cases, exclusions, token workflow, rate limits. It is front-loaded with the core purpose. Slightly verbose with the roadmap/quota notes but all are relevant to the agent's decision-making.

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 fully explains the expected return (claim_token) and how to use it later. It covers what to report, how to report, exclusions, rate limits, and account-free usage. For a feedback tool with nested parameters, this is a complete and self-sufficient description.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful guidance for using claim_token ('pass the pwfb_… token that filing returned, with no other arguments') and for formatting message ('Describe the issue in terms of Pipeworx tools/packs — don't paste the end-user's prompt'), which goes beyond the schema.

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

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

The description opens with 'Tell the Pipeworx team something is broken, missing, or needs to exist,' which is a specific verb+resource statement. It clearly distinguishes this from sibling tools (research, visibility, etc.) by framing it as feedback about the Pipeworx tool catalog itself, not a data query.

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

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

Explicitly tells when to use: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise).' It also gives a clear exclusion: 'ONLY for tools served by this Pipeworx connection — if the tool came from a different MCP server... file it with that server instead.' This is model guidance with alternatives.

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

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

Annotations already indicate a safe, read-only, idempotent operation. The description adds valuable context: data source (CF analytics-engine), privacy (no PII), caching behavior (5min-1h). No contradictions.

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

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

Two sentences plus use cases, all front-loaded with the core purpose. Every sentence adds value; no redundancy or filler.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description covers purpose, use cases, data source, privacy, caching, and parameter semantics. No gaps.

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

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

The single parameter 'window' is fully described in the schema with an enum. The description adds semantic guidance on choosing windows ('shorter windows surface what's hot right now; longer windows show steady-state demand').

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

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

The description clearly states the tool returns trending calls on Pipeworx, listing specific outputs (top tools, top packs, total call volume). It distinguishes itself from sibling tools by focusing on aggregate statistics rather than individual queries.

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

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

Three explicit use cases are provided (discovering hot data sources, confirming canonical tool, aligning use case). The description also explains window semantics. However, no guidance on when not to use or alternatives 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 declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint false. Description adds rich behavior: computation logic (monotonicity checks, partition sums), semantic anchor (Jaccard similarity ≥ 0.30), partition filter (placeholder slugs), fill check against live CLOB depth. 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?

Though verbose, every sentence adds value and the structure is logical: purpose, modes, filters, response, fill check. Front-loaded with main use. Could trim some redundancy (e.g., repeat of 'event' and 'topic' details), but still 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?

For a tool with 2 parameters, no output schema, and high complexity, the description covers all aspects: trigger modes, filtering logic (Jaccard, placeholder), fill check, response structure, and references sibling tool for custom sizing. No gaps.

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

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

Schema coverage is 100% with both parameters described. Description adds significant context: for event, walks child markets, checks date-axis/threshold-axis ordering, computes partition_check; for topic, searches related events, flattens markets, runs comparator. Goes far beyond schema descriptions.

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

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

Description clearly states the tool finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It names three modes (trending_scan, event, topic) with specific verbs and resources, distinguishing it from siblings like polymarket_edges or polymarket_fill_risk.

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

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

Explicit guidance: 'Call with NO args for trending_scan', 'pass `event`...', '`topic`...'. It explains when to use each mode, cross-event mode catches patterns single-event misses, and when not to trade (realizable_edge_pp ≤ 0). References sibling tool polymarket_fill_risk for custom sizing.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint true, and destructiveHint false. The description adds extensive behavioral context: caching (1h at KV level), response structure (by_segment, diagnostics), edge calculations (net of slippage), limitations (Fed bets excluded), and warnings about stale data. No contradictions with annotations.

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

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

The description is very long and detailed, which is appropriate given the complexity, but it could be more concise. It is well-structured with sections (MODEL_DRIVEN, STRUCTURAL_ARBITRAGE, etc.) and front-loads the purpose, but every sentence is not essential. Note: the description uses all caps and includes many details that could be streamlined.

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 is highly complete given the tool's complexity: 9 parameters, no output schema, multiple siblings. It explains the response structure, three segments, edge calculations, knobs, diagnostics, and caching. It also addresses limitations and provides context on Fed bets. No significant gaps.

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

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

Schema coverage is 100% with detailed descriptions for all 9 parameters. The description briefly mentions knobs but adds little additional meaning beyond the schema. Baseline score is 3 as parameters are already well-documented in the schema.

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

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

The description clearly states the tool's purpose: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It specifies the resource (Polymarket markets) and action (scan and return opportunities), and distinguishes it from siblings by mentioning Pipeworx data and the 'what should I bet on today' use case.

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

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

The description provides clear context for usage, such as 'Built for "what should I bet on today" — agents discover opportunities without paging hundreds of markets,' and explains the three segments. However, it does not explicitly compare to sibling tools like polymarket_arbitrage or polymarket_edge_tracker, missing explicit guidance on when to use alternatives.

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

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

Annotations indicate read-only, idempotent, and non-destructive behavior. The description adds detailed behavioral information: response structure (tracked, expired, snapshot_dates), trend computation, decay calculation, and TTL limits. No contradictions with annotations.

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

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

The description is thorough but slightly verbose. It is well-structured with clear separation of response fields and limits, and front-loads the key question. A bit more conciseness could improve score.

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

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

Given no output schema, the description fully explains the response structure (tracked[], expired[], snapshot_dates[]), limitations (60-day TTL, snapshot start), and decay computation. It provides a complete picture for a telemetry 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?

Both parameters have descriptions in the schema (100% coverage). The description adds value by providing defaults (days=14, window='1wk'), constraints (max 30 days), and contextual meaning (lookback, snapshot family).

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

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

The description clearly states the tool's purpose: providing edge persistence and decay telemetry from daily polymarket_edges snapshots. It answers the specific question about edge lifespan and distinguishes itself from siblings like polymarket_edges and polymarket_arbitrage.

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

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

The description explains when to use the tool (e.g., to distinguish a fresh wide edge from an old wide edge) but does not explicitly state when not to use it or mention alternatives. The context is clear, but lacks explicit exclusion guidance.

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

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

The description adds substantial behavioral context beyond annotations: it explains the check is against live order-book depth, details return fields for both modes (e.g., slippage_pp, verdict, capture_ratio, forced_directional_risk), and describes the implications of results. Annotations already indicate read-only, idempotent, nondestructive behavior, and the description aligns with 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 informative but verbose, containing around 200 words. It is front-loaded with the core purpose, but some details (e.g., 'REQUIRES one of market or event') could be inferred from the schema. The structure with sections is clear, but conciseness could be improved.

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

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

Given the complexity of two modes and no output schema, the description thoroughly explains the return fields for both single-market and basket modes, including edge cases like thin_legs and forced_directional_risk. It covers all necessary information for correct usage.

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

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

Schema coverage is 100% with descriptions for all parameters. The tool description adds extra context, such as how size_usd is interpreted differently for basket mode (settlement notional, shares per leg) and default side auto-detection for baskets. This adds marginal 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 it performs a 'Realizable-vs-theoretical edge check against live CLOB order-book depth' and explains two distinct modes (single-market and basket). It explicitly differentiates itself from sibling tools like polymarket_arbitrage and polymarket_edges by recommending its use before those tools.

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

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

The description provides explicit guidance: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. It also warns about the risks of partial fills and unhedged positions, helping the agent decide when to use the tool.

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

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

Even with readOnlyHint, openWorldHint, and idempotentHint annotations, the description goes far beyond them by disclosing limitations, safety fields, compatibility codes, fee modeling absence, skipped comparisons, and the meaning of null temporal_alignment. It explicitly warns that pairing is unverified and that non-equivalent bet shapes are flagged. This is exemplary behavioral transparency, with no contradiction against 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 structured and front-loaded with purpose and modes, but it is very long and somewhat repetitive, revisiting temporal_alignment_unknown and pre-mapped caveats multiple times. The density of critical safety information earns its place, yet the length could be tightened without losing 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 there is no output schema, the description carries the full burden of explaining response shape, safety codes, null semantics, skipped legs, flags, fees, and return-value caveats. It thoroughly prepares an agent to call the tool correctly in either mode, interpret warnings, and avoid over-trusting spread values. Nothing essential appears missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds valuable meaning beyond the schema by explaining that the two explicit parameters override the topic-mapped side and that both modes run the identical token-overlap matcher. It also contextualizes when to supply custom identifiers versus relying on topic. This goes beyond the schema, though it does not deeply document each parameter's format beyond what the schema already provides.

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

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

The description clearly states a specific resource and function: the cross-venue spread between Kalshi and Polymarket for the same resolving question. It differentiates itself from the sibling Polymarket-only tools by emphasizing the cross-venue nature and by detailing two concrete usage modes. The purpose is immediately identifiable and not merely a restatement of the name.

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

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

The description gives clear, practical guidance on both modes: pre-mapped topic shortcuts vs. explicit kalshi_event_ticker + polymarket_event_slug custom pairings, and notes that both run the same matcher. It also warns that pre-mapped topics are not necessarily tradeable and that reported spreads are gross, not net. However, it does not explicitly name sister tools as alternatives or state when to prefer one of them, so it stops short of a full exclusionary guide.

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 safety (readOnly, idempotent, non-destructive). Description adds scoping details (anonymous IP, BYO key hash, or account ID) and dual behavior (retrieve specific vs. list all), going beyond annotations without contradiction.

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

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

Three sentences, front-loaded with primary action, no filler. Every sentence adds value. 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?

Complete for a simple tool with full schema coverage and no output schema. Explains scoping, pairing with siblings, and three use cases (revisit ticker, address, notes). No gaps.

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

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

Schema covers 100% of the single parameter (key). Description adds crucial semantics: omit key to list all keys. Fully explains parameter meaning and usage.

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

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

Clearly states the purpose: retrieve a value by key or list all keys. Uses specific verb-resource pair ('retrieve...saved via remember') and distinguishes from siblings (remember, forget). Examples of use cases reinforce clarity.

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 ('look up context the agent stored earlier... without re-deriving'). Implicitly contrasts with remember (save) and forget (delete), but does not explicitly state when not to use. Provides good context for selection.

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

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

The description describes mark_read:true as flagging events read, which is a write operation, contradicting the readOnlyHint:true annotation. This is a clear contradiction, so score is 1 per the rules.

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 sentences, front-loaded with the core purpose, and no unnecessary words. It efficiently conveys usage, return fields, and polling suitability.

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

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

The description covers return fields and parameter usage, but misses details about ordering, pagination, and error handling. The contradiction with annotations also undermines completeness.

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

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

Schema coverage is 100%, baseline 3. The description adds value by providing examples (e.g., 'sec_8k') and explaining the behavioral effect of mark_read, enhancing beyond schema descriptions.

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

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

The description clearly states the tool pulls fired events from a subscription feed and returns recent alerts. It distinguishes from siblings like 'subscribe' and 'list_subscriptions' by focusing on retrieving already-fired events with filtering options.

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

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

The description explains when to use the tool: to get recent alerts with optional filters. It mentions polling works fine and provides an alternative API endpoint for scripts, but lacks explicit guidance on when not to use this tool versus siblings.

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

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

Annotations already indicate readOnlyHint and idempotentHint. The description adds context on data sources, fallback, and API sunset (PatentsView soft-fail). 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?

A single dense paragraph front-loaded with typical queries, then covers fallback, parameter notes, and sibling comparison without wasted words. 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?

Given 3 required parameters, high schema coverage, and no output schema, the description covers return structure (changes grouped, total_changes, URIs) and explicitly states only 'company' type is supported. Completes the picture.

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 detailed. The description adds value with examples of 'since' formats (ISO vs relative) and explains that 'value' accepts ticker or CIK. This goes beyond baseline.

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

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

The description clearly states the tool gets a change feed for a company (SEC filings, news, patents) in a time window. It distinguishes from the sibling entity_profile by explicitly noting when to use the static profile instead.

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 example queries, fallback behavior (GDELT to GNews), and when-not-to-use (use entity_profile for static profile). This gives clear guidance on when to invoke this tool vs alternatives.

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

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

Annotations provide idempotentHint=true, destructiveHint=false, readOnlyHint=false. Description adds: scoped by identifier, persistence details (authenticated vs anonymous sessions). 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?

Concise, well-structured, front-loaded with purpose. Every sentence adds value; no fluff.

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

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

Complete for a simple store operation with 2 required params. Covers idempotency, retention, and pairing with sibling tools. No output schema needed.

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

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

Schema coverage is 100%, baseline 3. Description adds contextual examples for key (e.g., 'subject_property') and value ('findings, addresses, preferences'), enhancing understanding beyond schema.

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

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

The description clearly states the tool's purpose: 'Save data the agent will need to reuse later.' It uses a specific verb ('save') and resource ('data'). It distinguishes from sibling tools like recall and forget by mentioning pairing.

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

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

Explicit guidance on when to use: 'Use when you discover something worth carrying forward' with concrete examples. Also specifies alternatives: 'Pair with recall to retrieve later, forget to delete.'

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

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

Annotations already mark it read-only, idempotent, open-world, and non-destructive. The description adds meaningful behavioral context beyond those hints: it cascades through several lookup endpoints internally, gracefully degrades when GLEIF/OpenFIGI are unavailable, returns EDGAR identifiers regardless, and reports unresolved identifiers explicitly. This gives the agent a clear mental model of the operation.

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

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

The description is long, but every sentence earns its place. It is front-loaded with purpose and usage priority, then organizes details by supported types and edge cases. Despite its density, it reads as a well-structured reference rather than a wall of text, with no filler or redundant restatements of the tool name.

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

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

For a tool with two entity types, multiple upstream sources, and no output schema, the description is remarkably complete. It specifies the return identifiers (CIK, ticker, LEI, FIGI, RxCUI, ingredient, brand), the citation format, degradation behavior, and input constraints. An agent has enough context to invoke it correctly across the supported use cases.

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 documents both parameters at 100% coverage, the description adds substantial semantic value: concrete examples for each type, accepted formats (ticker, CIK, ISIN, name), the 'entity name only' rule, and the bond-issuer caveat about trailing security-class words. This goes well beyond the schema and prevents common misinputs.

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

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

The description opens with concrete examples and a clear statement: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' It immediately distinguishes the tool's role from siblings like compare_entities or entity_profile by emphasizing the name-to-ID lookup function, and it further differentiates by supported entity types and identifier sources.

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 instructs 'Use FIRST whenever you have a name but need an ID,' which directly guides selection. It also gives detailed input-format rules, including what to pass for tickers, CIKs, ISINs, company names, drugs, and bonds, plus a negative example ('never the question's full noun phrase'), making the invocation conditions unambiguous.

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

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

Annotations already declare readOnly, idempotent, and openWorld hints. The description adds value by explaining the process (probes each entity, ranks by score) and the output structure (score, confidence, signal density per entity). 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 two sentences long, front-loaded with the core purpose, and immediately followed by an illustrative use case. Every word earns its place; no redundancy or unnecessary detail.

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

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

Given the complexity of comparing multiple entities and the absence of an output schema, the description explains the return values (ranked list with score, confidence, signal density per entity) and the general process. This is sufficient for an agent to understand input, behavior, and output.

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

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

While the schema already covers parameter descriptions (100% coverage), the description adds useful context: the first entity is treated as the subject for narrative, and that probing uses ai_visibility_check. This extra meaning helps the agent understand parameter intent beyond the schema.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, using ai_visibility_check for each. It differentiates from the sibling ai_visibility_check by being a multi-entity comparison tool. The specific verb 'compare' and resource 'AI presence across entities' make the 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?

The description explicitly states the use case: competitive AI-marketing audits, with an example question. It implies when to use (comparing multiple entities) but does not explicitly contrast with alternatives like ai_visibility_check or compare_entities, though the context is clear.

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

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

The annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds valuable behavioral context: partial failures degrade gracefully, bundlephobia's first measurement can take 5-30s, and sources_failed will list timeouts. No contradiction with annotations.

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

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

The description is detailed but well-structured, with the main purpose front-loaded. Every sentence adds meaningful information. It could be slightly tightened, but it's not verbose. The structure with examples and edge cases (e.g., timing for new versions) is helpful.

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 completely details the return structure: a summary block with specific fields, per-advisory details, links, and alternative versions. It also explains partial failure behavior and ecosystem limitations. This provides agents with a full picture of what to expect.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra value beyond the schema: it mentions that scoped packages like '@types/node' are accepted and that the version parameter defaults to latest. This enriches agent understanding beyond the schema descriptions.

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

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

The description clearly states the tool's composite nature: it combines deps.dev and bundlephobia checks in one call to evaluate whether to add an npm package. It specifies the verb 'scan/check', the resource (npm package), and the scope (license, advisories, bundle size, etc.). This distinguishes it from sibling tools that might handle individual ecosystems or single-source checks.

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

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

The description explicitly states when to use: whenever an agent asks about package safety, popularity, size, or cost. It also provides clear exclusions: 'NPM ecosystem only in v1; PyPI / Maven / Cargo / Go fall under deps.dev:version directly.' This gives agents unambiguous guidance on alternatives.

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

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

Annotations already declare read-only, idempotent, non-destructive. The description adds significant value beyond annotations: details about internal mechanics (BGE-base-en embeddings, cosine similarity, 500-char overlapping windows, 200K char cap with truncation flag) and output structure (character offsets, similarity scores).

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

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

The description is front-loaded with the purpose and uses a clear, efficient structure. It packs useful details without excessive verbosity. Slightly dense but every sentence adds value; could be slightly more streamlined.

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 effectively explains the return format (top-N passages with character offsets and similarity scores), the internal process, and the 200K char cap. Parameter documentation is complete. No gaps for an agent to understand usage.

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

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

Schema coverage is 100% with descriptions for all 3 parameters. The description adds extra context: text max 200K chars, limit range 1-20, query examples. It also explains the output generation (500-char windows) which relates to how the text parameter is processed.

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 does semantic search inside a fetched record, using the verb 'search' and the resource 'record'. It distinguishes from siblings by mentioning its pairing with ask_pipeworx_grounded and the workflow of fetching then searching.

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

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

Explicitly states when to use: 'when the record is too big to cram into the prompt' and pairs with ask_pipeworx_grounded for a complete workflow. Provides clear context and alternative usage.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive). The description adds meaningful behavioral context: keyless access and that the tool may take several seconds to respond. This goes beyond the annotations and helps the agent set expectations.

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 deliver all critical information upfront: what the tool does, the source, the output format, authentication, and performance. No extraneous words; every sentence earns its place.

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

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

For a simple two-parameter lookup without output schema, the description covers the source, output (classes and probabilities), authentication (keyless), and a performance caveat. Missing are potential error conditions or precision limits, but overall it is adequately 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?

Input schema covers both parameters with 100% coverage, including descriptions for latitude and longitude ranges. The description adds no parameter-specific information beyond what the schema provides, so baseline score of 3 is appropriate.

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

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

The description clearly states the tool retrieves the WRB soil classification from ISRIC SoilGrids, specifying the output (most probable class plus top 5 with probabilities). The verb 'Get' and resource naming are highly specific, making the purpose unmistakable even without sibling differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives like list_soil_properties or soil_properties. The description only explains what the tool does, leaving the agent without decision criteria for tool selection.

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

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

Description adds value beyond annotations by disclosing latency ('may take several seconds') and output unit scaling ('real units'), which are not covered by the readOnlyHint and idempotentHint annotations. No contradiction.

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

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

Two sentences, no fluff. Purpose and key details (source, resolution, units, latency) are front-loaded and efficiently communicated.

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?

Description adequately covers the tool's capabilities given its simplicity (no nested objects, no output schema). It explains the source, resolution, returned properties, and latency. Could specify output format more precisely but is sufficient.

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

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

Schema coverage is 100% with good descriptions for each parameter. The description provides an example of properties but does not add significant new meaning beyond the schema. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool retrieves soil property values at any coordinate from ISRIC SoilGrids, listing specific properties. It does not explicitly differentiate from sibling tools like list_soil_properties or soil_classification, but the verb+resource is clear.

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

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

No explicit guidance on when to use this tool versus alternatives. It mentions latency ('may take several seconds') but does not provide context on preferred scenarios or exclusion criteria.

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

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

Annotations indicate readOnlyHint=false, idempotentHint=true, and destructiveHint=false. The description adds value beyond annotations by detailing that subscriptions persist, webhook signing secret is returned once, and auto-disable after failures. No contradiction with annotations.

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

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

The description is well-structured with a clear first sentence stating purpose, followed by prerequisites, types, and delivery options. It is moderately concise, though some details could be streamlined without losing clarity.

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

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

Given the complexity (nested objects, no output schema), the description covers prerequisites, type-specific filters, delivery channels, constraints (SMS cap, webhook auto-disable), and return value. It lacks explicit error handling or rate limits beyond SMS.

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

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

Schema coverage is 100%, but the description adds concrete examples for each type and delivery sub-parameters (e.g., sec_8k with items, webhook HMAC signing), enhancing understanding beyond the schema's descriptions.

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

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

The description clearly states the verb 'Create' and the resource 'proactive monitoring subscription to a live-data event stream', and distinguishes from sibling tools like list_subscriptions and unsubscribe by focusing on creation and specifying return of a subscription ID.

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

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

The description provides prerequisites (Pipeworx OAuth account), type-specific examples, and delivery constraints (phone verification, webhook auto-disable). However, it does not explicitly differentiate from close siblings like 'polymarket_edge_tracker' or advise when to use alternatives.

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

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

Annotations already indicate readOnly, idempotent, openWorld, and non-destructive. The description adds useful behavioral context: it returns category-bucketed example questions with exact tool+argument shapes, drawn from a live catalog. No contradictions with annotations.

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

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

The description is well-structured and front-loaded with key trigger phrases and purpose. It is slightly long but every sentence is informative, earning its place. Could be marginally more concise, but overall effective.

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

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

The description is fully complete for a tool with one optional parameter and no output schema. It covers purpose, usage, output, and context, enabling an agent to correctly select and invoke the tool without additional information.

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

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

Schema coverage is 100%, so baseline is 3. The description adds valuable usage hints: 'pass `topic` (e.g. 'finance', 'pharma', 'betting') to focus' and 'Omit for a cross-category spread', which helps the agent understand parameter behavior 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 the tool's purpose: 'the onboarding entry point for an agent that just connected' and specifies it 'Returns category-bucketed example questions'. It also lists trigger phrases like 'What can I ask Pipeworx?' and distinguishes from siblings by advising to 'Use this FIRST when you do not yet know what Pipeworx can do for you'.

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 guidance on when to use the tool ('when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools') and how to pass the optional topic parameter. However, it does not explicitly compare with specific sibling tools or state when not to use it.

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

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

The description adds significant behavioral context beyond annotations: ownership enforcement, soft deactivation (not deletion), and that historical events remain. This complements the idempotentHint and destructiveHint annotations perfectly.

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

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

Two sentences, front-loaded with the action, no wasted words. Every sentence adds critical information.

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

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

Given one parameter fully described in the schema and no output schema, the description explains the effect (deactivation) and what remains available (historical events via recent_alerts), 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 coverage is 100%, with the id parameter described as 'Subscription id (uuid) returned by subscribe.' The description adds no extra semantic value beyond that, so baseline 3 is appropriate.

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

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

The description uses a specific verb 'Cancel' and resource 'subscription by id', clearly distinguishing it from siblings like 'subscribe' and 'list_subscriptions'. It also adds ownership enforcement and soft-deletion behavior.

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 ownership enforcement (you can only cancel your own), guiding appropriate use. It also references 'recent_alerts' for historical events, implying an alternative for viewing history. Lacks explicit 'when not to use' but is clear enough.

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

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

Beyond the read-only, open-world, idempotent annotations, the description discloses critical behavioral nuance: the dual-path execution (SEC EDGAR/XBRL vs. grounded pipeline), the special meaning of 'could_not_verify' (a failed check, not evidence), and the definition of 'unsupported.' It also notes the tool replaces a multi-step workflow, providing substantial context beyond what annotations convey.

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

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

The description is detailed yet every sentence carries value: trigger examples, usage context, dual-path behavior, output summary, and an 'IMPORTANT' callout about error semantics. The structure is front-loaded with purpose and examples, followed by a clear warning section, with 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?

For a tool with only two parameters and no output schema, the description thoroughly covers the return payload (verdict types, value with citation, reasoning), the fallback behavior for non-financial claims, and the nuanced error handling for 'could_not_verify.' It gives the agent sufficient context to invoke the tool and interpret results accurately.

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

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

The schema already fully documents both parameters with examples (100% coverage). The description adds context about 'exact percent-delta math' for financial claims, which hints at tolerance behavior, but it does not provide additional parameter-level meaning beyond the schema. Thus it meets the baseline for full schema coverage.

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

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

The description clearly identifies the tool as a natural-language claim verifier with trigger phrases like 'fact check' and 'verify the claim that...', then details the two verification pipelines and the verdict output. It also highlights that it replaces 4–6 sequential calls, distinguishing it from generic search or research 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 a clear usage trigger: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also distinguishes between company-financial and other claims, explaining the different processing paths. However, it does not explicitly mention when not to use the tool or name alternative sibling tools for comparison.

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