Google_sheets

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

Discloses default model, optional Anthropic proxy with cost implications, and return structure per-model. Annotations already signal safety; description adds value by specifying which models and how keys work.

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 with no redundancy: purpose, models/keys, returns, use cases. Every sentence adds distinct 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?

Covers all inputs, default behavior, optional parameters, and return format. No output schema but describes output fields. Missing rate limits or request volume, but overall sufficient given 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%, and description adds practical context (e.g., default model, how _apiKey works, purpose of context). Enhances understanding beyond schema.

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

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

Clearly states verb 'Probe', resource 'LLMs', and outcome 'score visibility (0-100) per model'. Distinguishes from sibling 'scan_competitor_ai_presence' by focusing on specific model probing and 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?

Lists explicit use cases: 'AI-marketing audits, pre-launch brand checks, competitive monitoring'. Explains default vs. optional models with BYO key. Could mention when to prefer over sibling but provides clear context.

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

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

No annotations are provided, so the description must carry the burden. It discloses that the tool automatically selects the right tool and fills arguments, which is key behavioral context. However, it does not mention potential limitations or failure modes.

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 three sentences, front-loaded with the key action, and includes examples. Minor improvement could be more structured formatting.

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

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

Given the tool's simplicity (one parameter, no output schema), the description is complete. It explains what the tool does, how to use it, and provides examples. Sibling tools like sheets_* are distinct, so no additional context 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 coverage is 100% with a single 'question' parameter described as 'Your question or request in natural language'. The description adds value by emphasizing plain English and providing examples, making the parameter's purpose even clearer.

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 natural language questions and returns answers from the best data source, which is specific and distinct from sibling tools like 'discover_tools' or the sheets tools.

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

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

The description provides examples of appropriate usage ('What is the US trade deficit with China?') and implies it handles tool selection, but does not explicitly state when not to use it or name alternatives.

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

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

Annotations (readOnlyHint=true, openWorldHint=true, destructiveHint=false) indicate a safe, read-only operation. The description adds details on the internal process: market resolution, classification, fan-out to packs, and return of comparison. It does not contradict annotations and provides useful behavioral context.

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

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

The description is two sentences, front-loaded with the tool's purpose. While dense, every sentence adds unique value. Could be slightly more concise but is effective overall.

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 and no output schema, the description explains the return format (evidence packet + comparison) and use cases. It lacks explicit details on evidence packet structure but provides sufficient context for an agent to invoke the tool correctly.

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

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

Input schema coverage is 100% with both parameters already well-described. The tool description rephrases the same parameter information without adding new semantics (e.g., depth options and market input types are identical). Baseline 3 applies.

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

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

The description clearly states it researches a Polymarket bet by pulling Pipeworx data, resolving the market, classifying it, and returning an evidence packet plus market-vs-model comparison. It uses specific verbs ('Research') and resource ('Polymarket bet') and distinguishes from sibling tools like ask_pipeworx by focusing on bet-specific context.

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 example queries ('should I bet on X?', 'what does data say?', 'is there edge?') and positions the tool as the core demo product, indicating agents perform better with it. This provides clear guidance on when to use versus 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 are provided, so the description must carry the full burden. The description clearly indicates a read-only data retrieval operation (from SEC EDGAR, FDA, etc.) with no side effects. It could have explicitly stated 'read-only' or mentioned that it does not modify any data, but the absence of annotations is mitigated by the clear description.

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 sentence that front-loads the core purpose and immediately adds value with type-specific details. Every word earns its place, no redundancy.

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

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

Given the absence of an output schema and annotations, the description is fairly complete for a comparative data retrieval tool. It specifies the types, data fields, and the benefit over sequential calls. It could have noted whether the result is paginated or if there are rate limits, but such details are not critical for basic 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 description coverage is 100%, so the schema already fully documents both parameters. The description adds context (e.g., 'type="company"...' and examples for values), but does not provide additional semantic meaning beyond what the schema 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 clearly states the tool's purpose: 'Compare 2–5 entities side by side in one call.' It specifies the resource (entities) and verb (compare), and differentiates from siblings by noting it replaces 8-15 sequential calls. The description also details the data returned for each entity type.

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: when comparing 2-5 entities of type 'company' or 'drug'. It explains that it replaces 8-15 sequential calls, implying it is the efficient choice over alternatives like individual data fetches. It also hints at when not to use it (if you need more than 5 entities or different data).

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 explains the behavior: it searches by natural language description and returns the most relevant tools with names and descriptions. Although no annotations are provided, the description compensates well by being clear about what it does and its purpose. It does not mention any destructive behavior or side effects, but as a search tool, none are expected.

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: three sentences, each providing essential information. The first sentence states the purpose, the second describes the output, and the third gives usage guidance. No extraneous 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 (two parameters, no output schema), the description is complete. It explains what the tool does, when to use it, and how to formulate the query. There is no need for additional details like return format, as the description states it returns 'the most relevant tools with names and descriptions.'

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

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

