Usaspending

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, establishing safety. The description adds value by disclosing the return format (per-model {score, confidence, signals, raw_response} + combined view) and cost implications for Anthropic (BYO key). 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 (single paragraph) and front-loaded with the core action. Every sentence adds value, covering purpose, defaults, optional behavior, return format, and use cases. No redundant or vague statements.

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 specifies the return structure (per-model fields plus combined view). Combined with the schema (all params documented) and annotations, the description provides sufficient information for an agent to select and invoke the tool correctly for its intended use cases.

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

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

Input schema covers all four parameters with descriptions (100% coverage). The description adds context beyond the schema: it explains that omitting `models` defaults to workers-ai, that `_apiKey` is only needed if 'anthropic' is in models, and that `context` disambiguates entities. This additional information enhances 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 the tool probes LLMs for knowledge about a business/brand/product/topic and scores visibility per model. It specifies the default model (Workers AI Llama-3.3-70b) and optional Anthropic probing. The use cases (AI-marketing audits, pre-launch checks, competitive monitoring) further clarify purpose. It distinguishes from siblings like 'ask_pipeworx' and 'scan_competitor_ai_presence' by focusing on visibility scoring.

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 use contexts (AI-marketing audits, pre-launch brand checks, competitive monitoring) and explains how to invoke Anthropic probing via `_apiKey`. However, it does not explicitly state when to avoid this tool or mention alternatives among siblings, which would improve 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?

No annotations are provided, so the description carries the full burden. It explains that the tool internally selects the right tool and fills arguments, which is useful behavioral context. However, it does not disclose limitations, potential errors, or what happens if no suitable data source is found, leaving some uncertainty.

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 at two sentences plus examples. It front-loads the core purpose and provides concrete examples, with 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 the single parameter and no output schema, the description adequately explains what the tool does and how to use it. The examples cover different types of queries. A minor gap is that it doesn't mention that the answer may be sourced from a specific sibling tool, but this is implied by 'best available data source'.

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

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

Schema coverage is 100% with a single parameter 'question'. The description adds meaning by explaining that the question should be in natural language and providing examples, but the parameter description in the schema already covers the basic idea. No additional constraints or format details are needed.

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 accepts a natural language question and returns an answer from the best available data source. It distinguishes itself from sibling tools by acting as a general-purpose query interface rather than a specific data lookup.

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

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

The description explicitly tells when to use this tool: when you have a question in plain English and want the system to pick the right underlying tool. It provides examples and contrasts with browsing tools or learning schemas, implying not to use this when you need to manually specify a tool.

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

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

Discloses internal logic: resolves market, classifies bet, fans out to relevant packs, returns comparison. Annotations already indicate read-only and open-world nature; description adds valuable process details 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 four sentences, each adding value. Front-loaded with core action. Could be slightly shorter but is well-structured and informative.

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

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

No output schema, but description specifies return: evidence packet plus comparison. Given complexity of input variations and fan-out logic, description is complete enough for an agent to understand what to expect.

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

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

Schema description coverage is 100%, so baseline is 3. Description enhances by explaining market parameter accepts slug, URL, or question text with example. Depth parameter details are in schema; description adds overall context but not significantly more.

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

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

Clearly states the tool researches a Polymarket bet by pulling Pipeworx data. Provides specific examples of inputs (slug, URL, question text) and outputs (evidence packet, comparison). Distinguishes from siblings by focusing on Polymarket bets, a unique use case among the listed 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?

Explicitly lists use cases: 'should I bet on X?', 'what does the data say?', 'is there edge?'. Contrasts with alternative of manually discovering packs, indicating this tool is more efficient. Provides clear when-to-use guidance.

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

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

No annotations provided, so description carries the burden. It discloses return type (paired data + URIs) and data fields per type, but lacks details on error handling, authentication needs, or rate limits. Adequate but not exhaustive.

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

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

Three sentences, front-loaded with the core function, and every sentence adds value. No fluff, 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 mentions return format but does not detail the exact structure of paired data. It covers the main use cases, but missing error scenarios and more precise return format. Adequate for a simple 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 has 100% coverage with descriptions for both parameters. The description adds context about what fields are returned for each type, which is useful but does not significantly extend beyond schema. Baseline 3 is appropriate.

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

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

Clearly states the tool compares 2-5 entities side by side, specifies verb (compare) and resource (entities), and distinguishes it from siblings by describing the two entity types and the data returned. Siblings are unrelated 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?

