wikiviews

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint true, and destructiveHint false. The description adds valuable behavioral context: the default model is free Workers AI Llama-3.3-70b, and passing _apiKey probes Anthropic with cost implications (BYO key). It also describes the return structure per model. No contradictions with annotations.

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

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

The description is two sentences, front-loaded with the core purpose, then adding details on defaults and return structure. Every sentence provides essential information, no filler or redundancies.

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 covers return values sufficiently (per-model {score, confidence, signals, raw_response} + combined view). The tool is well-documented for its complexity, covering required parameters, optional models, authentication, and disambiguation context. No significant gaps.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema: it explains that the default model is Workers AI (free), that _apiKey is needed for Anthropic, and that context helps disambiguate. It clarifies parameter roles but does not add extensive new detail beyond the schema's own 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 it probes LLMs for knowledge about a brand/product/topic and scores visibility (0-100) per model. It specifies the verb 'probe' and resource 'LLMs for what they know', making the purpose unambiguous. It distinguishes from siblings by being specifically about AI visibility audits, unlike other tools like 'compare_entities' or 'scan_competitor_ai_presence'.

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

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

The description provides explicit use cases: 'AI-marketing audits, pre-launch brand checks, competitive monitoring.' It also explains when to use the optional _apiKey for Anthropic. However, it does not explicitly state when not to use this tool or mention alternatives among siblings, missing a clear exclusion clause.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes key traits: the tool selects the best data source and fills arguments automatically, implying it handles tool orchestration internally. However, it lacks details on potential limitations, such as rate limits, authentication needs, error handling, or the types of data sources available, which are important for a tool that performs automated queries.

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 core purpose in the first sentence, followed by explanatory details and examples. Every sentence adds value: the second explains the automation mechanism, the third highlights the benefit of no manual tool selection, and the examples concretely illustrate usage. It is appropriately sized with no redundant or vague phrasing.

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 (automated querying with internal tool selection) and lack of annotations or output schema, the description is moderately complete. It covers the purpose, usage, and parameter semantics well, but does not address behavioral aspects like response format, error conditions, or data source limitations. This leaves gaps for an AI agent to fully understand how to invoke and interpret results from this tool.

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

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

The input schema has 100% description coverage, with the 'question' parameter documented as 'Your question or request in natural language.' The description adds value by emphasizing 'plain English' and providing examples like 'Look up adverse events for ozempic,' which clarifies the expected format and scope beyond the schema. However, it does not detail constraints or best practices for parameter usage, so it meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Ask a question in plain English and get an answer from the best available data source.' It specifies the verb ('ask'), resource ('answer'), and mechanism ('Pipeworx picks the right tool, fills the arguments'), distinguishing it from sibling tools like discover_tools or recall by emphasizing natural language querying without manual tool selection.

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

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

The description provides clear context on when to use this tool: for asking questions in plain English to get automated answers, eliminating the need to browse tools or learn schemas. It includes examples like 'What is the US trade deficit with China?' to illustrate appropriate use cases. However, it does not explicitly state when not to use it or name alternatives among siblings, such as for specific data retrieval tasks that might require direct tool invocation.

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 key behavioral traits beyond annotations: it resolves the market, classifies the bet, fans out to appropriate data packs, and returns an evidence packet with a comparison. This aligns with annotations (readOnlyHint=true, openWorldHint=true, destructiveHint=false) and adds context about the multi-step process. Minor gap: it doesn't detail the exact format of the evidence packet or comparison, but overall it is adequate.

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 of moderate length (about 4-5 sentences). It front-loads the primary action but then includes dense details about classification and fan-out. While all information is relevant, the structure could be improved by breaking it into concise points or using bullet lists. It is not verbose but could be more 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 the tool's moderate complexity (2 parameters, no output schema, no nested objects), the description provides a good level of completeness. It explains the input format, the internal process (resolve, classify, fan-out), and the output (evidence packet + market-vs-model comparison). While the output structure is not fully detailed, the description is sufficient for an agent to understand the tool's function and when to invoke it.

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

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