The input schema already describes both parameters (query and limit) with good detail. The description reinforces the query parameter's usage with examples ('e.g., "analyze housing market trends"'), adding value beyond the schema. However, the schema coverage is 100%, so the baseline is 3; the examples only marginally improve it.

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: searching the Pipeworx tool catalog by describing what you need. It uses specific verbs ('search', 'returns') and specifies the resource ('tool catalog'). It distinguishes itself from siblings by advising to call this FIRST when many tools are available.

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

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

The description explicitly advises when to use the tool: 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task.' This provides clear context and implicitly suggests not using other tools without first discovering them.

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 bears full responsibility. It discloses the return format (pipeworx:// citation URIs), lists data sources, and mentions performance trade-offs. It does not explicitly confirm read-only status, but for a profile retrieval tool this is implicit and 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?

Four sentences, front-loaded with purpose, no redundancy. Every sentence adds value: purpose, data list, return format, efficiency, and exclusion. Ideal conciseness.

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 inputs, outputs (URIs), data sources, and limitations. It references a sibling tool (resolve_entity) appropriately. Lacks details on error handling or pagination, but for a simple profile tool this is sufficient.

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

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

Schema coverage is 100%, but the description adds critical context: type only supports 'company' (future types mentioned), value requires ticker or CIK (not names), and recommends resolve_entity for name resolution. This exceeds the baseline of 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 a full entity profile across multiple Pipeworx packs, listing specific data types (SEC filings, XBRL financials, patents, news, LEI) for type=company. It distinguishes itself from sibling tools by noting it replaces 10–15 sequential calls and directs federal contract queries to a different tool.

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

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

Explicitly provides when-to-use (comprehensive company profile), when-not-to-use (federal contracts → usa_recipient_profile), and input constraints (ticker or CIK, names requiring resolve_entity). This helps the agent decide correctly.

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 disclose behavioral traits. It states 'Delete' but does not clarify if deletion is permanent, if it requires confirmation, or what happens if the key does not exist (error vs. silent success). There is no mention of authorization needs or 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?

A single, front-loaded sentence that conveys the essential purpose with no superfluous words. It 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?

Given the simplicity (1 required param, no output schema, no nested objects), the description is adequate but could mention return value or behavior on missing key. It covers the basic operation but lacks completeness for error handling.

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

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

The input schema has 100% coverage for its single parameter, with a clear description 'Memory key to delete'. The description adds no extra semantics beyond the schema, but the schema itself is sufficient. Baseline 3 is appropriate, and slight bonus for the single-param clarity.

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 'Delete a stored memory by key' clearly specifies the action (delete), the resource (stored memory), and the required identifier (key). It is distinct from sibling tools like 'remember' (store) and 'recall' (retrieve).

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 when a memory needs to be removed, but provides no guidance on when not to use it, prerequisites (e.g., memory must exist), or alternatives among siblings. The sibling list includes 'recall' and 'remember', but no explicit comparison is made.

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 that the tool fetches the page, extracts title/description/key links, and outputs standard markdown format. This adds behavioral context beyond the annotations (read-only, idempotent, open world) by detailing the extraction process and output format. The description is consistent 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 and front-loaded, starting with the core purpose, followed by output details, and ending with use cases. Every sentence adds value without redundancy or unnecessary detail.

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

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

The description explains input, process, and output, and lists use cases. However, it lacks details on error handling, rate limits, or what happens for invalid URLs. Given the absence of an output schema, more completeness on potential failure modes would be beneficial.

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

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

Schema coverage is 100%, with both parameters (url, max_links) described in the schema. The description does not add new information about the parameters beyond what the schema provides, so it meets the baseline for high coverage without additional enrichment.

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 that the tool generates a production-ready llms.txt file for any URL. It specifies the verb ('generate'), the resource ('llms.txt file'), and the target ('any URL'), making the purpose unambiguous. Among sibling tools, none provide similar functionality, ensuring clear 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 lists explicit use cases (getting a client's site indexed, drafting for own project, auditing AI crawler view) which guide when to use. However, it does not mention when not to use it or provide alternatives in case of failure, which would strengthen the 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 must disclose behavioral traits. It mentions rate limiting and that the tool is 'Free' (no cost). It also instructs not to include the end-user's prompt verbatim, indicating privacy concerns. However, it does not describe what happens after sending (e.g., acknowledgment, storage). Still, core behaviors are 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 very concise (4 sentences), front-loads the purpose, and every sentence adds unique value (purpose, use cases, guidelines, rate limit). No filler or redundancy.

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

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

For a feedback submission tool with no output schema, the description covers all necessary aspects: what it does, when to use, how to structure input, and constraints (rate limit). The nested 'context' parameter is explained in the schema, so no additional description needed. An agent can confidently use this 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%, and the description adds supplementary guidance: it clarifies the 'message' parameter should be specific and 1-2 sentences, and it reiterates the enum values' meanings. This adds value 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 the tool's purpose: 'Send feedback to the Pipeworx team.' It enumerates specific use cases (bug reports, feature requests, missing data, praise) and distinguishes it from sibling tools like ask_pipeworx or discover_tools, which have different functions.

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 feedback types) and what to include/exclude (describe what you tried, do not include the end-user's prompt verbatim). It also mentions the rate limit of 5 messages per identifier per day, covering usage constraints.

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

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

Annotations already declare readOnly, idempotent, non-destructive. Description adds caching behavior (5min-1h) and no-PII assurance, providing extra value.

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

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

Well-structured with front-loaded purpose and bullet-pointed use cases. Slightly verbose but each 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?

Describes return fields (top tools, packs, volume) despite no output schema. Caching and time window explained. Adequate for a simple read-only tool.

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

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

Only one parameter (window) with full schema coverage (enum, description). Description adds context about what shorter vs longer windows reveal.

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

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

Description clearly states the tool returns trending data (top tools, packs, call volume) over configurable windows. Distinguishes itself from siblings by focusing on aggregated popularity signals.

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

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

Explicitly lists three use cases (discovering hot data, confirming canonical choice, aligning with use cases). No explicit 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?

The description reveals that the tool walks child markets, extracts dates/thresholds, sorts them, and reports violations. This goes beyond the annotations (readOnlyHint, openWorldHint) by detailing the specific algorithm and output structure. No contradictions.

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

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

The description is front-loaded with the purpose, uses a clear example, and efficiently explains the mechanism. While slightly lengthy, every sentence adds value, making it 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 has no output schema, the description adequately explains the return format (list of objects with specific fields). Input is simple and fully described. For a tool of this complexity, the description covers all necessary aspects.

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

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

The single 'event' parameter is already described in the schema (100% coverage). The description adds value by explaining how the event is used to extract child markets and perform the arbitrage check, providing 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 by detecting monotonicity violations in Polymarket event markets. It provides a concrete example and distinguishes itself from sibling tools like 'bet_research' or 'polymarket_edges' through its specific arbitrage-focused logic.

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

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

The description explicitly instructs to pass a Polymarket event slug or URL. It implies when to use (when checking for arbitrage due to monotonicity violations) but does not provide explicit exclusions or mention alternatives among sibling tools. However, the context is clear.

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

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

Adds context beyond annotations: caching behavior, model details, ranking by |edge|, and suggested trade direction. No contradiction with readOnlyHint=true.

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

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

Single paragraph but front-loaded with core purpose. Contains necessary details without fluff; could be slightly more structured but effective.

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

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

No output schema, so description should clarify return format more explicitly. Mentions 'returns top N ranked by edge magnitude with suggested trade direction' but lacks structure details. Adequate but incomplete.

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 default values for all parameters (10 limit, 1wk window, 0.5 min_edge_pp), providing extra meaning.

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 scans Polymarket markets and returns edges where Pipeworx data disagrees with market price. Specific verb+resource, and distinguishes from sibling 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?

Explicitly states 'built for the what should I bet on today question' and mentions discovering opportunities without manual paging. Missing explicit 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?

Annotations already provide readOnlyHint, idempotentHint, openWorldHint, and destructiveHint. The description adds valuable context about typical price differences (2-25pp) and explains the return format (leg-by-leg prices, spread). No contradictions.

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

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

The description is front-loaded with purpose and modes. It's slightly verbose but every sentence adds value. Could be trimmed slightly, but overall efficient.

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

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

Despite no output schema, the description fully explains return values (prices in 0-1, spread in percentage points) and covers both modes and overriding behavior. No gaps for this complexity level.

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

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

Input schema has 100% description coverage with clear definitions. The description enhances understanding by explaining the two modes and how explicit parameters override topic-mapped values, adding meaning beyond the schema.

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

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

The description clearly states the tool computes cross-venue spread between Kalshi and Polymarket for the same resolving question. It identifies two modes (topic shortcuts and explicit event tickers) and differentiates from siblings like polymarket_arbitrage by focusing on cross-venue 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 explains when to use each mode: topic for pre-mapped macros, explicit for custom pairings. It doesn't state when not to use or list alternatives, but the context is clear enough for correct selection.

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

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

No annotations are provided, so the description carries the full burden. It discloses that omitting the key lists all memories, which is important. However, it does not mention side effects, limitations, or whether this is a read-only operation. The description is adequate but not detailed.

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

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

Two sentences, front-loaded with the core action, no wasted words. Every sentence adds distinct value.

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

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

Given the tool's simplicity (1 optional parameter, no output schema, no annotations), the description is nearly complete. It could mention that keys are case-sensitive or what happens if a key doesn't exist, but for a retrieval tool this is sufficient.

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

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

Schema description coverage is 100%, so the schema already documents the 'key' parameter. The description adds value by explaining the behavior when key is omitted (list all). This goes 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 'retrieve' and the resource 'memory', with explicit mention of two modes: retrieve by key or list all. It distinguishes itself from sibling tools like 'remember' and 'forget' by focusing on 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 explains when to use the tool ('to retrieve context you saved earlier') and when to omit the key ('to list all stored memories'). It does not explicitly state when not to use it, but the context 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?

With no annotations provided, the description carries the full burden. It explains the parallel fan-out behavior (SEC EDGAR, GDELT, USPTO) and the return structure (structured changes, total_changes, pipeworx:// URIs). No contradictions. It could mention rate limits or permissions, but for a read-only aggregation tool this is sufficient.

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

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

The description is a single, well-structured paragraph that fronts the core idea. Every sentence adds value. Minor redundancy (mentioning 'Only "company" supported today' both in the 'type' description and inline), but overall concise and efficient.

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

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

Given the tool's complexity (multi-source fan-out) and the lack of an output schema, the description covers the return format (structured changes, total_changes, URIs). Input requirements are fully explained. It could mention error handling or pagination, but for a typical change-monitoring use case, it is complete enough.

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 significant value: it explains the 'since' parameter accepts ISO dates or relative strings ('7d', '30d', '3m', '1y') and recommends '30d' or '1m'. For 'value', it gives examples (ticker or CIK). For 'type', it notes that only 'company' is supported. This goes far beyond the schema's enum/description.

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

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

The description clearly states the tool's function: 'What's new about an entity since a given point in time.' It specifies the entity type ('company'), the data sources (SEC EDGAR, GDELT, USPTO), and the use case ('brief me on what happened with X'). This verb+resource clarity distinguishes it from sibling tools like entity_profile or 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?

Explicit usage guidance is provided: 'Use for "brief me on what happened with X" or change-monitoring workflows.' This clearly indicates when to use the tool. However, it does not explicitly state when not to use it or suggest alternatives, which would have earned a 5.

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

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

Description goes beyond annotations (none provided) by explaining persistence behavior: authenticated users get persistent memory, anonymous sessions last 24 hours. It does not mention any destructive behavior or rate limits, but given the simple nature of the tool, this is sufficient.

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

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

Three short sentences, each providing essential information: what it does, when to use, and persistence details. No wasted words.

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

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

Given the tool has only 2 simple parameters, no output schema, and no annotations, the description is complete. It covers purpose, usage, and behavioral context (persistence). The only minor gap is not mentioning any potential size limits or overwrite 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?

Schema description coverage is 100%, so the schema already documents both parameters well. The description adds usage context for the value field (any text) but does not add new semantic meaning beyond the schema. Baseline 3 is appropriate.

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

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

Description clearly states the tool stores a key-value pair in session memory, with a specific verb (store) and resource (session memory). It distinguishes from siblings like 'recall' and 'forget' by explicitly focusing on saving 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?

Description explains when to use (save intermediate findings, user preferences, context across calls) and provides context on persistence (authenticated vs anonymous). However, it does not explicitly mention when not to use or alternatives like 'recall' or 'forget'.

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 mentions the output fields and single-call behavior but lacks details on authorization, rate limits, or error handling. Adequate but not comprehensive.

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 input formats, with no wasted words.

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

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

Given no output schema and no annotations, the description is fairly complete, covering inputs, outputs, and benefit. It could mention error behavior for invalid inputs, but is sufficient for a simple lookup 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 already covers both parameters with descriptions. The description adds examples (e.g., 'AAPL', 'Apple') and explains the value parameter accepts ticker, CIK, or name, but does not add significant new information 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 resolves an entity to canonical IDs, specifies the entity type (company) and accepted inputs (ticker, CIK, name), and distinguishes it from unrelated sibling tools.

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

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

The description provides context by stating it replaces 2-3 lookup calls, but does not explicitly mention when not to use it or name alternative tools. However, siblings are mostly unrelated sheets and memory 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?

Annotations already declare readOnlyHint, openWorldHint, etc. The description adds that it probes each entity with ai_visibility_check, ranks by score, and surfaces most/least recognized. It also details return fields: score, confidence, signal density. 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?

Description is concise at 2-3 sentences, front-loaded with purpose, 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 no output schema, the description fully explains return format (ranked list with score, confidence, signal density) and input constraints (2-8 entities). An agent can understand and use the tool correctly.

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

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

Schema coverage is 100%, but the description adds significant meaning: entities first is subject, rest competitors; context disambiguates; models and _apiKey are optional. This 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 compares AI visibility across multiple entities, probes each with ai_visibility_check, ranks them, and returns a ranked list. It distinguishes from sibling ai_visibility_check by emphasizing side-by-side comparison for competitive audits.

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 a concrete use case: 'does Claude know about us as well as our competitors?' This implies when to use. However, it does not explicitly mention when not to use or name alternative sibling tools like compare_entities.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It states 'append to the end' which implies non-destructive behavior, but does not detail what happens if the range does not match existing table dimensions, or if rows contain formulas. Acceptable but minimal.

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, front-loaded sentence that conveys the core action and resource. It is concise and efficient, though it could benefit from a brief mention of behavior regarding empty rows or formula parsing.

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 4 parameters and no output schema, the description covers the basic purpose but lacks detail on return values or side effects. For a simple append tool, this is adequate but could be more informative.

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 parameters are already well-documented. The description adds no extra meaning beyond what the schema provides, such as hinting that 'values' should be 2D arrays or that 'range' is typically 'Sheet1!A1' to detect the table. 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 action ('Append rows') and the resource ('Google Sheets table'). It distinguishes itself from siblings like 'sheets_write' (which overwrites) and 'sheets_create' (which creates new sheets), though it could be more explicit about the difference.

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 adding rows to the end of a table, but provides no explicit guidance on when to use this vs 'sheets_write' or other sibling tools. There are no usage examples or caveats.

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 correctly indicates creation (mutating) behavior. However, it does not disclose details like authentication requirements, rate limits, or what happens if the title already exists. A score of 3 is appropriate as it states the basic behavioral trait but lacks depth.

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, short sentence that efficiently conveys the tool's purpose. No unnecessary words, earning the highest score.

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

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

Given the tool has only 1 parameter, no output schema, and no annotations, the description is minimal but covers the essential action. However, it lacks information about return value (e.g., spreadsheet ID) and potential side effects, which would be helpful for an agent. A score of 3 indicates adequacy with 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% and the only parameter 'title' is described in the schema as 'Title for the new spreadsheet'. The description adds no further semantic context beyond what the schema provides. Baseline 3 is correct.

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 ('Create') and resource ('Google Spreadsheet'). It distinguishes from siblings like 'sheets_read' and 'sheets_write' by focusing on creation. However, it does not mention any scope or uniqueness, but the purpose is specific enough.

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 creation use case but provides no guidance on when to use this vs alternatives like 'sheets_get_spreadsheet' or 'sheets_append'. No when-not-to-use or prerequisite information is given.

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

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

The description indicates a read-only operation, which is appropriate given no annotations are present. It adds context about what metadata is returned (title, sheets/tabs, properties), but does not disclose side effects, authorization needs, or rate limits. With no annotations, the description carries full burden but provides only moderate detail.

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

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

The description is one short sentence, concise and to the point. It is front-loaded with the main purpose and lists key properties. While concise, it could be slightly more descriptive without losing brevity.

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

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

Given the tool has one parameter and no output schema, the description adequately covers the tool's purpose. However, it lacks information about the return format (e.g., whether it returns a structured object), which could be useful for an agent. No context on limitations or edge cases is provided.

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

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

The schema has 100% coverage for the single parameter 'spreadsheet_id', so the schema already documents it. The description adds no additional meaning beyond what the schema provides. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool retrieves spreadsheet metadata including title, sheets/tabs, and properties. The verb 'get' combined with 'spreadsheet metadata' is specific and distinguishes it from siblings like sheets_read or sheets_append, though it doesn't explicitly differentiate from similar metadata tools.

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

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

The description implies usage for obtaining metadata before performing other operations, but provides no explicit guidance on when to use this vs alternatives like sheets_read. No context on prerequisites or exclusions is given.

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

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

With no annotations, the description bears full burden. It discloses that the tool reads data and returns rows as arrays, but does not mention read-only safety, rate limits, or behavior for empty ranges or errors.

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 that directly state purpose and output format. No unnecessary words, but could be slightly more front-loaded.

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

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

Given simple parameters and no output schema, the description is adequate but incomplete. It does not explain return format in detail (e.g., how rows are structured) or error handling.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add meaning beyond the schema, as it only restates the purpose. No parameter-specific details are given.

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 'read' and resource 'Google Sheets range', and specifies that it returns rows as arrays. It is distinct from sibling tools like sheets_append, sheets_write, etc.

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 reading data but does not provide explicit guidance on when to use this tool versus alternatives like sheets_get_spreadsheet. No exclusions or prerequisites 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?

The description discloses the overwrite behavior, which is critical for a write tool. However, with no annotations provided, the description should also mention side effects like whether the entire range is cleared before writing, or if only specified cells are overwritten. This gap reduces transparency.

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 two short sentences that cover the core purpose and key behavior. Every word is necessary; no redundancy.

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

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

The description is complete enough for a simple write tool given good schema coverage (100%) and no output schema. However, it lacks information about the return value (e.g., updated cells response) and does not clarify overwrite semantics in detail. This is adequate but not thorough.

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 context by implying the 'values' parameter structure (array of arrays) and the overwrite behavior, but it does not elaborate on 'value_input_option' beyond what the schema provides. The description adds modest extra value, raising the score to 4.

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

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

The description clearly states the verb 'Write' and the resource 'Google Sheets range'. It adds 'Overwrites existing data', which distinguishes it from its sibling 'sheets_append' (which presumably appends rather than overwrites). This provides good clarity but could be more explicit about the overwrite behavior compared to append.

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 'Overwrites existing data', which implies when to use this tool over 'sheets_append'. However, it does not explicitly state when not to use it or provide alternatives. A more direct comparison to 'sheets_append' would improve this.

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 details the output (verdict, structured form, citation, delta) and internal steps (NL parsing, resolution), being transparent about its behavior 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?

Four sentences with no wasted words. Front-loaded with the core action, followed by scope, output, and benefit, making it efficient and easy to parse.

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

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

Covers purpose, domain, output, and comparison to alternatives. Lacks explicit error conditions or prerequisites, but given the single parameter and clear domain, it is sufficiently 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 has 100% coverage with a clear description for the 'claim' parameter. The description adds examples and domain constraints, enhancing meaning beyond the schema.

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

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

The description clearly states it fact-checks natural-language claims using authoritative sources, specifies the domain (company-financial for US public companies), and contrasts with sequential agent calls, effectively distinguishing it from sibling tools like ask_pipeworx.

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

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

The description indicates it replaces sequential agent calls and supports company-financial claims, implying when to use it. It lacks explicit when-not-to-use or alternatives, but provides sufficient context for an agent to decide.

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