Meteostat

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

Annotations indicate read-only, open-world, idempotent, non-destructive behavior. The description adds crucial behavioral details: it probes multiple models, costs may apply (BYO key for Anthropic), and returns structured per-model results. No contradictions.

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

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

The description is concise (3 sentences), front-loads the action, and includes no fluff. Every sentence adds essential information.

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

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

Despite no output schema, the description specifies the return structure. All parameters are covered, annotations provide safety context, and the tool's complexity is modest. The description is fully adequate.

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 default model, why _apiKey is needed, and how context helps disambiguate—beyond what schema provides.

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

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

The description clearly states the tool probes LLMs for knowledge about entities and scores visibility per model. It distinguishes from siblings by specifying the AI-marketing audit use case.

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

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

The description explains when to use the tool (e.g., brand audits, competitive monitoring) and clarifies optional parameters like _apiKey. However, it does not explicitly state when not to use it or mention alternatives among siblings.

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

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

Annotations already mark it read-only, open-world, idempotent, and non-destructive; the description adds useful behavior beyond that: it dynamically routes to one of many tools, fills arguments, and returns structured answers with stable pipeworx:// citation URIs. It does not discuss edge behavior such as unsupported questions or routing failures, hence not a 5.

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 longer than average, but it is front-loaded with the critical preference rule and organized as scope, behavior, triggers, examples, and default-use instruction. The domain list and examples are justified for a broad routing tool, though it could be trimmed without losing intent.

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

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