Schema description coverage is 100%, so the schema already provides clear parameter descriptions. The description reinforces that 'market' can be a slug, URL, or question text, and mentions the 'depth' default, but adds no new semantics beyond the schema. Baseline score of 3 is appropriate since the description does not compensate for any missing schema detail.

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

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

The description clearly states the tool's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies the inputs (slug, URL, question text) and the output (evidence packet plus market-vs-model comparison). The verb 'research' and resource 'Polymarket bet' are specific, and the description distinguishes it from sibling tools like ask_pipeworx by focusing on bets and data fan-out.

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 for "should I bet on X?", "what does the data say about this Polymarket market?", or "is there edge in this bet?".' It also highlights that this is the 'core demo product' and that agents using it 'convert better,' implying it's preferred over discovering packs manually. However, it does not explicitly state when not to use it or mention alternative tools for similar tasks, which would improve the score.

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?

No annotations are provided, and the description does not disclose behavioral traits such as read-only nature, authentication needs, rate limits, or potential side effects. It mentions output format but not operational behavior, leaving the agent with incomplete understanding.

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 two sentences, front-loaded with the core action 'Compare 2-5 entities side by side in one call.' Every sentence adds value, and there is no 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 moderate complexity (two entity types, multiple entities), the description covers key aspects: allowed entities, data fields for each type, output format with URIs, and efficiency. It lacks detailed return structure, but the schema and clear purpose compensate. Without an output schema, a bit more detail on the return format would improve completeness.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds context by explaining the data returned for each entity type and the efficiency benefit, but does not introduce new parameter semantics beyond the schema.

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

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

The description clearly states the tool compares 2-5 entities side by side, specifying two entity types and the data returned for each. It distinguishes itself from sibling tools like 'get_article_views' by offering multi-entity comparison in a single call.

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

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

The description indicates when to use the tool (comparing 2-5 entities) and highlights efficiency over sequential calls. However, it lacks explicit when-not scenarios or references to alternative sibling tools, though the purpose is self-evident.

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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool returns 'the most relevant tools with names and descriptions,' which adds context about output format. However, it lacks details on rate limits, error handling, or performance characteristics, leaving gaps for a tool with potential high usage.

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 core purpose in the first sentence, followed by usage guidance, with zero wasted words. Both sentences earn their place by providing essential information without redundancy, making it highly 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 the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is mostly complete. It covers purpose and usage well but lacks details on behavioral aspects like error handling or output structure, which would be beneficial for a discovery tool in a large catalog.

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

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

Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain query formatting or limit implications), resulting in a baseline score of 3 as the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with specific verbs ('Search the Pipeworx tool catalog') and resource ('tool catalog'), and explicitly distinguishes it from siblings by emphasizing its role in finding tools among 500+ options, unlike the sibling tools which focus on retrieving specific data views.

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 guidelines: 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task.' This clearly indicates when to use it (for discovery in large catalogs) and implies alternatives are not needed for initial tool discovery, though it doesn't name specific 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?

No annotations provided, so description carries full burden. It discloses the output format (pipeworx:// citation URIs) and confines to read-side data retrieval, but does not explicitly state it is read-only or mention potential rate limits. Still, it provides good behavioral context for a query tool.

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 convey purpose, contents, output format, and sibling differentiation without redundancy. Each sentence earns its place; 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 the complexity (multiple data sources), description is complete on purpose, constraints, and alternatives. Lacks details on output structure beyond URIs and potential size limits, but overall adequate for an agent to select 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?

Input schema has 100% coverage with descriptions for both parameters (type as enum with future plans, value as ticker/CIK with name resolution hint). Description reinforces the value parameter usage but adds no new structural meaning beyond schema, meriting the baseline score.

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

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

Description clearly states it returns a full profile across Pipeworx packs for an entity, specifically for type='company', listing included data sources (SEC filings, XBRL, patents, news, LEI). It distinguishes itself from siblings like resolve_entity and compare_entities.

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 not to use (for federal contracts, call usa_recipient_profile directly) and prerequisites (use resolve_entity if only have a name). Also notes it replaces 10–15 sequential calls, highlighting efficiency.

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?

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a deletion operation, implying it's destructive, but doesn't specify whether deletion is permanent, reversible, requires specific permissions, or has side effects. For a destructive tool with zero annotation coverage, this is a significant gap.

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, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately scannable and understandable.

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 destructive tool with no annotations and no output schema, the description is incomplete. It doesn't explain what happens after deletion (e.g., confirmation message, error if key doesn't exist), behavioral constraints, or how this tool fits with siblings like 'recall' and 'remember'.

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

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

