Czso Cz

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 valuable details: returns per-model {score, confidence, signals, raw_response} plus combined view, and notes that Anthropic probing requires a BYO key with direct billing. 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?

Description is concise and front-loaded with the primary purpose. Each sentence adds value: purpose, default behavior, optional key, return format, use cases. No wasted words.

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

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

For a tool with 4 parameters and no output schema, the description explains inputs and outputs well. It mentions per-model and combined view structure, though not formally defining return types. Still sufficiently complete for an agent to use correctly.

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

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

Input schema covers all 4 parameters with 100% coverage. The description adds meaning: default model, BYO key for Anthropic, context for disambiguation, and notes that `_apiKey` is passed straight through to api.anthropic.com. This enriches the schema without redundancy.

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 visibility on entities and returns scores 0-100 per model. It specifies default and optional models, distinguishing it clearly from siblings like 'bet_research' or 'compare_entities' which serve different purposes.

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

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

Explicitly suggests use cases (AI-marketing audits, brand checks, competitive monitoring) and explains when to provide `_apiKey` for Anthropic. Does not explicitly state when not to use, but context is clear and sufficient for an agent.

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

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

Annotations already indicate read-only, idempotent, open world. Description adds that it routes to many tools and returns citations, which extends behavioral context without contradiction.

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

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

Description is front-loaded with 'PREFER OVER WEB SEARCH', followed by scope and examples. Every sentence adds value, though slightly verbose. Well-structured.

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

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

Given the complexity (6 parameters all aliases, no output schema), the description covers purpose, usage, and output format (citations). Lacks detail on error handling or limits, but sufficient for typical use.

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

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

Schema coverage is 100% with descriptions for each alias parameter. The description does not add extra meaning beyond the schema (just says 'Your question or request'). Baseline score 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 routes questions to 3,300 tools across 737 sources, returning structured answers with citations. It distinguishes itself from web search by emphasizing authoritative structured data. Examples illustrate the range of queries.

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

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

Explicitly says 'PREFER OVER WEB SEARCH' and lists domains (SEC, FDA, etc.). Provides example queries and suggests use for factual questions. Lacks explicit 'when not to use' but the preference is strong.

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

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

The description thoroughly discloses behavior: fan-out examples, response shapes, resolver contract, parent event extraction, news fallback mechanisms, and safety checks for low-confidence/closed markets. It adds substantial context beyond annotations like readOnlyHint and idempotentHint.

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

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

The description is long but well-structured with clear section headings (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES, etc.). Front-loaded with core purpose, then detailed specifics. Slightly verbose but justified by tool 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?

No output schema exists, yet the description explains the complete response structure (result.market, result.analysis, result.evidence) and covers edge cases (low-confidence, closed, illiquid). All parameters, behaviors, and special cases are addressed.

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 schema descriptions already define parameters. The description adds extra context (e.g., depth options, include_raw effects on response size) and examples, elevating it above the 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?

The description clearly states the tool researches Polymarket bets by pulling Pipeworx data, specifying inputs (slug, URL, question) and outputs (evidence packet, market-vs-model comparison). It distinguishes from sibling tools like polymarket_edges or polymarket_arbitrage by being the comprehensive research 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 for "should I bet on X", "what does the data say about Y", or "is there edge in Z"' and provides safety warnings (e.g., inspecting match confidence). Could be improved with explicit when-not-to-use scenarios, but the context is clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, which the description reinforces. Additionally, the description adds important behavioral context: it returns actual most-recent FY filing (post-Run-6 fix), handles off-calendar fiscal years correctly, and sorts results by primary metric. 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 fairly long but front-loaded with the core purpose. Every sentence adds unique information (data sources, parameter details, return formatting, example use cases). While slightly verbose, it remains clear and well-structured.

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

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

Despite lacking an output schema, the description explains that the tool returns paired data with citation URIs, sorted by primary metric. It also explains the replacement of multiple lookups and handles edge cases (off-calendar fiscal years). For a multi-source comparison tool, this level of detail is highly 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?