For a tool with no output schema, it discloses the return shape (structured answer with stable pipeworx:// citation URIs), covers domains, gives explicit usage triggers and examples, and explains the routing behavior. An agent has enough context to select and invoke it correctly in most factual-query situations.

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

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

The input schema already documents the single required natural-language parameter and every alias at 100% coverage, so the description bears little parameter burden. The examples in the description illustrate valid questions, but do not add meaning beyond the schema's own 'natural language' description and examples.

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 factual-question router over verified data sources: it 'routes the question to the right one of 5,798 tools' and returns cited structured answers. It is specific enough about scope, though it does not explicitly differentiate this from sibling tools like ask_pipeworx_beta or ask_pipeworx_grounded, so it misses full sibling-level distinction.

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

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

It gives an explicit preference rule ('PREFER OVER WEB SEARCH'), enumerates trigger phrases ('what is', 'look up', 'find', 'get the latest', 'how much', 'current'), lists concrete example queries, and says to use it even when web search could also answer. This is strong when-to-use guidance with a named alternative.

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

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

Annotations already cover read-only, open-world, idempotent, and non-destructive behavior. The description adds valuable context: candidate routing improvements are live only when under test, no candidate is currently active so it matches ask_pipeworx exactly, and it falls back to nothing because it is a full working router. 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 front-loaded with the tool's identity and beta status, then efficiently covers current state, usage guidance, and fallback behavior. Each sentence contributes distinct useful information with no filler or redundancy.

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

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

For a read-only, idempotent universal router with no output schema, the description covers identity, current live behavior, usage instructions, and the relationship to the stable router. The scope is sufficiently clear from 'same 5,798 tools' and 'same response shape', making this complete for an agent to call correctly.

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

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

Schema coverage is 100% and all six parameters are documented as aliases for the single required question parameter. The description references the same arguments as ask_pipeworx but adds no new parameter meaning beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description clearly identifies the tool as a beta version of ask_pipeworx, a universal router with the same 5,798 tools, arguments, and response shape. It distinguishes itself from the stable sibling by being the experimental routing edge, so an agent can tell it apart from ask_pipeworx and ask_pipeworx_grounded.

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

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

The description explicitly says to use it exactly like ask_pipeworx when you want the newest routing and explains that results are compared against the stable router. It gives clear context but does not provide an explicit when-not-to-use statement or mention alternatives such as ask_pipeworx_grounded.

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

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

The description goes well beyond the annotations by disclosing the refusal behavior, exact success/refusal return shapes, the constraint to use only tool result content, and the extra cost relative to the sibling. This adds meaningful behavioral context beyond readOnly/openWorld/idempotent hints and does not contradict them.

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

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

The description is information-dense but every sentence earns its place: mode, routing, extraction rule, return shape, refusal reasons, use cases, and cost trade-off. It is front-loaded with the most important behavioral distinction and wastes no words.

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

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

For a tool with no output schema, the description compensates by specifying both success and refusal return structures, key use cases, and the comparison against ask_pipeworx. Combined with complete schema coverage and annotations, an agent has everything needed to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, with every alias for the question parameter documented. The description adds no additional parameter-level detail, but none is needed since the schema already fully explains the input semantics. Baseline 3 is appropriate.

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

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

The description clearly identifies the tool as a hallucination-resistant, grounded answer mode for high-stakes reads, with a specific verb and resource. It explicitly distinguishes itself from the sibling ask_pipeworx by describing the same routing but a stricter extraction behavior, making it easy for an agent to 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?

The description gives explicit when-to-use guidance: whenever an answer will be quoted, cited, or acted on and the agent must not invent facts. It also names ask_pipeworx as the alternative for casual lookups and notes the extra LLM call cost, providing clear routing criteria.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds rich behavioral context: fan-out behavior, response shapes, resolver contract, parent event extractor, news fallbacks, safety short-circuits, wide-spread handling, resolution-rule risk. No contradictions.

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

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

The description is comprehensive but very long and dense. While front-loaded with purpose, it lacks concise structure (e.g., bullet points). Some redundancy and excessive detail reduce readability.

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

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

Extremely complete for a complex tool: covers market resolution, classifiers, fan-out examples, response shapes, resolver contract, parent events, news fallbacks, safety, wide-spread, cancellation rules. No output schema, but description compensates fully.

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

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

Schema coverage is 100% and the description adds meaningful context for all three parameters: market (slug/URL/question text), depth (quick vs thorough), include_raw (summarized vs full payloads). Goes beyond schema with examples and usage intent.

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

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

The description clearly states it researches a Polymarket bet by pulling Pipeworx data, resolving the market, classifying, and returning evidence. It distinguishes from sibling tools by specifying use cases ('should I bet on X').

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

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

Provides explicit when-to-use scenarios ('should I bet on X'), comprehensive examples for classifiers and fan-outs, and detailed instructions to inspect market_match_confidence before trusting analysis. Covers many edge cases.

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

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

Annotations already indicate read-only and idempotent behavior. The description adds significant behavioral context: it details data sources (SEC EDGAR/XBRL for companies, FAERS for drugs), fiscal year handling for off-calendar companies, sorting by primary metric, and the inclusion of citation URIs. This goes well beyond the annotations.

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

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

The description is highly efficient: it front-loads common user triggers, then provides essential behavioral details in a dense but readable format. Every sentence serves a purpose, and there is 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?

Given the tool's complexity (two entity types, multiple data sources, sorting), the description covers key behaviors completely: parallel execution, data pulled per type, fiscal year handling, sorting, and citation URIs. It does not need to detail output format since no output schema is required. Compared to siblings, it clearly differentiates from single-entity lookups.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds meaningful context: for the 'type' parameter, it explains that 'company' pulls specific financial data and 'drug' pulls adverse-event data. For 'values', it clarifies that companies use tickers/CIKs and drugs use names, and constrains the count to 2–5. This adds substantial 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 starts with clear trigger phrases ('Compare X and Y', 'X vs Y', etc.) and explicitly states it performs side-by-side comparison of 2–5 entities. It distinguishes itself from sequential lookups by emphasizing it is a single parallel call, making the purpose unmistakable.

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

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

The description explicitly instructs the agent to 'ALWAYS PREFER over sequential single-pack lookups when comparing entities' and quantifies efficiency by stating it 'Replaces 8–15 sequential lookups.' This provides clear when-to-use guidance and contrasts with sibling tools like 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?

Adds far beyond annotations: auth/plan prerequisites with signup URL, latency expectations ('15-60s... up to ~90s'), return packet format (verbatim evidence + confidence + source + fetched_at + citation URI), honesty guarantee ('gaps[]... never invented'), contradictions[] behavior, conditional citation fetchability ('present only when the source emits one'), semantic excerpting ('not head-truncated'), and depth-mode mechanics. No contradiction with readOnly/openWorld/idempotent 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 — details about citation fetchability, excerpting, and contradictions[] are all load-bearing. Front-loaded correctly with prerequisites and alternatives before mechanics. However, it's a dense continuous block with long parenthetical chains; paragraph breaks would aid an agent's scanning.

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

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

With no output schema, the description carries the return-format burden and fully meets it: findings packet structure, gaps[], contradictions[], citation URIs, hop field, and latency. Prerequisites, exclusions, alternatives, and failure-avoidance (auth, paid plan) are all covered. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema covers both params at 100%, so baseline is 3. The description adds the crucial paid-plan constraint on depth:'thorough' that the schema cannot express, plus grounds depth modes in concrete behavioral outcomes (gap recovery, contradictions scan, iterative hop). Modest but genuinely useful 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?

States a specific verb+resource: 'Grounded multi-source research across Pipeworx's 1517 STRUCTURED data sources... in ONE call'. Explicitly differentiates from siblings: 'this is NOT open-web search' and 'For a single lookup use ask_pipeworx instead'. Concrete example questions ('compare X and Y's regulatory + financial exposure') make scope 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?

Names alternatives with explicit switch conditions: 'If you are not signed in, use ask_pipeworx instead' and 'For a single lookup use ask_pipeworx instead.' States the sweet spot ('Best for broad/multi-part questions over structured data') and prerequisites, including the paid-plan gate on depth:'thorough'. Nothing is left to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds useful behavioral context: returns top-N tools with full schemas and examples, and states 'no second schema lookup needed.' No contradictions.

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

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

The description is front-loaded with purpose and usage guidance, listing domains and return format. It is somewhat long but every sentence adds value; could be slightly more concise.

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

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