Schema description coverage is 100%, so the schema already documents the single 'key' parameter fully. The description adds no additional semantic context beyond what's in the schema (e.g., what constitutes a valid key, format examples). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the verb ('Delete') and resource ('a stored memory by key'), making the purpose immediately understandable. It doesn't explicitly distinguish from sibling tools like 'recall' or 'remember', but the action is specific enough to imply differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives like 'recall' (which likely retrieves memories) or 'remember' (which likely stores them). The description only states what it does, not when it's appropriate or what prerequisites might exist.

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

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

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description details the internal process: fetches page, extracts title/description/key links, and outputs standard markdown format. 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 with two sentences, front-loading the purpose and following with use cases. It is efficient but could be slightly more terse 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 two parameters, no output schema, and annotations covering safety, the description adequately explains output format and use cases. It is complete enough for an agent 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%, so the schema already documents both parameters (url and max_links). The description does not add significant semantic meaning beyond what the schema provides, resulting in baseline score.

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

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

The description clearly states the tool generates a production-ready llms.txt file for any URL, specifying the verb (generate), resource (llms.txt), and context (for AI crawlers). It distinguishes itself from sibling tools, none of which perform this function.

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

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

The description lists explicit use cases for indexing sites, personal projects, and competitor auditing, providing clear context. It does not exclude alternative tools or state when not to use, but the context suffices.

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?

With no annotations provided, the description carries full burden. It discloses the date format constraint (YYYYMMDD) which is useful behavioral context, but doesn't mention rate limits, authentication needs, response format, pagination, or error conditions. The description doesn't contradict any annotations.

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

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

Two sentences with zero waste. First sentence states purpose clearly, second sentence provides critical format requirement. Perfectly front-loaded and appropriately sized for this 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?

For a read-only query tool with 100% schema coverage but no output schema, the description is adequate but could be more complete. It doesn't describe the return format (daily counts structure) or potential limitations, which would be helpful given the lack of 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 the schema already fully documents all three parameters. The description adds the date format requirement which is already covered in the schema descriptions. No additional parameter semantics beyond what the schema provides.

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

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

The description clearly states the specific action ('Get daily pageview counts'), resource ('for a specific Wikipedia article'), and scope ('over a date range'). It distinguishes from sibling tools by focusing on individual article views rather than project-level views or top articles.

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

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

The description implies usage context through the date range requirement but doesn't explicitly state when to use this tool versus alternatives like 'get_project_views' or 'get_top_articles'. No guidance on exclusions or prerequisites is provided.

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?

With no annotations provided, the description carries the full burden. It discloses the date format constraint ('Dates must be in YYYYMMDD format'), which is useful behavioral context. However, it doesn't mention other important traits like rate limits, authentication needs, pagination, or what the return format looks like (though there's no output schema).

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

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

The description is two sentences with zero waste. The first sentence states the purpose and scope, and the second provides a critical constraint. Every word earns its place, and it's appropriately sized for this simple 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?

Given the tool's moderate complexity (date-range query with no output schema), the description is adequate but has gaps. It covers the purpose and date format, but without annotations or output schema, it should ideally mention more about the return values (e.g., that it returns aggregate totals) or any limitations. It's minimally viable 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?