The input schema has 100% coverage, but the description greatly enriches meaning. It explains that 'type' selects between company (financial data from SEC) and drug (adverse event data from FAERS), and details the 'values' parameter formatting: tickers/CIKs for companies, drug names for drugs. It also notes min/max items (2-5) and provides 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 states the tool compares 2-5 companies or drugs side by side, specifying exact data sources (SEC EDGAR for companies, FAERS/FDA for drugs) and the type of data retrieved (revenue, net income, adverse events, etc.). It also includes specific use cases like 'compare X and Y' or 'which is bigger', distinguishing it from single-entity tools like entity_profile.

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

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

The description explicitly calls out when to use the tool (comparison, ranking queries) and mentions it replaces 8-15 sequential lookups, implying a performance benefit. However, it does not explicitly state when NOT to use it or suggest alternative sibling tools (e.g., for single entities).

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint as safe, so the description doesn't need to repeat those. The description adds the nuance that this is catalog layer only, which aligns with annotations. No contradictions. Slightly less transparency on return format or performance, but sufficient given annotation coverage.

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

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

The description is remarkably concise: one sentence listing contents and a second sentence distinguishing from siblings. Every part earns its place with no wasted words.

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

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

Given the tool returns rich metadata with no output schema, the description lists many expected fields (description, keywords, indicators, dimension variants, selection rules, update periodicity, themes). This is sufficient for an agent to understand what the tool provides without over-specifying.

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

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

The single parameter 'kod' is described in the schema as 'Dataset id'. The description adds an example ('OBY05B03') and clarifies its source ('Get it from list_datasets'), which provides meaningful context beyond the schema.

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

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

The description clearly states it returns full catalog metadata by dataset ID, listing contents like description, keywords, indicators, dimension variants, selection rules, update periodicity, and themes. It distinguishes itself from siblings by specifying this is the catalog layer and directing to data_summary/get_data for actual numbers.

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 (get catalog metadata by kod) and when not (for actual numbers, use data_summary/get_data). Also indicates kod comes from list_datasets, providing a clear workflow.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds behavioral context by calling it 'cheap' and describing the returned fields, which goes beyond annotations without contradicting them.

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

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

Two sentences, no wasted words. First sentence lists return fields, second sentence gives usage guidance and version handling. Information is front-loaded 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?

Given no output schema, the description sufficiently explains what data is returned. Covers all necessary context for a summary tool with two simple parameters, including version resolution and use-before-get_data advice.

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 reinforces parameter semantics by providing an example dataset ID and clarifying that version defaults to latest from catalog if omitted.

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

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

The description clearly states the tool provides a cheap content summary for a ČSÚ dataset, listing specific fields like number of data cells, time range, per-dimension value counts, and timestamps. It distinguishes from the sibling tool get_data by mentioning it should be used before get_data to gauge dataset size.

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

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

Explicitly states 'Use this before get_data to gauge size, since full datasets can be large.' This provides clear when-to-use guidance and an alternative. Also notes version auto-resolution from catalog if omitted.

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

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

Annotations indicate read-only and idempotent behavior. The description adds key behavioral details: returns top-N relevant tools with full schemas and curated examples, and that results are ready for direct invocation without a second lookup. 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 moderately long but efficient: every sentence serves a purpose (purpose, usage guidance, parameter aliases, return details). It is well-structured and front-loaded with the core action.

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 fully explains what is returned (names, descriptions, full schemas with examples) and that results are directly callable. This is complete for a tool-discovery tool.

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

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

Schema coverage is 100%, but the description adds value by clarifying that multiple parameters (query, task, q, search, description) are aliases for the same main query, and that limit defaults to 20 with max 50. This enhances usability 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 the action ('Find tools by describing the data or task') and resource (tools), distinguishing it from sibling tools that are task-specific. It covers the exact purpose of discovering available 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 advises 'Call this FIRST when you have many tools available and want to see the option set', providing clear usage context. It lists domains where the tool is useful (SEC filings, FDA drugs, etc.), though it does not explicitly state when not to use it.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. Description adds return structure, notes about patents sunset, fallback logic, and data freshness warning. Provides useful behavioral context beyond annotations.

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

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