Given the tool is a discovery tool with no output schema, the description adequately explains what is returned (names, descriptions, schemas with examples) and that results are ready to call. No critical information 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 description coverage is 100%, so the description adds minimal value beyond what the schema already provides. The description does not elaborate on parameter aliases or usage details.

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

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

The description clearly states the tool's purpose: finding tools by describing data or task. It lists many example domains and distinguishes this meta-tool from sibling tools that are specific task 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 explicitly says 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This provides clear when-to-use guidance, though no explicit when-not-to-use exclusions.

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

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

Annotations already mark readOnly/openWorld/idempotent, but the description adds substantial behavioral context: one parallel call, soft-failure of the patents source, semantics of sources_used/sources_failed, empty sections meaning real absence of data, and private-company resolved:false behavior. This goes well beyond the structured annotations.

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

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

Every sentence carries meaningful routing, input, or caveat information, but the description is long and dense, with the core purpose and usage packed into a single run-on opening. It is justified for a multi-source tool, but it is not a model of concise structuring.

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

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

There is no output schema, so the description compensates by enumerating every return group—filings, fundamentals, patents, contracts, FDA products, hiring, news, LEI—and their caveats. It also covers boundary cases like private companies, no data, and source failures, leaving nothing essential unexplained.

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 coverage is 100% and already documents both parameters, including examples and accepted value forms. The description mostly restates this ('type accepts company or ticker interchangeably', zero-padded CIK, name resolution) rather than adding new parameter-level meaning, so the 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 opens with concrete user phrasings and clearly states the deliverable: a 'full cross-source profile of a US public company in ONE parallel call.' It explicitly enumerates the fan-out sources and differentiates from single-pack SEC/XBRL/news lookups, making it easy for an agent to distinguish this from sibling tools.

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

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

The description explicitly says to 'ALWAYS PREFER' this over chaining single-pack lookups when the user wants a holistic view. It also specifies the accepted input shapes (ticker, CIK, company name) and explains what happens for private companies, giving clear guidance on when and how to invoke 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, openWorldHint=true, idempotentHint=true, and destructiveHint=false, indicating a safe, idempotent lookup. The description adds behavioral details beyond annotations, such as returning data inventory with date ranges and the ability to rank by proximity. No contradiction with annotations.

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

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

The description is concise yet comprehensive. It front-loads the core purpose in the first sentence, then provides essential context (prerequisite, examples, return data) in a well-structured flow. No redundant or 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?

The description fully covers what an agent needs: the tool's role (station lookup before data tools), input semantics (name, country, coordinates), and output details (id, name, inventory with date ranges). There is no output schema, so the description compensates by listing return fields. All 5 optional parameters are addressed with examples.

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 input schema already documents all 5 parameters. The description adds value by explaining how parameters combine (e.g., 'pair near_lat with near_lon') and providing usage examples inline. It clarifies the purpose of each parameter beyond the schema descriptions (e.g., 'filter by country ISO-2').

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

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

The description clearly states the tool finds weather station IDs by place name or geographic proximity. It uses specific verbs ('Find', 'lookup') and resources ('Meteostat weather station IDs'). It differentiates from siblings by explicitly naming it as the prerequisite for get_daily_history and get_monthly_normals, which are listed among sibling tools.

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

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

The description explicitly says 'the lookup you need BEFORE' specific data tools, providing when to use it. It gives concrete examples of queries (by name, country, proximity). It does not explicitly state when not to use it or list alternatives, but the context strongly implies it is for station discovery, not data retrieval.

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

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

Annotations already convey destructive and idempotent behavior. Description confirms deletion but adds no new behavioral context beyond what annotations provide. 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 short, front-loaded sentences with no wasted words. Every sentence adds value.

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

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

For a single-parameter, no-output-schema tool, the description covers purpose, usage, and relationships. No gaps given the tool's simplicity.

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

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

Schema describes the key parameter fully (100% coverage). Description adds no extra detail about the key format or constraints, so baseline 3 is appropriate.

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

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

The description clearly states the tool deletes a memory by key, uses a specific verb 'Delete' and resource 'memory', and distinguishes from siblings 'remember' and 'recall'.

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

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

Provides explicit when-to-use scenarios: stale context, task completion, clearing sensitive data. Also mentions pairing with remembered and recall as alternatives.

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

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

Annotations already declare the tool read-only, idempotent, and non-destructive. Description adds behavioral details: fetches page, extracts title/description/key links, outputs markdown. 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?

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

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

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

Covers input, output format, and use cases. Lacks error handling or edge cases, but for a simple read-only tool with good annotations, it is largely 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 covers 100% of parameters with descriptions. Description does not add new semantic details beyond mentioning extraction of links, which aligns with max_links parameter. No extra value added.

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

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

Description clearly states the tool generates a production-ready llms.txt file for any URL, with specific verbs and resource. It distinguishes from sibling tools like scan_competitor_ai_presence by focusing on generating the standard file format.

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

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