Schema description coverage is 100%, so the schema already fully documents both parameters (start and end dates with format examples). The description adds the date format requirement, but this is redundant with the schema. No additional parameter meaning is provided beyond what's in the schema.

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

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

The description clearly states the specific action ('Get aggregate daily pageview totals'), resource ('all of English Wikipedia'), and scope ('over a date range'). It distinguishes from sibling tools like get_article_views (which likely gets views for specific articles) and get_top_articles (which likely gets ranking data).

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

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

The description implies usage context by specifying 'over a date range' and 'for all of English Wikipedia', which suggests when to use this tool. However, it doesn't explicitly state when NOT to use it or mention alternatives like the sibling tools, leaving some guidance gaps.

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?

With no annotations provided, the description carries full burden. It discloses key behavioral traits: the tool returns ranked data, has a limit of 1000 articles, and focuses on view counts. However, it doesn't mention rate limits, authentication needs, data freshness, error conditions, or pagination behavior, leaving gaps for a read operation.

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

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

The description is two sentences with zero waste. The first sentence establishes purpose and scope, the second adds crucial behavioral details (limit and ranking). Every word earns its place, and information is front-loaded appropriately.

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 tool with 3 parameters and 100% schema coverage but no output schema, the description provides adequate purpose and scope. However, without annotations or output schema, it should ideally mention more about return format (e.g., structure of article data) or error handling to be fully complete for 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 description coverage is 100%, with all three parameters clearly documented in the schema. The description adds no parameter-specific information beyond implying date-based filtering. This meets the baseline of 3 when the schema does the heavy lifting, but doesn't provide additional semantic context.

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 specific action ('Get the most viewed Wikipedia articles') and resource ('Wikipedia articles'), with precise scope ('for a specific day', 'ranked by view count', 'up to 1000 articles'). It distinguishes from siblings by focusing on top articles rather than individual article views or project-level data.

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

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

The description implies usage context through 'for a specific day' and 'ranked by view count', suggesting this tool is for popularity analysis rather than detailed tracking. However, it doesn't explicitly state when to use this versus sibling tools like get_article_views or get_project_views, nor does it mention any prerequisites or 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?

With no annotations, the description carries full burden. It discloses a daily rate limit and indicates the tool is free. While it doesn't detail side effects or backend actions, the nature of a feedback tool makes this sufficient. The 'Free' note adds unexpected but useful context.

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

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

Three terse sentences: purpose, usage guidance, and rate limit. No redundancy. Every word earns its place, and the most critical info (what it does) appears first.

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 (feedback submission, no output schema), the description fully covers purpose, parameter usage, constraints (rate limit, prompt prohibition), and optional context. There are no obvious gaps for an agent to invoke the tool incorrectly.

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 beyond the schema: for the `type` field it reiterates enum meanings, for `context` it explains optional structured context, and for `message` it specifies typical length and a 2000-char limit. This enhances usability.

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 function: sending feedback (bug reports, feature requests, data gaps, praise). It explicitly names the target team and use cases, distinguishing it from sibling tools that focus on queries, articles, or memory.

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 specifies when to use the tool (for various types of feedback) and includes concrete advice: describe attempts in Pipeworx terms, avoid verbatim prompts, and notes a rate limit. It does not mention alternative tools, but siblings are functionally distinct, so this is not a gap.

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 value beyond annotations by explaining the data source (CF analytics-engine), privacy (no PII), output structure (pack, tool, count), and caching behavior (5min-1h). 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, with a clear first sentence summarizing purpose, followed by bullet-point use cases, and a closing technical note. 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?

Given the simple input schema (one optional parameter) and no output schema, the description fully covers what the tool does, what it returns, how it works, and its caching. It is complete for an agent to decide when to invoke it.

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 'window' has 100% schema coverage and the description adds semantic guidance: shorter windows for current trends, longer for steady-state demand. This enhances the enum choices.

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, packs, and call volume over a recent window, with specific examples of use. It distinguishes itself from sibling tools by focusing on trending data.

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

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