Front-loaded with purpose, but contains some technical implementation details (e.g., 'Run 6 fix landed real FY2025 numbers') that could be streamlined. 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 no output schema, description thoroughly covers return fields, data sources, edge cases (patents sunset), and limitations. Provides complete context for an AI agent to understand what the tool returns and its caveats.

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 description adds value: explains type enum only supports 'company', value formats (ticker or CIK), and explicitly states names not supported, directing to resolve_entity. Adds important usage nuance.

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 'Get everything about a US public company in one call.' Specifies verb (get), resource (US public company), and distinguishes from sibling tool resolve_entity by noting that names are not supported.

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 when to use: when user asks 'tell me about X', 'research Acme', etc. Also states when not to use: names not supported, recommends resolve_entity first. Provides clear context and 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?

Description aligns with annotations (destructiveHint=true, idempotentHint=true) but adds no further behavioral context beyond what annotations already 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 concise sentences, front-loaded with purpose, followed by usage guidance. No unnecessary words.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose, usage, and pairing with siblings, making it 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 already fully describes the 'key' parameter as 'Memory key to delete'. Description does not add additional meaning beyond the schema.

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

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

Description clearly states 'Delete a previously stored memory by key', which is a specific verb and resource. It effectively 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?

Explicitly provides when to use: 'when context is stale, the task is done, or you want to clear sensitive data'. Also instructs to pair with remember and recall.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, etc. The description adds behavioral details: it 'fetches the page, extracts title/description/key links, and emits the standard llms.txt markdown format.' It also states the output is 'ready to drop at site-root/llms.txt'.

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

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

Three concise sentences: first states purpose, second explains process briefly, third lists use cases. No redundant words, front-loaded with key action.

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

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

Given the simple tool with two parameters and no output schema, the description covers purpose, process, output format ('single text blob'), and use cases. Sufficient 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?

Schema coverage is 100% with both parameters (url, max_links) described. The description only mentions 'default 25, max 50' for max_links, which is already in the schema. No additional semantic value beyond schema.

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

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

The description clearly states the tool generates an llms.txt file for any URL, using specific verbs ('generate', 'fetches', 'extracts') and resource ('llms.txt file'). It distinguishes from sibling tools like 'scan_competitor_ai_presence' by its unique output 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?

The description lists explicit use cases: 'getting a client's site indexed by AI, drafting llms.txt for your own project, or auditing how an AI crawler would see a competitor.' It does not mention when not to use or alternatives, but the use cases are clear.

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

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

Goes beyond annotations by stating the tool returns a full cross-product, often large (hundreds of thousands of cells, 1MB+), and that labels are mostly Czech-only. No contradiction with readOnlyHint etc.

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

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

Two sentences plus a note, front-loaded with the core purpose. Every sentence adds value without redundancy.

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

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

Covers all essential aspects: purpose, parameter behavior, size warning, and prerequisite tool. Even without output schema, the JSON-stat format is adequately described.

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

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

Schema coverage is 100%, but description adds meaningful value: 'verze' auto-resolves, 'kod' sourced from list_datasets, and 'lang' notes Czech-only labels. The addition is helpful but not critical.

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

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

The description explicitly states the action ('Fetch'), the resource ('ČSÚ dataset'), and the output format ('JSON-stat 2.0'). It distinguishes itself from sibling tools like 'data_summary' by focusing on actual observations/values.

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

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

Provides clear directive: 'call data_summary first to check pocetUdaju' to avoid large payloads. Also notes version auto-resolution, guiding the agent on optional parameters.

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

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

Annotations already indicate readOnly, idempotent, and non-destructive behavior. The description adds valuable behavioral details: no server-side search, catalog size (~781 datasets), and substring matching against Czech title. This complements annotations well.

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: first states purpose and return fields, second adds critical filtering and paging details. Every word is useful and front-loaded.

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

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