Provides context by noting it replaces 8-15 sequential calls, implying efficiency. However, it does not explicitly state when to avoid using it or compare to specific sibling tools. Still, the description gives clear guidance on its purpose.

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 must carry the burden. It states that the tool returns the most relevant tools with names and descriptions, which is transparent about the output. However, it does not mention any potential side effects, rate limits, or limitations, but given the read-only search nature, the description 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 concise with three sentences: the first states the action, the second describes the output, and the third gives a usage directive. 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 the tool's simplicity (2 parameters, no output schema, no nested objects), the description is complete. It explains what the tool does, what it returns, and when to use it. No additional information is needed.

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

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

Schema description coverage is 100%, so baseline is 3. The description mentions the query parameter by example but does not add extra meaning beyond the schema's description. It does not elaborate on the limit parameter's behavior 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 verb ('Search') and resource ('Pipeworx tool catalog'), and specifies the use case: discovering relevant tools when 500+ are available. It distinguishes itself from siblings by emphasizing it returns tool names and descriptions for selection, whereas siblings like ask_pipeworx or usa_award_search 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?

The description explicitly says to call this FIRST when 500+ tools are available, providing clear usage context. It implies this tool is for discovery, not for direct task execution, which differentiates it from 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?

With no annotations provided, the description fully discloses behavior: returns pipeworx:// citation URIs, bundles multiple data sources, notes performance caveat (too slow for federal contracts), and states only company type is supported. 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 a single dense paragraph with no wasted words. Every sentence adds value: data content, URI format, efficiency claim, exception for federal contracts. Could be slightly more structured but remains highly concise.

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

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

Given the tool's complexity (multiple data sources) and lack of output schema, the description covers input requirements, expected output (URIs), and context for use (replacing many calls). Also notes limitations (type, value format) and alternative tool for federal contracts. Complete for an agent to 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%, but the description adds significant meaning: explains the type enum's current limitation to company, details what value expects (ticker or CIK) with examples, and explicitly advises using resolve_entity for names. This goes beyond the schema.

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

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

The description clearly states it returns a full profile of an entity across Pipeworx packs, specifying exactly what data is returned for company type (SEC filings, revenue, patents, news, LEI) and explicitly says it replaces 10-15 sequential calls, distinguishing it from siblings like 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?

The description provides explicit when-to-use guidance ('full profile of an entity'), when-not-to-use (for federal contracts, use usa_recipient_profile instead), and prerequisites (if only a name, use resolve_entity first). It also lists alternatives indirectly via 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?

No annotations provided, so the description must disclose behavioral traits. It states deletion but doesn't mention whether the operation is irreversible, if confirmation is needed, or any side effects. The behavior is implied but not fully 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?

A single sentence that is concise and front-loaded with the action. 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 simplicity (1 param, no output schema), the description is adequate but lacks details about return value or confirmation. It could mention that the operation is permanent or provide success/failure indicators.

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 only one required parameter 'key', and the description mentions 'by key', aligning with the schema. No additional semantic detail is added beyond the schema's 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?

The description clearly states the action ('Delete') and the target resource ('a stored memory'), and specifies the key parameter. It distinguishes from sibling tools like 'remember' (create) and 'recall' (retrieve), though it doesn't explicitly name them.

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 on when to use this tool versus alternatives like 'recall' or 'remember'. There is no mention of prerequisites (e.g., key existence) or error handling.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds context about fetching the page and extracting title/description/links, which aligns with annotations. No contradictions.

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

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

Concise with no wasted words. The description is front-loaded with the primary function, followed by technical output details, then specific use cases. Each 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?

Given rich annotations, full schema coverage, and no output schema needed, the description covers the main points. It could mention error handling or output format details but is sufficient for a simple generation tool.

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

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

Schema coverage is 100%, so description adds only contextual framing (e.g., why the URL is needed) but no new parameter details beyond what the schema already provides.

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

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

The description clearly states the tool generates an llms.txt file for any URL, specifying the verb (generate), resource (llms.txt for a URL), and target audience (AI crawlers). It distinguishes itself from sibling tools by focusing on a specific file format.

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

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

The description explicitly lists use cases: getting a client's site indexed, drafting for own project, or auditing competitor visibility. It does not specify when not to use, but the provided scenarios offer clear 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses the rate limit and that the tool is free, but does not describe what happens after sending (e.g., acknowledgment, whether feedback is visible to the user, or any authentication requirements). Some behaviors remain unspecified.

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

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