The description provides three explicit use cases for when to use the tool, offering clear context. It does not explicitly mention when not to use it or compare to alternatives, but the context is strong enough for an agent to understand its utility.

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, and destructiveHint=false, so the description's main job is to add context. It describes the return value ('Ranked opportunities with suggested trade direction + reasoning'), which is helpful. However, it could mention any rate limits or data freshness, but overall it is transparent.

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

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

The description is concise and well-structured, with front-loaded purpose, clear mode breakdowns, and examples. Every sentence serves a purpose 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?

Despite no output schema, the description adequately describes return value and behavior for both modes. It covers the tool's complexity (dual modes, cross-event search) completely, making it sufficient for an agent to decide when and how to invoke it.

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 value by explaining the two parameters in context, including when to use each and providing examples. This goes beyond the schema's short 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 starts with a specific verb-object pair ('Find arbitrage opportunities on Polymarket by checking for monotonicity violations') and clearly distinguishes the two modes, which differentiates it from sibling tools like 'polymarket_edges'.

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

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

The description explicitly states when to use each mode: event mode for a single event's child markets, topic mode for cross-event opportunities. It also provides a concrete example of when topic mode is necessary (separate events by cutoff dates), leaving no 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 read-only and non-destructive behavior. The description adds valuable behavioral context: it scans top markets, groups by asset, fetches price history once (efficiency), computes model probability, ranks by |edge|, and returns top N with suggested direction. 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 concise paragraph of about 5 sentences, front-loaded with the main action and supported by details. Every sentence adds value, and there is no redundancy or 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 the tool's complexity (3 parameters, no output schema), the description adequately covers how it works, its input parameters, and what it returns (top N ranked by edge magnitude with suggested direction). It is complete for the intended use case, though it could explicitly mention the output structure.

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

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

All three parameters (limit, window, min_edge_pp) are described in the schema with 100% coverage. The description adds value by explaining how each parameter fits into the overall algorithm (e.g., 'Top N edges to return after ranking'). It does not provide additional nuance beyond the schema, but the context is sufficient.

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: scanning high-volume Polymarket markets, computing a model probability, ranking by edge magnitude, and returning opportunities. It specifies the domain (crypto-price bets), the model used (lognormal from FRED + live coinpaprika), and the use case ('what should I bet on today'), effectively distinguishing it from siblings like 'polymarket_arbitrage'.

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

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

The description explicitly states the use case ('what should I bet on today') and that it helps users discover opportunities without manual browsing. However, it does not explicitly state when not to use it or directly compare to alternatives among the sibling tools, though the purpose is clear enough.

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

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

Annotations declare readOnlyHint, idempotentHint, etc. Description adds valuable context: explains why spread exists (different participant pools), describes two modes, and specifies return format. No contradiction.

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

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

Description is detailed but front-loaded with purpose, then modes, then returns. Slightly long for a concise definition, but every sentence adds value. Could be tightened slightly.

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

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