No output schema, but description explains the return fields (id, version, title, status, time/territory levels). It also covers catalog size, filtering behavior, and paging—sufficient for a browsing 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?

All 3 parameters have schema descriptions (100% coverage). The description reinforces parameter meaning by adding context (e.g., 'the API has no server-side search' for query, defaults for limit/offset) 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 browses the Czech Statistical Office open-data catalog, specifies returned fields (id, version, title, etc.), and distinguishes it from siblings like dataset_detail and get_data by focusing on catalog exploration.

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

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

The description explains filtering via case-insensitive substring and paging with limit/offset, but does not explicitly guide when to use this tool versus alternatives (e.g., dataset_detail for specifics). The context is clear enough for an agent to infer usage.

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

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

Describes rate limits (5 per identifier per day), notes it doesn't count against tool-call quota, and states it's free. This adds behavioral context beyond the annotations, which only indicate non-destructive/non-readonly/non-idempotent.

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

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

Highly concise: first sentence states purpose, then conditions, then operational details. No unnecessary words. Front-loads key information. Every sentence adds value.

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

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

Given the tool's simplicity (3 params, no output schema), the description covers all necessary aspects: purpose, usage scenarios, parameter guidance, and constraints. Complete for effective tool selection and 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 description coverage is 100%, so baseline is 3. The description adds meaningful guidance on parameter usage (e.g., 'don't paste the end-user's prompt', 'be specific'), enhancing the schema's enum descriptions. This additional context justifies a 4.

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

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

The description clearly states it's for giving feedback about broken, missing, or needed features, listing specific categories (bug, feature, data_gap, praise). It differentiates itself from sibling tools by being a feedback channel.

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

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

Explicitly tells when to use each feedback type (bug for wrong data, feature for missing tools, etc.) and what not to do (don't paste end-user prompt). Also mentions rate limits and that it's free.

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

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

Annotations already provide readOnly/openWorld/idempotent hints. Description adds derivation method (CF analytics-engine), privacy guarantee (no PII), and cache timing (5min-1h). No contradictions.

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

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

Four sentences, front-loaded with main result. Every sentence adds unique value: purpose, use cases, data source, caching. 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 read-only tool with no output schema, the description fully covers purpose, usage, parameter semantics, and behavioral traits. No gaps remain.

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

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

Only one parameter 'window' with enum values. Description explains each window's semantic effect (shorter for hot, longer for steady-state) and notes default, adding value beyond schema's enum description.

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

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

Clearly states it returns top tools, packs, and call volume over recent windows. Distinct from all siblings; no other tool provides aggregated usage trends.

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?

Lists three concrete use cases (discovering hot data sources, confirming canonical tool, aligning use case). Does not explicitly state when not to use or name alternatives, but context is clear.

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

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

Annotations include readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds extensive behavioral detail: it walks child markets, checks ordering, computes partition_check, applies similarity and filter rules, and describes the response structure. No contradiction with annotations.

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

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

The description is dense but well-structured with clear mode separation and enumerated details. It is front-loaded with the main purpose. While lengthy, every sentence adds value for a complex tool.

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

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

Despite no output schema, the description fully explains the response structure (opportunities array with fields) and covers all aspects: modes, logic, filters, and success conditions. No gaps remain for an agent to understand usage.

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

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

Schema coverage is 100% with both parameters documented. The description adds significant meaning: it explains the event mode's partition check and cross-event mode's similarity anchor, and provides example inputs. This goes well 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 states exactly what the tool does: find arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It clearly distinguishes two modes (event and topic) and explains their differences, 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 explicitly tells when to use each mode (event for a single event slug, topic for a seed question) and provides examples. It does not explicitly mention when not to use the tool or compare to siblings, but the context is clear enough for an AI agent to decide.

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

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

The annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint) are consistent with the description's scanning and read-only behavior. The description additionally reveals caching: 'Cached 1h at the KV level keyed on all knobs.' It also details the diagnostic fields like _diagnostics, allowing callers to see why segments might be empty. This adds valuable behavioral context beyond the annotations.

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

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