The description is extremely concise at three sentences. Each sentence serves a distinct purpose: stating the action, listing use cases and constraints, and providing rate limit info. It front-loads the key purpose and has no redundant or filler content.

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

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

Given the tool's simplicity (3 parameters, no output schema), the description adequately covers purpose, usage guidelines, and a key constraint (rate limit). It does not explain return values, but that is acceptable for a feedback tool. The description addresses what an agent needs to decide whether to invoke and how to fill parameters.

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 value by advising the user to 'describe what you tried in terms of Pipeworx tools/data' and to avoid including the user's prompt verbatim. This provides usage nuance beyond the schema's 'be specific' instruction.

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 'Send feedback' and specifies the resource 'Pipeworx team'. It enumerates concrete use cases (bug reports, feature requests, missing data, praise) which unambiguously distinguish it from sibling tools that perform queries or data retrieval.

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 (for various feedback types) and what not to include (end-user prompt verbatim). It also mentions the rate limit (5 per day per identifier). However, it does not explicitly state when not to use it (e.g., for non-feedback queries), which is implicit given sibling tool names.

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 (readOnly, idempotent), the description adds: 'Self-aggregating signal — derived from CF analytics-engine, no PII, just (pack, tool, count). Cached 5min-1h depending on window.' This provides full transparency on data source, privacy, and caching. 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?

The description is a single paragraph with clear bullet points. It is not overly long; every sentence adds value. Slightly front-loaded but still 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 explains what is returned (top tools, packs, call volume) and provides caching, privacy, and data source details. It is adequate for a simple read-only tool, though it could specify ordering or pagination.

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

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

The schema covers the parameter with enum and description (100% coverage). The description adds semantic value by explaining shorter windows show 'hot right now' and longer windows 'steady-state demand,' which aids agent reasoning.

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 window, with a specific verb and resource. It distinguishes itself from siblings by focusing on trending usage, not comparison or discovery.

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

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

Three explicit use cases are provided (discovering hot data sources, confirming canonical choices, aligning with agent needs). While it doesn't explicitly say when not to use or list alternatives, the guidance is strong and context-rich.

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 destructiveHint=false. The description adds transparency by detailing the algorithm: walks child markets, extracts dates/thresholds, sorts, and reports violations. 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 around 100 words, well-structured with a concise explanation of the concept, an example, and output format. It front-loads the main purpose but includes unnecessary details about the output structure.

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

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

Given the tool has one parameter, no enums, and no output schema, the description fully covers the input, the logic, and the output format. It 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% with a single 'event' parameter described. The description elaborates by stating it can be a slug or full URL and gives an example ('when-will-bitcoin-hit-150k'), adding 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 the tool finds arbitrage opportunities in Polymarket events via monotonicity violations, specifying the resource (events with multiple markets) and verb ('find'). It distinguishes itself from sibling tools like bet_research and polymarket_edges by its specialized purpose.

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

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

The description explains when to use the tool (checking multiple markets for price order violations) and provides a concrete example. It implicitly indicates when not to use it (if the event has no multiple date/threshold markets), but does not explicitly list alternative 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 details the process: scanning top markets, grouping by asset, fetching price history once, computing model probability, ranking by |edge|, and returning top N with suggested trade direction. This adds rich behavioral context beyond the annotations, which already indicate read-only and non-destructive behavior.

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

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

The description is detailed with multiple sentences, but each sentence adds value (model, process, use case). It is front-loaded with key verbs and nouns, though could be slightly more concise 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?

The tool lacks an output schema, but the description fully explains return values (top N ranked by edge magnitude with suggested trade direction). It covers the model, data sources (FRED, coinpaprika), and scope (crypto-price bets, V1). No missing information for a complex 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 description coverage is 100%, so the schema already documents parameters like limit, window, and min_edge_pp. The description adds context on how they are used in the ranking process but does not significantly enhance individual parameter semantics. Baseline of 3 is appropriate.

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

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

The description clearly states the tool scans high-volume Polymarket markets and returns those where Pipeworx data disagrees most with market price, ranking by edge magnitude. It explicitly mentions V1 covers crypto-price bets, distinguishing 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 specifies the tool is built for 'what should I bet on today' questions, helping users discover opportunities. While it lacks explicit when-not or alternatives, the use case is clear and well-contextualized.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds useful context: explains underlying cause of spread (different participant pools), arb signal, and return format.

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 well-structured with modes and return overview, but slightly verbose. Front-loaded main purpose effectively.

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 covers return values. Modes are explained. Could mention edge cases or behavior when topic missing.

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

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