Explicitly lists three use cases (client indexing, personal draft, competitor audit), providing clear context. Does not include when-not-to-use but offers sufficient guidance 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds the return format (date-keyed fields) but does not disclose additional behavioral traits such as authentication requirements, rate limits, or data latency beyond what annotations cover.

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

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

The description consists of two concise sentences, each adding essential information. No fluff or redundancy, making it easy for an AI agent to quickly grasp the tool's purpose and usage.

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 3 parameters and an output schema, the description covers purpose, return fields, prerequisite (station_id from find_stations), and date range. It is complete enough, though it could mention any limitations on date ranges or data availability.

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 description adds value by explaining the station_id source ('Get a station_id from find_stations') and implying the date format (YYYY-MM-DD inclusive), which goes beyond the schema alone.

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

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

The description clearly states 'Daily historical weather for a Meteostat station between two dates' with specific verb, resource, and scope. It lists the returned fields and references the sibling tool find_stations for obtaining station IDs, effectively distinguishing from other weather 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 clear context: it's for daily historical weather requiring a station_id, start_date, and end_date. It directs users to get the station_id from find_stations. However, it does not explicitly exclude using this tool for other purposes or mention alternative tools like get_monthly_normals.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds value by specifying that the tool returns long-run averages by calendar month, which is behavioral context beyond the annotations.

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

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

Two concise sentences that are front-loaded with the purpose and include a practical example. No wasted words.

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

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

With an existing output schema (not shown), the description adequately covers the tool's purpose and return semantics. For a simple tool with one parameter and clear annotations, it is complete.

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

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