The description is excessively long and dense, containing highly technical details about model families, segments, and diagnostics. While comprehensive, it lacks conciseness and front-loading; the first sentence is clear, but the rest buries the key points in a wall of text. An AI agent would benefit from a more structured, shorter overview.

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

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

Given the complexity of nine parameters and no output schema, the description is remarkably complete. It explains the response structure (by_segment), the three segments in detail, the edge fields, diagnostics, and even edge cases like Fed bets. It provides enough information for an agent to understand what the tool returns and why, without needing an output schema.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds some extra context, such as explaining that 'edge is evaluated NET of slippage' and clarifying the min_partition_leg_kelly parameter's behavior. However, most parameter descriptions in the schema are already detailed, and the description does not significantly enhance understanding beyond the schema.

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

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

The description clearly states the tool's purpose: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It is built for 'what should I bet on today' and explicitly distinguishes from alternatives by explaining its focus on Pipeworx data disagreement, unlike sibling tools like polymarket_arbitrage or polymarket_kalshi_spread which target cross-platform arbitrage.

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

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

The description provides clear context for when to use the tool: for opportunistic betting based on model-driven signals. It mentions that Fed bets are excluded from ranking due to unreliable signals, indicating a limitation. However, it does not explicitly name sibling tools as alternatives or state when not to use it, leaving some ambiguity.

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

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

Annotations already indicate readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. The description adds significant behavioral context: it explains the response structure (leg-by-leg prices, matched spreads), the safety fields (compatibility_warning, temporal_alignment, skipped counters), and importantly that the tool can indicate non-equivalent bet shapes and temporal misalignment. 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 comprehensive but quite verbose, with a dense paragraph structure. While every sentence adds value, it could be better organized (e.g., sections for purpose, modes, response, safety). It is not concise, but it is thorough.

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

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

Given no output schema, the description thoroughly explains the response format including leg-by-leg prices, matched spreads, and all safety fields (compatibility_warning, temporal_alignment, skipped counters). It also covers edge cases like non-equivalent bet shapes and temporal misalignment. The tool's complexity is fully addressed.

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

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

Schema coverage is 100% with good descriptions for each parameter (e.g., topic lists allowed values). The description adds further context by explaining the two modes and how parameters override each other, and provides examples in the schema. Since the schema already does extensive work, the description's extra value is moderate, earning a 4.

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

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

The description clearly states 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' and differentiates two modes (topic vs explicit). This distinguishes it from sibling tools like polymarket_arbitrage or polymarket_edges, which focus on other aspects.

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, how to use it (two modes), and important caveats: 'Real cross-venue spreads are rarer than the macro-shortcut list suggests' and warnings about compatibility and temporal alignment. It also explains safety fields that indicate when spreads are not meaningful.

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 idempotentHint: true, indicating safe read operation. The description adds behavioral context: 'Scoped to your identifier (anonymous IP, BYO key hash, or account ID).' No contradictions detected. It could mention return behavior for missing keys, but overall sufficient.

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

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

The description is three sentences: first defines core functionality, second provides usage examples and context, third adds scoping and sibling pairing. It is front-loaded, every sentence adds value, and no unnecessary words.

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

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

Given no output schema, the description does not explain the return format, such as what happens if the key doesn't exist or the structure of the returned object. It covers purpose, usage, and scoping well, but for a retrieval tool, return behavior is important. It is adequate but not fully 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?

The only parameter 'key' is fully described in the schema (100% coverage). The description adds value by explaining that omitting the key lists all saved keys, which is not explicit in the schema examples. This clarifies the optional nature and dual use case.

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 value previously saved via remember, or list all saved keys (omit the key argument).' It specifies the verb 'retrieve/list', the resource (memory values/keys), and distinguishes from sibling tools like remember and forget through pairing language.

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 when to use: 'Use to look up context the agent stored earlier...without re-deriving it from scratch.' It implies alternatives by pairing with remember and forget, though it doesn't explicitly state when not to use this tool. The guidance is clear and contextual.

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

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