Schema coverage is 100%; description adds mode explanation and return semantics (leg-by-leg prices, spread in % points) beyond parameter 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?

Title and description clearly state it's a cross-venue spread tool between Kalshi and Polymarket for the same resolving question. It distinguishes from siblings like polymarket_arbitrage by specifying venue pair and purpose.

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

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

Description explains two modes (topic and explicit) and when to use each. It gives examples but does not explicitly state when not to use it or 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?

The description does not contradict the lack of annotations. It discloses the core behavior (retrieve/list) but does not add details beyond what the description and schema already imply. Since there are no annotations, the description carries the burden, but it is straightforward and adds minimal behavioral context beyond the obvious.

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 (two sentences) and front-loaded with the primary action. Every word serves a purpose, 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 tool is simple (one optional parameter, no output schema, no nested objects), the description is nearly complete. It explains both retrieval and listing. However, it could mention that the return format is a string or object, but the lack of output schema makes this a minor gap.

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 parameter semantics are fully documented in the schema. The description adds no additional meaning beyond restating what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: retrieve a memory by key or list all stored memories. It uses specific verbs ('retrieve', 'list') and the resource ('memory'), distinguishing it from sibling tools like 'remember' and 'forget'.

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

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

The description explicitly tells the agent when to use this tool: to retrieve context saved earlier. It also explains how to list all keys by omitting the key parameter, and provides context about retrieving from current or previous sessions, which differentiates it from 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?

No annotations are provided, so the description carries full burden. It discloses that for company type the tool fans out to three sources (SEC, GDELT, USPTO) in parallel, explains input formats (ISO date or relative), and mentions the return structure (structured changes, count, URIs). It does not specify permissions or rate limits, but the behavior is well-covered.

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

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

The description is two sentences long, but the second sentence is dense with information. It is front-loaded with the core purpose. While it could be slightly more structured, it is efficient and avoids repetition.

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 explains the return structure (changes + count + URIs). It covers the only supported entity type (company) and the parallel fan-out behavior. This is sufficient for the tool's complexity and 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 adequate parameter descriptions. The description adds value by providing examples for 'since' (ISO and relative formats) and clarifying that 'type' only supports 'company' today, and 'value' can be ticker or CIK. This adds modest context beyond the schema, supporting a 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 returns what's new about an entity since a point in time, with a specific example for company entity. It distinguishes from siblings like entity_profile (static profile) and compare_entities (comparison) by focusing on change monitoring and real-time updates.

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 recommends use for 'brief me on what happened with X' or change-monitoring workflows. It does not list exclusions or alternatives, but the use case is clearly defined against siblings like entity_profile (static snapshot).

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 persistence behavior (authenticated users get persistent memory; anonymous sessions last 24 hours), which is critical behavioral context beyond what the schema provides. No mention of overwrite behavior or limits, but sufficient for most use cases.

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

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

Three sentences with no wasted words. Front-loaded with action and resource, then usage examples, then behavioral note. Every sentence adds value.

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

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

For a simple two-parameter tool with no output schema, the description is complete enough. It covers purpose, usage, and key behavioral details (persistence). Minor gap: no mention of value overwriting behavior, but not critical.

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% (both parameters have descriptions). The description adds general semantics about saving findings and preferences but does not add specific meaning beyond the schema's parameter descriptions. Baseline 3 is appropriate.

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

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

The description clearly states the tool stores a key-value pair in session memory, with a specific verb ('store') and resource ('key-value pair in session memory'). It distinguishes itself from siblings like 'recall' (retrieving) and 'forget' (deleting), providing clear 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?

The description provides explicit usage context: saving intermediate findings, user preferences, or context across tool calls. It does not mention when not to use or alternatives, but the context is clear enough to guide appropriate usage.

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

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

No annotations are provided, so the description carries the full burden. It discloses that it is v1, supports only 'company' type, and returns specific fields. It does not detail permissions, rate limits, or error handling, but for a read-only lookup the transparency 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 two sentences with no wasted words. It front-loads the purpose and then details inputs and outputs. Every sentence contributes essential information.

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

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

Given no output schema, the description covers what the tool returns. It mentions v1 and the single supported type. It could mention error cases (e.g., entity not found), but for a simple lookup tool it is largely complete.

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

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