Despite no output schema, description fully explains return values: leg-by-leg prices and spread. Covers both modes and parameter overrides. Complete for a cross-venue arbitrage 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 covers all three parameters with descriptions. Description adds semantics by explaining how parameters interact (topic auto-fetches, explicit overrides) and provides examples for kalshi_event_ticker and polymarket_event_slug.

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 'Cross-venue spread between Kalshi and Polymarket', specifies two modes, and distinguishes this tool from siblings like polymarket_arbitrage by focusing on Kalshi vs Polymarket comparison.

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 guidance: use 'topic' for pre-mapped shortcuts or explicit tickers for custom pairings. Lists available topics. Does not explicitly state when not to use, but context is clear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the dual functionality (retrieve by key vs list all) and mentions persistence across sessions ('in previous sessions'), which is valuable context. However, it doesn't disclose potential limitations like memory size constraints, retrieval failures, or what happens when a non-existent key is provided. For a tool with zero annotation coverage, this leaves some behavioral aspects unclear.

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 perfectly concise and well-structured in two sentences. The first sentence establishes the core functionality with clear conditional logic. The second sentence provides important context about when to use the tool. Every word earns its place with zero redundancy or unnecessary elaboration.

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 moderate complexity (dual functionality, session persistence) and 100% schema coverage but no output schema or annotations, the description does well. It explains the two operational modes and persistence scope. However, without an output schema, it doesn't describe what gets returned (memory content format, list structure), leaving some uncertainty about the tool's complete behavior.

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 has 100% description coverage, so the baseline is 3. The description adds meaningful context by explaining the semantic implication of omitting the key parameter: 'omit to list all keys' and 'list all stored memories (omit key)'. This provides important usage guidance beyond the schema's technical description. However, it doesn't add details about key format, constraints, or 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's purpose with specific verbs ('retrieve', 'list') and resources ('previously stored memory', 'all stored memories'). It distinguishes from siblings like 'remember' (store) and 'forget' (delete) by focusing on retrieval operations. The description explicitly mentions retrieving context saved earlier in the session or previous sessions, which adds important scope information.

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 this tool vs alternatives: 'Retrieve a previously stored memory by key, or list all stored memories (omit key).' It clearly explains the two modes of operation (retrieve specific vs list all) and when to use each. While it doesn't name specific sibling alternatives, it provides complete operational guidance for the tool's intended use 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?