The description discloses the fan-out to multiple data sources (SEC EDGAR, GDELT→GNews fallback, USPTO), explains fallback behavior and potential failures (USPTO soft-fails until reactivated), and describes the output structure. Annotations already provide readOnlyHint, idempotentHint, etc., and the description adds significant behavioral context beyond annotations.

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

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

The description is detailed yet concise, covering purpose, usage, data sources, parameters, and output in a few sentences. It is well-structured with clear sections and a helpful note on alternatives. Slightly verbose but appropriate for the 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?

Despite the lack of an output schema, the description thoroughly covers essential aspects: tool purpose, parameter semantics, data sources and fallbacks, output structure (changes grouped by source, total count, citations), limitations (USPTO), and when to use an alternative tool. It fully equips an agent to invoke the tool correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning beyond the schema by explaining the 'since' parameter accepts relative shorthand ('7d', '30d', '3m', '1y') with examples, and clarifies that 'value' can be ticker or CIK. This extra detail improves parameter understanding.

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

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

The description clearly states 'What's new with a company in the last N days/months?' and provides example use cases like 'what's happening with X', 'updates on Y', and 'change-monitoring'. It explicitly distinguishes from the sibling tool 'entity_profile' by specifying when to use each.

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

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

The description explicitly states when to use this tool: for news, updates, and change monitoring. It also explicitly says when not to use it: 'Use entity_profile instead when you want the static profile… regardless of window.' This provides clear guidance on alternatives.

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

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

Adds context beyond annotations: memory scope, persistence duration (24h for anonymous, persistent for authenticated). 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?

Reasonably concise (4 sentences), front-loaded with purpose, then usage, then details. Slightly verbose but 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?

Covers purpose, usage, persistence, scoping, and related tools. No output schema needed for simple key-value store. Complete for this complexity level.

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

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

Schema coverage is 100%, so baseline is 3. Description does not add param-specific info beyond what schema provides (key, value), so no extra value.

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

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

Clearly states 'Save data the agent will need to reuse later' and provides concrete examples (ticker, address, preference). Mentions pairing with recall and forget, distinguishing itself from siblings.

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

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

Explicitly says 'Use when you discover something worth carrying forward' and contrasts with recall and forget. Could clarify when not to use it, but overall provides good guidance.

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

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

The description adds context beyond annotations (readOnlyHint, openWorldHint, etc.) by explaining that each call cascades through several lookup endpoints and replaces manual lookups. It details return formats for each type, including citation URIs, which the annotations do not provide. No contradictions with annotations.

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

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

The description is two paragraphs, with the first sentence immediately stating the core purpose. It is informative without being verbose, though some might prefer a bulleted list for the types. Overall, it is well-structured and front-loaded.

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

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

Given no output schema, the description fully explains the return values for each entity type, including citation URIs. It covers input formats, disambiguation, and the replacement of manual lookups. This is complete for the tool's complexity.

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

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

Schema coverage is 100% and each parameter has a description in the schema. The description adds significant meaning by explaining the accepted input formats and return values for each type (e.g., 'company returns ticker + 10-digit CIK'). This goes beyond the schema's brief 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 uses a specific verb ('Resolve') and resource ('user-spoken name to canonical/official identifiers'), and clearly distinguishes the tool's purpose from siblings by stating its role as a name-to-ID converter. It lists supported types (company, drug) with their outputs, making the purpose unambiguous.

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

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

The description explicitly states 'Use FIRST when you have a name but need an ID,' providing clear timing. It also mentions that the tool replaces 2-3 manual lookups, implying efficiency. However, it does not explicitly mention when not to use it or alternatives among the sibling tools.

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

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

The description adds value beyond annotations by revealing that the tool calls 'ai_visibility_check' internally and returns a ranked list. However, it omits behavioral details such as the requirement for an API key when using the 'anthropic' model, which is only in the schema but not in the description. With annotations already declaring the tool as read-only and idempotent, the description provides moderate additional context.

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

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