Schema coverage is 100% with both parameters described. The description adds value by providing concrete examples (AAPL, 0000320193, Apple) and clarifying that the value parameter accepts multiple identifier formats, going beyond the schema definitions.

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

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

The description clearly states the tool resolves an entity to canonical IDs, specifies the supported type (company), expected inputs (ticker, CIK, name), and outputs (ticker, CIK, name, URIs). It distinguishes itself by noting it replaces 2–3 lookup calls.

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

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

The description gives clear context for using the tool: to resolve entities in a single call, with examples. It does not explicitly state when not to use it or provide alternatives, but given no direct sibling tools for entity resolution, the guidance is sufficient.

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

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

Annotations already provide readOnlyHint, idempotentHint, destructiveHint. The description adds that it probes each entity with another tool and returns a ranked list with score, confidence, signal density. It also explains optional apiKey behavior. 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?

Three sentences with no wasted words. Front-loaded with purpose and key details. Every sentence earns its place.

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

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

No output schema, but description details return format (ranked list with score, confidence, signal density). It covers optional parameters and behavior. Sufficient for a comparison tool with good annotations.

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 parameter descriptions. The description adds value by stating the first entity is treated as 'subject' and that output includes scores and rankings, which is beyond the schema. This aids agent 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 explicitly states the tool compares AI visibility across multiple entities, probes each with ai_visibility_check, ranks by score, and surfaces recognition levels. It clearly distinguishes from siblings like ai_visibility_check (single entity) and compare_entities (generic 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?

The description gives explicit context for use ('competitive AI-marketing audits') with an example question. It implicitly distinguishes from ai_visibility_check but does not explicitly state when not to use or mention all alternatives. Still clear and helpful.

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

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

No annotations are provided, so the description carries full burden. It does not disclose whether this is a read-only operation, any rate limits, or authentication requirements. The description only lists filters and return fields, lacking transparency about side effects or data freshness.

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 plus a bonus line for award types. Information is front-loaded (purpose first). Minor redundancy: 'Returns recipient, amount, dates, agency, and description' repeats some info from the schema.

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

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

For a search tool with 7 parameters and no output schema, the description covers the purpose and key fields but lacks details on pagination, sorting, or how to handle large result sets. It is adequate but not comprehensive.

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 all parameters are described in the schema. The description adds some context (e.g., award type codes) but does not provide deeper semantics beyond what the schema already offers. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Search') and resource ('federal contract awards') and lists key filters (keywords, agency, date range, NAICS code) and return fields. It also distinguishes from sibling tools like 'usa_spending_by_agency' by focusing on contract awards rather than spending aggregation.

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 states what the tool does and lists filters, but does not explicitly guide when to use this tool over siblings (e.g., when to use 'usa_spending_by_category' instead). No exclusions or alternatives are mentioned, though the description of return fields implies use for detailed contract info.

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 present, so the description carries full burden. It clearly states the tool returns contract awards within a date range, implying a read-only, non-destructive operation. The behavior is well-described without 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 two sentences, front-loading the purpose and then detailing scope. It is concise but could be slightly more structured; 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 no output schema, the description adequately explains what the tool returns (contract awards for a named recipient within a date range). The required parameters are all documented. It is complete enough for its complexity.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds no additional meaning beyond what the schema provides for each parameter, hence a baseline 3 is appropriate.

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

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

The description uses a specific verb ('Get') and resource ('contractor or recipient's federal spending profile'), and clarifies the scope ('All contract awards within a date range'). It distinguishes itself from siblings like usa_award_search and usa_spending_by_agency, which focus on broader or different spending 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 implies usage for retrieving a named recipient's spending, but does not explicitly state when to use this versus other tools like usa_award_search or usa_spending_by_agency. The date range requirement is clear, but no exclusions or alternatives are mentioned.

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

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

Annotations are empty, so the description must disclose behavioral traits. It states that the tool returns spending per agency, but does not mention any side effects, rate limits, authentication needs, or data freshness. However, as a read-only query tool, the description is adequate. It could mention that data is from USAspending.gov and may be delayed.

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 at two sentences, with the key purpose in the first sentence. It is front-loaded and contains no filler. It could be slightly more structured (e.g., listing parameters), but it is 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 simple query nature (two optional parameters) and no output schema, the description is mostly complete. However, it lacks details about the response format (e.g., list of agencies with amounts) and whether totals or breakdowns are provided. Still, it is functional for an agent to decide to use 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%, meaning the input schema already describes both parameters well. The description adds no extra meaning beyond what the schema provides, which is acceptable. Baseline 3 is appropriate since 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 gets federal spending breakdown by agency for a given fiscal year and optional quarter. It specifies the verb 'Get', the resource 'federal spending breakdown by agency', and the scope 'for a given fiscal year and optional quarter'. While it distinguishes from siblings like usa_spending_by_category and usa_spending_trends, it could be more explicit about the distinction.

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

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

The description implies when to use it (for agency-level spending breakdowns) but does not explicitly state when not to use it or provide alternatives among siblings. Given the sibling tools (e.g., usa_award_search, usa_recipient_profile), some guidance would help, but the purpose is clear enough for an agent to infer.

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 present, so the description must convey behavioral traits. It states the breakdown categories and mentions 'market analysis', but does not disclose whether the tool is read-only, potential rate limits, or that it returns aggregated data (not individual awards). The description is adequate but not rich.

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 action, and each sentence adds value. 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 lack of output schema, the description does not explain what the response contains (e.g., aggregated totals, counts). It also does not specify that the categories are mutually exclusive or how grouping works. With 6 parameters and 3 required, the description covers the main purpose but leaves some behavioral details unspecified.

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 all parameters are described in the schema. The description adds value by listing the category options in prose, which reinforces the schema's enum-like list. However, it does not provide additional semantics beyond what the schema already offers for parameters like 'limit', 'agency', etc. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function: 'Get federal spending broken down by category', listing specific category types (NAICS code, PSC, recipient, etc.). It differentiates from siblings like 'usa_spending_by_agency' which groups by agency only, and 'usa_spending_trends' which likely focuses on trends over time.

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 notes it's 'Useful for market analysis', implying a business intelligence use case. However, it does not provide explicit guidance on when to use this tool versus alternatives like 'usa_award_search' or 'usa_spending_trends'. No exclusions or prerequisites are stated.

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

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

Annotations are empty, so the description should disclose behavior like rate limits, data freshness, or scope (e.g., only US federal spending). It does not mention any behavioral traits beyond grouping options.

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 purpose and grouping options. It is concise and to the point.

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

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

The tool has no output schema, so description should hint at return format (e.g., time series with spending amounts). It does not describe output structure or pagination. Given 5 params and no annotations, more details would help.

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 each parameter has a description. The tool description adds context about grouping (fiscal_year, quarter, month) but does not explain the meaning of 'agency' or how keywords interact with agency filtering.

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

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

The description clearly states the tool gets federal spending over time and returns grouped data, distinguishing it from sibling tools like usa_spending_by_agency which focuses on agency-level breakdowns. However, it could be more specific about the verb (e.g., 'Retrieve' instead of 'Get').

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 it's useful for trend analysis, but does not explicitly state when to use this tool versus alternatives like usa_spending_by_agency or usa_spending_by_category. No when-not-to-use guidance 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 full burden for behavioral disclosure. It reveals that it uses SEC EDGAR + XBRL, returns a verdict with citation, and calculates percent delta. It does not mention error handling, rate limits, or side effects, but for a read-only fact-checking tool, this level of detail is high. No contradictions with annotations exist as none are present.

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

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

The description is extremely concise with four sentences, each earning its place: first states purpose, second details domain, third lists return types, fourth notes efficiency gain. It is front-loaded with the main verb and resource, and contains no redundant or vague wording.

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

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

Given the tool has one parameter, no annotations, and no output schema, the description is remarkably complete. It explains the input domain, the data sources, the output structure (verdict, structured form, actual value, citation, percent delta), and the value proposition (replaces multiple calls). An agent can confidently invoke this tool without needing additional documentation.

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

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

The schema covers the single 'claim' parameter with a description. The tool description adds significant semantic value by specifying the types of claims supported (company-financial, public US companies), the sources used, and the expected output format. This goes well beyond the schema's basic parameter description, providing deep context for correct invocation.

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 fact-checks natural-language claims, specifies the supported domain (company-financial claims via SEC EDGAR + XBRL), and lists exact return values (verdict, structured form, actual value with citation, percent delta). It also distinguishes itself from siblings by explicitly stating it replaces multiple sequential agent calls, making the purpose highly specific and unambiguous.

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

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

The description explicitly states when to use this tool (for company-financial claims) and what it replaces (4-6 sequential calls). It does not explicitly state when not to use it or mention alternatives for other claim types, but the supported domain is clear enough for an agent to infer boundaries. The context is clear, but lacks explicit exclusions or alternative tool references.

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