Schema coverage is 100% with a clear description of station_id linking to find_stations. The description adds meaning by detailing the return values (temperature, precipitation, pressure), which is not 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 it retrieves monthly climate normals for a station, listing specific variables (temperature, precipitation, pressure). It distinguishes from sibling tools like get_daily_history by specifying 'monthly' and 'long-run averages'.

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 use case ('what's normal in May here' baselines) but does not explicitly state when not to use it or compare with alternatives like get_daily_history. No guidance on prerequisites beyond the schema linking to find_stations.

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, non-destructive. Description adds return field details but no further behavioral context beyond annotations.

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

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

Two efficient sentences: first states action and return fields, second explains when to use. 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?

Given simple operation with one optional param and no output schema, description is complete: lists return fields, explains usage purpose, and ties to sibling subscribe/unsubscribe.

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 description for include_inactive. No need for additional parameter explanation in description; baseline 3 applies.

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

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

Description clearly states 'List the caller's active subscriptions' and lists return fields (id, type, params, etc.). Distinguishes from sibling subscribe/unsubscribe as a listing tool.

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

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

Explicitly says 'Use this to review what you're monitoring before adding more or to find an id to cancel.' Provides clear context for when to use, though could mention when not to use.

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

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

Annotations provide no hints (all false), so the description carries the full burden. It discloses rate limits ('Rate-limited to 5 per identifier per day'), quota behavior ('Free; doesn't count against your tool-call quota'), the claim_token return flow for follow-up ('Filing without an account returns a claim_token; pass it back later... to read whether it was fixed and what changed'), and the human impact ('The team reads digests daily and signal directly affects roadmap'). This is rich behavioral context beyond what annotations could 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 long but every sentence earns its place. It is front-loaded with the core purpose, then systematically covers scope exclusions, naming guidance, the claim_token flow, rate limits, and quota. No redundant or filler sentences; all information is operationally relevant.

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

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

For a tool with no output schema, the description thoroughly explains return behavior ('returns a claim_token', 'read whether it was fixed and what changed'). It covers scope, prerequisites (no account needed), rate limiting, quota, and content expectations for all four parameters. The nested context object is handled by the schema, and the description adds the necessary flow context, making this complete for an agent to invoke correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful semantic context beyond the schema: it explains the claim_token lifecycle (how the token is obtained and reused), gives guidance for the message field ('Describe the issue in terms of Pipeworx tools/packs — don't paste the end-user's prompt'), and clarifies that type categories correspond to the schema enum. This elevates it above baseline, though the schema already does heavy lifting for param descriptions.

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

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

The description opens with a clear, specific verb and resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It then breaks down concrete use cases (bug, feature/data_gap, praise), making the tool's purpose unmistakable. It also distinguishes this tool from every sibling by emphasizing it is the only feedback channel for this Pipeworx connection, and explicitly excludes tools from other MCP servers.

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 a tool returns wrong/stale data... when a tool you wish existed isn't in the catalog... when something worked surprisingly well') and when-not-to-use guidance ('if the tool came from a different MCP server... file it with that server instead'). It also tells the agent exactly how to determine if a tool is in scope ('Pipeworx tool names are the ones this connection lists') and how to frame the feedback ('Describe the issue in terms of Pipeworx tools/packs — don't paste the end-user's prompt').

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds valuable context: aggregation from CF analytics-engine, no PII, caching behavior (5min-1h), and output structure (pack, tool, count). No contradictions.

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

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

The description is concise (under 120 words), front-loads the core purpose, and uses bullet points for use cases. Every sentence adds value with no redundancy.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose, return values, use cases, data source, privacy, and caching. It is sufficient for an agent to understand and invoke correctly.

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

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

Schema coverage is 100% for the single parameter 'window'. The description adds meaning by explaining the trade-off between short and long windows, enhancing understanding beyond the enum values.

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

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

The description clearly states the tool returns 'top tools, top packs, and total call volume over a recent window' and lists three specific use cases, making it distinct from sibling tools.

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

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

The description provides three explicit use cases (discovering hot data sources, confirming popular tools, aligning use cases) but does not contrast with sibling tools or give when-not-to-use guidance.

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

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

Annotations already declare readonlyHint=true, and description adds behavioral details: live order book depth check, Jaccard similarity filtering, partition placeholder filtering, and fill check logic. 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?

Thorough and well-structured, but slightly lengthy. Front-loaded with core purpose and modes. Every sentence adds value, but could be tightened for brevity.

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

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

Fully explains output structure (opportunities array, partition check, fill check) despite no output schema. Covers three modes, internal filters, and edge cases. References sibling tool for additional functionality. 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 already covers 100% of parameters with good descriptions. Description adds context: event accepts slugs or full URLs, topic is a seed question, and no args triggers trending scan. Provides practical usage guidance.

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

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

Clearly states the tool finds arbitrage on Polymarket via monotonicity violations and partition-sum checks. Distinguishes three modes (no args, event, topic) with specific purposes. Differentiates from sibling tools by focusing on arbitrage detection.

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

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

Explicitly recommends when to use each mode: no args for trending scan, event for a specific market, topic for cross-event scanning. Provides examples of event slugs and topic seeds. Also warns when not to trade based on fill check, and references 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, etc. The description adds extensive behavioral details: caching policy, response diagnostics, edge calculation with slippage, Kelly caps, and Fed bets exclusion. No contradictions.

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

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

The description is long but well-structured: purpose first, then segments, knobs, response, caching. Every sentence adds value, though some detail could be condensed. Front-loaded with primary goal.

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

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

With no output schema, the description fully explains the response structure (by_segment, diagnostics) and per-opportunity fields. It also covers caching and model families, making the tool self-contained for an agent.

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

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

Schema covers 100% of parameters with descriptions. The description adds valuable context by explaining why knobs exist (e.g., 'drop opportunities where edge isn't realizable') and detailing technical nuances like slippage and partition leg Kelly.

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 'Scan' and resource 'Polymarket markets', and distinguishes from siblings like 'polymarket_arbitrage' by emphasizing 'Pipeworx data disagrees with market price'. It is specific and unique.

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 use ('what should I bet on today') and explains tradeable-edge knobs. However, it lacks explicit when-not-to-use guidance or mentions of sibling tools as alternatives.

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

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

Annotations already declare read-only, open-world, idempotent. Description adds behavioral details: history bounded by 60-day snapshot TTL, decay computed from daily closes, gaps in data. No contradictions.

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

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

Front-loaded with purpose, then describes response structure and limitations. Each sentence adds value. Could be slightly shorter, but comprehensive without unnecessary text.

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 fully defines response components (tracked, expired, snapshot_dates) with field details and limitations. Complete for a tool with two optional params.

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

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

Schema coverage is 100%. Description repeats parameter defaults and adds context like 'snapshot family' for window, but does not add meaning beyond schema. Baseline 3.

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

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

Description clearly states the tool's purpose: 'Edge persistence and decay telemetry' answering how long an edge has existed and if it's shrinking. It distinguishes from siblings by focusing on historical context rather than current edges.

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

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

Implicitly explains when to use: when you need to know if an edge is long-standing versus fresh. Does not explicitly state when not to use or name alternatives, but context is clear given sibling polymarket_edges.

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

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

The description adds significant behavioral context beyond the annotations (readOnlyHint, idempotentHint). It explains the tool walks the order book ladder, returns verdicts like 'clean|degraded|cannot_fill', and warns about thin legs and forced directional risk. No contradiction with annotations.

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

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

The description is well-structured with clear sections for single-market and basket modes, and front-loaded with a concise one-liner. However, it is somewhat verbose; some details could be condensed without loss of clarity. Still, it earns its length given the tool's complexity.

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

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

Given the tool's complexity and lack of output schema, the description fully covers return values (top_of_book, vwap_fill_price, slippage_pp, etc.), verdict, and edge cases like thin legs, partial fills, and forced directional risk. It is complete for an AI agent to understand and invoke correctly.

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

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

With 100% schema description coverage, the description adds further meaning: it explains default side behavior in basket mode, interpretation of size_usd (spend vs target proceeds, settlement notional), and distinguishes market vs event modes. This provides clarity beyond the schema.

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

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

The description clearly states the tool's purpose as a 'Realizable-vs-theoretical edge check against live CLOB order-book depth'. It distinguishes between single-market and basket modes, and explicitly differentiates from sibling tools like polymarket_arbitrage and polymarket_edges by specifying when to use this tool before acting on their signals.

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

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

The description provides explicit usage guidance: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. It also warns against relying on theoretical overround on thin books and explains the risk of partial basket fills converting arbs into unhedged directional positions, covering both when and when-not to use.

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

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

The description goes far beyond the annotations' readOnly/idempotent hints, disclosing that Kalshi fees are not modeled, spreads are gross not net, compatibility warnings can be non-empty even when pairs are returned, unclassified legs are never paired, and temporal_alignment null means not computed rather than aligned. This level of caveat disclosure is exemplary.

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?

While the description is information-dense and front-loaded with the core purpose, it becomes a wall of text with multiple interlocking safety fields and codes that are hard to parse at a glance. Some redundancy appears (e.g., temporal_alignment_unknown explained twice), and better structuring with bullet points or clear section boundaries would improve scannability.

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 the absence of an output schema, the description covers return shapes, safety fields, compatibility codes, skipped counters, and fee caveats—far more than typical. However, it leaves a gap around partial parameter combinations (e.g., providing only kalshi_event_ticker without polymarket_event_slug) and does not formally document the expected response structure, which prevents a perfect completeness score.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful semantic value beyond the schema by explaining that both modes run the identical token-overlap matcher and that explicit parameters override the topic-mapped side, clarifying the interaction between parameters. It stops short of fully specifying the effect of providing only one explicit parameter, so not a 5.

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

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

The description states a specific function—computing the cross-venue spread between Kalshi and Polymarket for the same resolving question—and further clarifies it by contrasting equivalent versus non-equivalent bet shapes. This is precise enough for an agent to distinguish it from siblings like polymarket_arbitrage or polymarket_edges even without comparing 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 explicitly defines two mutually exclusive modes (topic shortcut vs. explicit ticker/slug) and explains when each is applicable, including that pre-mapped topics may not be tradeable. It doesn't explicitly name sibling tools as alternatives or state when NOT to use this tool in favor of another, but the mode-selection guidance is clear and actionable.

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 context beyond annotations, such as scoping to user identifier and the ability to list keys. Annotations already indicate read-only and idempotent behavior, so the description complements them well without contradiction.

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

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

The description is concise with four sentences. The primary action is stated first, followed by usage guidance and scoping. Every sentence adds value; no redundant or extraneous information.

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

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

Given the tool's simplicity (one optional parameter, no output schema, and comprehensive annotations), the description covers all necessary aspects: what it does, when to use, how it relates to siblings, and scoping. No critical details are missing.

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

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

Schema coverage is 100%, and the description's parameter information ('omit the key argument to list all keys') matches the schema's description. No additional semantic value is added 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's purpose: retrieve a specific value by key or list all keys. It uses specific verbs ('retrieve', 'list') and resource ('saved values'), and distinguishes itself from sibling tools 'remember' 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?

The description provides explicit guidance on when to use the tool: to look up previously stored context without re-deriving it. It also explains scoping and pairing with remember/forget. However, it does not explicitly state when not to use it or mention alternatives beyond these siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds valuable behavioral context: what each alert carries (source, citation_uri, payload), the mark_read feature, and that polling is acceptable. 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 sentences, each contributing essential information. The purpose is front-loaded in the first sentence. No wasted words, and the structure is clear and efficient.

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

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

Despite no output schema, the description explains the return structure (source, citation_uri, payload), filtering options, mark_read behavior, and alternative access method. It is complete for a retrieval tool.

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

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

Schema coverage is 100%, but the description adds significant meaning beyond parameter descriptions. It explains how to use 'type' (example 'sec_8k'), 'since' (ISO timestamp), and 'mark_read' (flagging events read). This enhances understanding.

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

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

The description clearly states 'Pull fired events from your subscription feed' with a specific verb and resource. It distinguishes itself from sibling tools like 'list_subscriptions' or 'subscribe' by focusing on retrieving events rather than managing subscriptions.

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

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

The description mentions 'Polls work fine' and provides an alternative endpoint for scripts and dashboards, offering some usage guidance. However, it does not explicitly compare to other 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?

Annotations already indicate safe, idempotent behavior. Description adds multi-source fanout, soft-fail for USPTO, return structure, and parameter format details. No contradictions.

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

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

The description is well-structured with examples upfront, but relatively long. Each sentence adds value, though minor redundancy (e.g., repeating fallback 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 complexity (multi-source, fallback, parameter formats, no output schema), the description covers all necessary aspects: sourcing, parameter usage, return structure, and limitations (PatentsView sunset).

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 description is not required but adds value: explains acceptable formats for `since` (ISO date, relative shorthand) and recommends '30d' or '1m' for monitoring. Also clarifies `type` and `value` examples.

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 defines the tool as providing a change feed for a company (SEC filings, news, patents) over a time window, with specific query examples. It distinguishes from entity_profile, which is for static profiles.

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

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

Explicitly states when to use (recent changes/news) and when not (static profile, redirecting to entity_profile). Also explains fallback behavior between GDELT and GNews.

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?

Adds context beyond annotations: explains persistence duration (24h for anonymous, persistent for authenticated), scoping by identifier, and that it's a write operation (consistent with readOnlyHint=false). 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?

Four sentences, front-loaded with purpose, no wasted words. Efficient and clear.

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

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

For a simple key-value store tool, the description covers lifespan, scoping, and complementary tools. No output schema needed, so completeness is high.

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

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

Schema coverage is 100%, so baseline is 3. The description provides concrete examples for keys (e.g., 'subject_property') and values, adding meaning 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 'Save data the agent will need to reuse later' with a specific verb and resource, and distinguishes itself from sibling tools like recall and forget.

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

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

Provides explicit when-to-use guidance ('when you discover something worth carrying forward') and mentions pairing with recall/forget, but does not explicitly state when not to use.

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

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

The annotations already declare readOnly/openWorld/idempotent, but the description goes far beyond them by disclosing graceful degradation, the figi_candidates ambiguity behavior, the explicit unresolved list, internal cascading lookups, and ownership data when LEI resolves. No statement contradicts the annotations.

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

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

The description is one massive wall of text with long parenthetical asides and repetitive query-phrasing examples. It is front-loaded enough to state purpose early, but the content would be far more readable as bullets or short sections. It is functional but not concise.

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

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

For a tool with no output schema, the description thoroughly covers return values and edge cases: identifiers with source labels, unresolved, figi_candidates, RxCUI plus ingredient/brand and citation, and fallback behavior. It also covers ownership children, non-US issuers, and exact input expectations, so nothing needed to call it correctly is missing.

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

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

Schema coverage is 100%, yet the description adds substantial meaning: accepted input forms (ticker, CIK, ISIN, name), the ISIN-to-LEI mapping flow, and the warning to pass the entity name only rather than the full noun phrase. These details turn the generic 'value' parameter into a precisely understood input.

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

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

The description states a specific action—'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input'—and reinforces it with concrete examples like ticker, CIK, LEI, and RxCUI. It clearly distinguishes itself from profile or research tools by emphasizing that its output is identifiers needed by other tools. The core purpose is unmistakable even though the description is long.

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 contains the explicit directive 'Use FIRST whenever you have a name but need an ID,' which gives clear when-to-use guidance. The supported types and the bond/issuer warning add valuable usage context. However, it never names an alternative tool or states when not to use it, so it falls just short of a 5.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds value by explaining that it calls ai_visibility_check multiple times, ranks results, and returns specific fields (score, confidence, signal density). 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 concise, front-loaded with the main action, and includes all essential elements: action, methodology, use case, and output format. Every sentence provides value without redundancy.

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

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

Given the tool has 4 parameters, no output schema, and annotations covering safety, the description is complete. It explains inputs, process, output format, and typical use case. No additional information is needed for correct invocation.

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

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

Schema coverage is 100% with descriptions for all parameters. The description adds extra context for the 'entities' parameter (first entry treated as subject, rest competitors) which is not in the schema. This enhances understanding beyond the structured definitions.

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

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

The description clearly states it compares AI visibility across multiple entities by probing with ai_visibility_check, ranking, and surfacing recognition. It distinguishes itself from siblings like ai_visibility_check (single entity) and compare_entities (generic comparison) by specifying the use of AI visibility probes and competitive benchmarking.

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 use case ('competitive AI-marketing audits') and an example question, helping the agent understand when to use it. However, it does not explicitly mention when not to use it or suggest alternative tools among siblings, leaving some ambiguity for edge cases.

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

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

The description adds significant context beyond annotations: it details the return structure, explains partial failures ('sources_failed will list it if it times out, the rest still returns'), and mentions a specific latency behavior ('bundlephobia's first measurement on a new version can take 5-30s'). No contradiction with annotations.

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

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

The description is a single paragraph but well-structured, front-loading the main purpose, then covering usage, return, ecosystem limitations, and behavior. Every sentence adds value, though it is moderately long.

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 (composite check, multiple sources, no output schema), the description thoroughly explains the return value fields, partial failure behavior, ecosystem restrictions, and latency. All relevant context is provided.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds that scoped packages are accepted for 'package' and that 'version' defaults to latest, but these are already in the schema. Baseline 3 is appropriate.

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

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

The description clearly states it performs a composite check on an npm package, aggregating data from deps.dev and bundlephobia. It distinguishes from siblings by specifying the exact use case and scope (npm only).

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

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

The description explicitly says 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me"'. It also clearly states when not to use: 'NPM ecosystem only in v1; PyPI / Maven / Cargo / Go fall under deps.dev:version directly', providing an alternative.

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

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

Goes well beyond annotations. Describes input limits (200K chars with truncation and flag), embedding model (BGE-base-en), windowing (500-char overlapping), and return format (passages with offsets and similarity scores). 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?

Well-structured with the main action upfront. Each sentence adds value, though slightly verbose with technical details. Could be shortened 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 no output schema, the description sufficiently explains return values (passages with offsets, scores, truncation flag). Covers all essential behavioral aspects for effective agent use.

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

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

Schema has 100% coverage, but description adds significant value: specifies max chars for text, gives example queries, and notes default for limit. This helps the agent understand 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 clearly states the tool performs semantic search inside a fetched record. It uses specific verbs and resources, and distinguishes itself from siblings by mentioning pairing with ask_pipeworx_grounded and alternatives like cramming into prompt.

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 fit in the prompt. It also pairs with another tool for grounding. However, it does not explicitly exclude other scenarios or provide when-not-to-use guidance.

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

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

Annotations indicate idempotentHint: true but the description doesn't elaborate on idempotency. However, it discloses behavioral traits like SMS cap, webhook auto-disable after failures, and that signed secrets are returned once. 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 a single packed paragraph that front-loads the purpose. It is concise but could benefit from slight structuring (e.g., bullet points for types). Still, 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 (nested objects, multiple types, delivery options), the description covers purpose, parameters, prerequisites, and constraints comprehensively. No output schema is needed as return value is stated.

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 has 100% coverage, but the description adds significant meaning by detailing type-specific params with examples (e.g., sec_8k items codes, delivery channel restrictions). This goes beyond simple schema definitions.

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

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

The description clearly states the tool creates a subscription to a live-data event stream and returns the subscription ID. It specifies the resource and action, distinguishing it from sibling tools like list_subscriptions and unsubscribe.

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

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

The description provides clear context: requires Pipeworx OAuth account, lists supported types with examples, and mentions delivery channels. It doesn't explicitly say when not to use this tool but the sibling names imply alternatives. The prerequisite about authentication is helpful.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds that results are drawn from a live catalog and include tool+argument shapes. No contradictions; description enriches agent's understanding of behavior.

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

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

Description is front-loaded with the key purpose and lists example phrases. While slightly verbose with many examples, each sentence adds value. Could be tightened, 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?

Despite lacking an output schema, the description fully explains what the tool returns (category-bucketed questions with tool+argument shapes) and gives context for when to use it first. For a simple tool with one optional parameter, this is complete.

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

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

Schema coverage is 100% (one optional string parameter 'topic'). Description adds value by listing example values and explaining the effect of omitting versus specifying a topic. Beyond schema, it clarifies the parameter's role in focusing the output.

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

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

Clearly states it returns category-bucketed example questions with exact tool+argument shape, and distinguishes itself as the onboarding entry point. Specific verb 'returns' and resource 'example questions' differentiate from sibling tools like 'discover_tools' or 'ask_pipeworx'.

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

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

Explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do' and provides usage patterns: 'Call with no arguments for the full spread, or pass topic...' This gives clear when-to-use and how-to-call 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?

Adds value beyond annotations: explains deactivation (not deletion) and that historical events remain accessible via recent_alerts. Annotations already indicate non-destructive mutation.

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 filler, essential information front-loaded.

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

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

For a simple tool with one parameter, the description covers purpose, usage constraint, and behavioral nuance. 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?

The only parameter 'id' is clearly described in schema, and the description adds that it is 'returned by subscribe,' linking to the counterpart tool. Schema coverage is 100%.

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 'Cancel a subscription by id.' Verb + resource is specific and distinguishes from sibling tools like subscribe and list_subscriptions.

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

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

Mentions ownership enforcement ('you can only cancel your own subscriptions') which is a key usage constraint. Does not explicitly state when not to use, 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?

Annotations provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, but the description goes far beyond by explaining the meaning of each verdict type, especially the critical distinction between could_not_verify and unsupported. It also discloses that the tool may fail (verification_error) and that it routes to different pipelines internally. This is rich behavioral context beyond the structured annotations.

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

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

The description is long but every sentence carries essential information: examples, routing logic, verdict semantics, error handling, and performance benefits. It is front-loaded with natural-language triggers and structured clearly. Slightly verbose, but justified given the tool's complexity and lack of an output schema.

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

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

With no output schema, the description fully compensates by explaining the verdict values, the actual value with citation, reasoning, and error semantics. It covers the tool's scope, internal routing, and edge cases (could_not_verify vs unsupported). For a tool of this complexity, the description is complete and self-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?

The input schema already documents both parameters with descriptions and examples, achieving 100% schema coverage. The description does not add additional parameter semantics beyond what the schema provides; it mentions tolerance in the context of callers but the schema already explains the override behavior. Since schema coverage is high, a baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: natural-language claim verification against authoritative sources. It gives specific trigger phrases like "fact check" and "verify the claim that", and the mention of verdict types (confirmed, refuted, etc.) sets it apart from generic query tools like ask_pipeworx or deep_research. The scope (company-financial vs any other claim) further distinguishes its 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?

The description explicitly says "Use whenever the agent needs to check whether something a user said is factually correct" and differentiates between company-financial claims (structured EDGAR path) and other claims (grounded pipeline). It also warns that could_not_verify means the check did not happen and must not be used as evidence, which is a critical usage guideline. This is clear, actionable, and effectively distinguishes it from siblings.

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