The description is concise (four sentences) and front-loaded with the core purpose. Every sentence adds value: purpose, method, use case, and output format. No redundant or vague wording is present.

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

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

Given the tool's complexity (4 parameters, 1 required, no output schema), the description covers the key aspects: what it does, how it works (probes with another tool), and the output structure (ranked list with score, confidence, signal density). It lacks explicit mention of the allowed entity count range (2-8) and the ability to omit the 'models' parameter, but these are documented in the schema.

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

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

While schema coverage is 100%, the description clarifies the roles of entities: the first entry is treated as the 'subject' and the rest as competitors. This adds meaningful context beyond the schema descriptions, helping the agent understand how to structure the input. The description also notes that the 'context' parameter disambiguates common names.

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: comparing AI visibility across multiple entities side-by-side. It specifies the verb 'compare', the resource 'AI presence', and explicitly differentiates from sibling tools like 'ai_visibility_check' by focusing on multiple entities in a single operation.

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

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

The description provides a clear use case ('competitive AI-marketing audits') and implies when to use this tool over alternatives by mentioning it compares multiple entities, whereas 'ai_visibility_check' is likely for single entities. However, it does not explicitly state when not to use it or list alternative tools for single-entity scenarios.

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

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

Description details fan-out behavior (deps.dev + bundlephobia), return structure (summary block, per-advisory, links, alternatives), and failure mode ('sources_failed' when bundlephobia times out). This adds significant behavioral context beyond the annotations (readOnly, idempotent), which already indicate safety.

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

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

Single paragraph is information-dense without waste, but could benefit from bullet points for clarity. Still efficient and front-loaded with the core purpose.

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

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

Given 100% schema coverage, no output schema, and tool complexity (6 data points plus alternatives), the description fully explains return fields, ecosystem limits, and failure behavior. No gaps remain.

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

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

Schema covers both parameters with descriptions (100% coverage). The description adds that scoped packages are accepted and version defaults to latest, which is useful but minimal. Baseline 3 with slight improvement to 4.

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

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

The description explicitly states 'Composite "should I add this npm package to my project" check' and lists exact coverage (license, advisories, bundle size, etc.). This clearly distinguishes it from siblings like scan_competitor_ai_presence or entity_profile, which operate on different domains.

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

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

Provides explicit usage triggers ('is X safe / popular / small', 'what does adding lodash cost me') and ecosystem constraints (NPM only, mentions deps.dev for others). Also explains partial failure handling and first-measurement delay, giving clear when-to-use and when-not-to-use context.

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

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

Annotations already indicate readOnly, openWorld, idempotent, non-destructive. The description adds that it returns a verdict with structured data and citations, and replaces multiple sequential calls. It also specifies the authoritative source (SEC EDGAR + XBRL), providing behavioral context beyond annotations.

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

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

The description is moderately concise, front-loading the action and then providing necessary details. It could be slightly more concise, but every sentence adds value: purpose, usage, domain, return value, and benefit.

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 single required parameter and no output schema, the description fully explains the tool's capabilities: it returns a verdict with structured data, actual value, citation, and percent delta. It also specifies the domain and authoritative source. The context is complete for an AI agent to invoke the tool correctly.

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

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

The single parameter 'claim' is well-described in the schema with a natural-language example. The description adds usage examples and context about the domain, which adds value beyond the schema. Schema coverage is 100%, so baseline is 3, but the examples boost it to 4.

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

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

The description clearly states the tool's purpose: fact-check natural-language claims against authoritative sources, specifically for company-financial claims. It uses specific verbs like 'validate', 'confirm', 'refute', and specifies the resource (SEC EDGAR + XBRL). It distinguishes itself from siblings by being a specialized verification 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?

The description explicitly tells when to use the tool (checking if a user's statement is true, with example phrasings) and specifies the domain (company-financial claims). It does not explicitly state when not to use it or suggest alternatives for non-financial claims, but the domain limitation is clear.

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