With no annotations provided, the description fully carries the behavioral transparency burden. It details the parallel fan-out to SEC EDGAR, GDELT, and USPTO for company entities, the supported input formats, and the return structure (structured changes, total_changes count, pipeworx:// URIs). There is no contradiction with missing 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 compact two-sentence structure, but it packs essential information: purpose, type-specific behavior, parameter details, return shape, and use cases. Every sentence serves a purpose 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?

For a tool with parallel fan-out to three data sources and no output schema, the description covers the main aspects: what it does, inputs, sources, and output components. It could mention error handling or limitations (e.g., only company supported), but it is largely complete for effective usage.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds value beyond the schema by explaining the 'since' format with examples (ISO date and relative), clarifying that 'value' accepts ticker or CIK, and emphasizing that 'type' only supports 'company'. This provides actionable guidance.

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

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

The description begins with a clear purpose: 'What's new about an entity since a given point in time.' It then elaborates with specific behavior for the 'company' type. This distinguishes it from sibling tools like 'entity_profile' (which provides a static profile) and 'compare_entities'. The verb-resource pair is specific and action-oriented.

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 'brief me on what happened with X' or change-monitoring workflows. It also explains the accepted 'since' formats (ISO date or relative). It lacks explicit exclusions or comparisons to alternative tools, but the use cases are clearly defined.

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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: the tool performs a write operation ('store'), specifies persistence characteristics ('authenticated users get persistent memory; anonymous sessions last 24 hours'), and implies it's for session-scoped data. It does not cover rate limits, error handling, or authentication requirements beyond persistence, but adds substantial value beyond basic purpose.

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 appropriately sized and front-loaded, with the core purpose stated first ('Store a key-value pair in your session memory'), followed by usage guidance and behavioral details. Both sentences earn their place by providing essential context without redundancy, making it efficient and well-structured.

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

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

Given the tool's moderate complexity (a write operation with persistence nuances), no annotations, and no output schema, the description is largely complete. It covers purpose, usage, and key behavioral traits like persistence rules. However, it lacks details on error cases (e.g., what happens if the key already exists) or return values, which would be needed for full completeness, especially without 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?

The input schema has 100% description coverage, with both parameters ('key' and 'value') well-documented in the schema itself. The description does not add any parameter-specific details beyond what the schema provides, such as examples or constraints not in the schema. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description adds no extra parameter semantics.

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

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

The description clearly states the tool's purpose with specific verbs ('store a key-value pair') and resource ('in your session memory'), distinguishing it from sibling tools like 'recall' (which retrieves) and 'forget' (which removes). It specifies the type of data that can be stored ('intermediate findings, user preferences, or context across tool calls'), making the purpose explicit and differentiated.

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 this tool ('to save intermediate findings, user preferences, or context across tool calls'), which implicitly distinguishes it from siblings like 'recall' (for retrieval) or 'get_article_views' (for analytics). However, it does not explicitly state when not to use it or name alternatives, such as using 'forget' to remove stored data, which prevents a perfect score.

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?

With no annotations, the description provides behavioral context: it handles company type, accepts multiple input formats, returns canonical IDs and URIs, and is a v1 with potential expansion. It lacks explicit read-only indication but implies it is a lookup with no side effects.

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

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

The description is two sentences, front-loaded with the main purpose, and every word adds value. No redundancy or 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 no output schema, the description adequately explains return values (ticker, CIK, company name, URIs). For a simple resolution tool with two params, it covers all necessary context for an agent to use it correctly.

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

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

Schema coverage is 100%, and the description adds meaning by explaining the enum 'company' as v1 and providing concrete examples for the value parameter (AAPL, CIK, company name), which goes beyond the schema descriptions.

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

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

The description clearly states the tool resolves an entity to canonical IDs, specifying it accepts ticker, CIK, or company name and returns ticker, CIK, company name, and URIs. It distinguishes itself from sibling tools like ask_pipeworx by being a focused resolution 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 says 'in a single call' and 'replaces 2–3 lookup calls', which implies when to use it for efficiency. It does not explicitly mention when not to use it, but among sibling tools, there is no other entity resolution tool, so 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 provide safety profile (readOnly, idempotent, not destructive). Description adds behavioral details: probes each entity via ai_visibility_check, ranks by score, surfaces most/least recognized, and explains API key requirement for Anthropic model.

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?

Five sentences, front-loaded with action and purpose. No redundant phrasing. Every sentence adds value without unnecessary detail.

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

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

No output schema present, but description explains return format: 'ranked list with score, confidence, signal density per entity'. All parameters and behavior fully covered. No gaps for a read-only comparison 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%, baseline 3. Description adds meaning beyond schema: explains 'entities' first entry as subject, 'models' default and conditional apiKey requirement, 'context' as shared disambiguation for 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?

Description uses specific verb 'compare' and resource 'AI visibility across multiple entities side-by-side'. Clearly distinguishes from sibling ai_visibility_check (single entity) and compare_entities (different scope).

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

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

Explicitly states use case: 'competitive AI-marketing audits' with example question. Implicitly indicates when not to use (single entity check). Lacks explicit mention of alternatives but context is sufficient for an AI 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?

No annotations are provided, so the description carries the full burden. It transparently states the limitation to v1 and the supported claim types (company-financial, US public companies). It also outlines the output format. It does not detail auth needs or rate limits, but for a read-only tool this is acceptable.

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 of three sentences, no wasted words. It front-loads the purpose, then scopes the domain, lists outputs, and ends with an efficiency note. Every sentence serves a 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?

For a single-parameter tool with no output schema, the description is quite complete. It covers input format, supported domain, return types, and value proposition. It could be improved by mentioning behavior for out-of-domain claims or error handling, but that is minor.

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 sole parameter 'claim' has full schema coverage with a description. The tool's description adds significant context: what types of claims are valid (company-financial, e.g., revenue/net income/cash) and provides two concrete examples. This goes beyond the schema and guides the agent on formulation.

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 specifies that the tool fact-checks natural-language claims against authoritative sources, explicitly states the domain (company-financial claims for public US companies), and lists the return values (verdict, extracted structure, actual value with citation, percent delta). This is specific and goes beyond a generic verb+resource.

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 that it replaces 4–6 sequential agent calls, implying efficiency gains for this specific task. However, it does not explicitly state when not to use it or provide alternative tools for out-of-scope claims. The context of sibling tools is available but not referenced in the description.

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