Google_drive

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

No annotations provided, so description carries full burden. It discloses that the tool internally selects the best source and fills arguments, giving insight into its autonomous behavior. No contradiction since no annotations exist.

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 three sentences with key information front-loaded, including examples. Every sentence adds value, 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 simple single-parameter schema and no output schema, the description adequately covers what the tool does and how to use it. Could mention that it may return text from various sources, but sufficient for the use case.

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 no parameter-level detail beyond the schema's 'Your question or request in natural language', but the overall use case is clear; 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 accepts plain English questions and returns answers by routing to the best data source, distinguishing it from other tools that require schema knowledge or manual tool selection.

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

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

The description explicitly says to ask questions in natural language, provides examples, and implies not needing to browse tools or learn schemas, but does not explicitly state when not to use it or contrast with siblings.

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

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

Beyond annotations (readOnlyHint, openWorldHint), the description explains market resolution, bet classification, data pack fan-out, and the evidence packet with comparison, fully disclosing behavior without contradiction.

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

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

The description is front-loaded with the main action and contains valuable details, though the final sentence about agent conversion is slightly promotional but not detrimental.

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

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

Given the tool's complexity and lack of output schema, the description covers input methods, internal processes, output format, and depth options, making it fully informative for an agent.

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

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

Schema coverage is 100% and the description adds context for both parameters: what 'market' can accept (slug, URL, text) and how 'depth' affects the fan-out, enriching 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 'research a Polymarket bet' with a specific verb and resource, and distinguishes it from sibling tools like ask_pipeworx by detailing the integrated fan-out and comparison functionality.

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 use cases are provided ('should I bet on X?', 'what does the data say?', 'is there edge?'), though explicit when-not-to-use or direct alternatives are not listed, it 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?

No annotations provided, so description carries full burden. It discloses data sources and output format but omits details on error handling, authorization, or rate limits. For a read-like operation, it is 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 concise sentences with the main action upfront. No filler; every sentence adds essential information.

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

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

Given no output schema, the description adequately covers input types, data fields, and output format. It lacks details on pagination or error handling but is sufficient for a 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 description coverage is 100%, baseline 3. The description adds value by explaining the fields returned for each type (e.g., revenue, net income for companies; adverse-event count for drugs), which are not in the schema.

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

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

The description clearly states the tool compares 2–5 entities side by side, with distinct behaviors for 'company' vs 'drug' types. It specifies data sources (SEC EDGAR, FDA) and output format (paired data, pipeworx URIs). This differentiates it from single-entity tools like resolve_entity.

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 replaces 8–15 sequential agent calls, implying efficiency for batch comparisons. However, it does not explicitly state when not to use it or mention alternatives among siblings.

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

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

No annotations are provided, so the description must carry the full burden. It states the tool searches and returns results, which is appropriate for a read-only operation. However, it doesn't disclose any behavioral traits such as whether it modifies state, whether results are ranked, or if there are any limitations (e.g., search quality). The description is clear but minimal for behavioral 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 two sentences long with zero wasted words. It front-loads the purpose and immediately follows with the usage directive. Every sentence adds value.

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

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

Given the tool's complexity (2 simple params, no output schema, no nested objects), the description covers the essential information: what it does, when to use it, and how to use the query parameter. The lack of output schema means the agent doesn't know what the return format is, but the description implies it returns tool names and descriptions, which is likely sufficient for the task of selecting tools. It could be more complete by mentioning the result format, but the context signals show a simple 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 baseline is 3. The description adds value by explaining the purpose of the query parameter with concrete examples ('analyze housing market trends', etc.) and specifying default and max values for limit. This goes beyond the schema's basic description, providing practical guidance.

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

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

The description clearly states the verb ('search') and resource ('tool catalog'), and explains it returns 'the most relevant tools with names and descriptions.' The phrase 'by describing what you need' adds specificity. It also distinguishes from siblings by being a catalog search tool, not a direct data access or file tool.

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

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

The description explicitly states when to use: 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task.' This provides a clear usage directive and implies when not to use (e.g., when you already know the tool). No alternatives are named, but the context of having many tools justifies calling this first.

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 mutation (create), but does not disclose behavioral traits like whether it overwrites existing files, permission requirements, or error conditions. No annotations are provided, so the description carries the burden, and it only partially fulfills it.

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 sentence, no wasted words. Effectively communicates the core action and key parameters.

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

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

Given the tool has 4 parameters, no output schema, and no annotations, the description is adequate but leaves gaps (e.g., default behavior for parent folder, return value). It provides the essential purpose but not full context for invocation.

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

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

Schema coverage is 100%, so the description need not add much. However, it mentions 'name, content, and MIME type' which matches the required parameters, but does not add meaning beyond what the schema already provides. The optional 'parent_folder_id' is not mentioned.

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 ('Create') and resource ('new file in Google Drive'), and mentions key attributes (name, content, MIME type). It clearly distinguishes from sibling tools like 'drive_list_files' or 'drive_get_content'.

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 creating files, but lacks explicit guidance on when to use this vs alternatives (e.g., drive_get_file for reading, drive_list_files for listing). No mention of when not to use it.

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

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

No annotations are provided, so the description must disclose behavioral traits. It states that the tool returns raw content or exports to a format, which covers the core behavior. However, it does not mention whether the operation is read-only (likely, but not stated), any side effects, rate limits, or auth requirements. 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?

Two sentences, zero waste. Each sentence adds essential information: first sentence defines the action and scope, second sentence clarifies the two modes of operation. Front-loaded and efficient.

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

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

Given the low complexity (2 params, no output schema, no nested objects), the description covers the essential purpose and parameter semantics. It could mention that the return value is binary or the exported content, but since there is no output schema, this is a minor gap. Overall, the description is nearly complete for this tool.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds context that export_mime_type is required for Google Workspace files, which reinforces the schema but does not add new meaning beyond 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 verb ('Download or export'), the resource ('content of a Google Drive file'), and distinguishes between two use cases: exporting Google Docs/Sheets/Slides to a format, and getting raw content for binary files. This differentiates it from sibling tools like drive_get_file (which presumably retrieves metadata) and drive_create_file.

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 export_mime_type (for Google Workspace files) but does not explicitly exclude scenarios, provide prerequisites, or mention alternatives. It lacks explicit when-to-use or when-not-to-use guidance, which is acceptable given the tool's narrow scope but could be improved.

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 exist, so description carries full burden. It discloses that the tool returns metadata (name, mimeType, etc.) and does not modify or delete, but lacks details on access requirements (e.g., permission scope), rate limits, or behavior when file_id is invalid. With no annotations, a score of 3 is appropriate as it provides basic but incomplete 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?

Single sentence front-loads purpose and lists key fields, no fluff. Slightly more efficient would be to remove 'and more' if exact fields are listed, but still concise.

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

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

For a read-only metadata retrieval with no output schema, the description is adequate but lacks guidance on error handling (e.g., missing file) or rate limits. Given tool simplicity, it's minimally complete.

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

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

Schema description coverage is 100% (both parameters described). The description adds no additional meaning beyond the schema for file_id, but does not elaborate on fields (e.g., format, available values). 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?

Description uses specific verb 'Get metadata' and resource 'Google Drive file by ID', clearly distinguishing from siblings like drive_get_content (which retrieves file content) and drive_list_files (which lists files without a specific ID). The listed fields (name, mimeType, size, etc.) further clarify the scope.

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

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

The description implies use when metadata is needed for a specific file ID, but does not explicitly state when to use this over alternatives. For example, it doesn't contrast with drive_search or drive_list_files, nor does it mention prerequisites like having the file ID.

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 must cover behavior. It mentions optional filtering but lacks details like default sorting, pagination behavior, or any side effects. The description is minimal but not misleading.

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 sentence with a period; no wasted words. Could potentially add a second sentence for when to use, but it's concise and front-loaded.

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

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

For a simple list tool with full schema coverage and no output schema, the description is adequate but could mention pagination behavior or default order. It's not incomplete, but not rich.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the 'q' parameter uses Drive query syntax and gives examples in the schema, which is helpful.

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 lists files in Google Drive and optionally filters with a search query, which is specific and distinct from sibling tools like drive_create_file or drive_search.

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 (listing files, optionally filtering), but does not explicitly contrast with siblings like drive_search or provide when-not-to-use guidance.

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

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

Annotations are empty, so description carries full burden. Discloses it uses Drive query syntax and supports specific operators, but does not mention any potential side effects, permissions needed, or result limitations beyond what schema shows.

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 purpose and key detail about supported operators. 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 tool complexity is low (2 params, no output schema), description is complete enough. It explains the query syntax usage and supported operators. Could mention that results are file metadata, but output schema is absent.

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

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

Schema coverage is 100%, so baseline is 3. Description adds context about query syntax operators but does not add significant meaning beyond schema descriptions for query and page_size.

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 searches Google Drive files using Drive query syntax, listing supported operators like name, mimeType, fullText. Differentiates from siblings like drive_list_files which lists files without query syntax.

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

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

Provides clear context for when to use this tool (search with Drive syntax), but does not explicitly mention when not to use or alternatives. Sibling drive_list_files is a simpler listing 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?

No annotations are provided, so the description carries full burden. It discloses that the tool returns pipeworx:// citation URIs and implies it is a comprehensive read operation covering multiple sources. However, it does not mention error handling, rate limits, authentication requirements, or whether it modifies any data. This is adequate but lacks full 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 concise, with key information front-loaded: purpose, included data, output format, and usage alternatives. Each sentence adds value, and the structure is logical and easy to parse. No unnecessary words or repetitions.

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 (aggregating data from multiple sources) and the lack of an output schema, the description provides a good overview of the returned data categories. However, it omits details on result size limits, response format structure, or error scenarios. Still, it is fairly complete for functional understanding.

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 detailed parameter descriptions. The tool description adds some context (e.g., listing the data types returned) but does not significantly enhance the schema's own parameter explanations. Baseline score is appropriate as the schema already clarifies the parameters sufficiently.

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 profile of an entity across multiple Pipeworx packs. It specifies the data included for type='company' (SEC filings, revenue, patents, news, LEI) and distinguishes itself by noting it replaces 10-15 sequential agent calls, implying a comprehensive alternative to separate calls. It also hints at an alternative for federal contracts, showing 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 explicitly states when to use: to get a comprehensive entity profile. It also provides when-not-to-use guidance: for federal contracts, call usa_recipient_profile directly. Additionally, it advises using resolve_entity first if only a name is available, offering clear prerequisites.

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 the full burden. It states 'Delete' which implies irreversible mutation, but does not disclose whether confirmation is needed, if the key must exist, or any side effects. A 3 is appropriate for adequate but not detailed 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?

A single, short sentence with no filler. Every word is necessary and front-loaded with the action 'Delete'.

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 delete tool with one required parameter and no output schema, the description is minimally complete. It does not explain return behavior (e.g., success vs. not found) or error states, but the tool's simplicity reduces need for more detail.

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 one required parameter 'key' described as 'Memory key to delete'. The description reinforces that the key identifies what to delete, adding no new info but confirming the schema. With high coverage, baseline is 3, but the alignment earns a 4.

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

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

The description uses a specific verb ('Delete') and resource ('stored memory by key'), clearly distinguishing it from sibling tools like 'remember' (create) 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 deletion by key, which is clear usage context. However, no explicit when-not-to-use or alternatives are given. Sibling names hint at distinctions but the description itself does not elaborate.

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 burden. It discloses a rate limit of 5 messages per identifier per day, which is a key behavioral trait. It does not mention authentication, storage, or responses, but for a feedback tool, this 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 four sentences, each serving a purpose: stating the action, listing use cases, providing usage guidance, and noting the rate limit. No redundant or missing 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?

The description covers purpose, usage, and constraints adequately. The schema covers parameters completely. However, it does not describe the output (e.g., whether feedback is acknowledged or saved), but given the simplicity of the tool, this is acceptable.

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

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

All parameters have schema descriptions (100% coverage). The description adds value by advising users to describe what they tried and to avoid including the end-user's prompt verbatim. However, the schema already explains the enum values and context structure.

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

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

The description explicitly states the action ('Send feedback to the Pipeworx team') and the resource ('Pipeworx team'), and lists specific use cases (bug reports, feature requests, etc.). It clearly distinguishes from sibling tools like ask_pipeworx which are for queries.

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

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

The description provides clear when-to-use guidance via use cases and categories. It includes constraints like 'do not include the end-user's prompt verbatim' and a rate limit. However, it does not explicitly state when not to use, though alternatives are not needed for feedback.

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

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

Annotations declare readOnlyHint=true and destructiveHint=false, and the description reinforces this by describing a read-only check. It adds behavioral details: the tool searches Polymarket for related markets, groups them, and returns ranked opportunities with reasoning. No contradiction with annotations, and the description enriches understanding beyond what annotations provide.

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

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

The description is a single paragraph but well-structured with explicit labels ('TWO MODES:') and clear explanations. Every sentence adds value, and the key information is front-loaded. It is concise without being terse.

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 the tool returns: ranked opportunities with suggested trade direction and reasoning. It covers both modes, the scope of the search, and the logic. For a tool with two modes and no output schema, the description is fully complete.

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

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

Schema coverage is 100% (both parameters have descriptions), but the description adds significant value: it explains the two modes, the meaning of each parameter (event slug vs topic), and provides examples. This helps the agent understand how to use each parameter correctly.

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

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

The description clearly states the tool's purpose: finding arbitrage opportunities on Polymarket via monotonicity violations. It distinguishes two modes (event and topic) and explains the resource (Polymarket markets) and action (checking monotonicity). The purpose is 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 tells when to use each mode: event mode for a single event slug, topic mode for cross-event scenarios where related markets are in separate events. It explains why cross-event mode is necessary (single-event mode misses monotonicity across events). Examples like 'Strait of Hormuz traffic returns to normal' provide concrete guidance.

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

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

Annotations already provide readOnlyHint, openWorldHint, and destructiveHint. The description adds extensive behavioral details: it scans top markets, groups by asset, fetches price history once, computes model probability using a lognormal model from FRED and live coinpaprika price, ranks by |edge|, and returns top N with suggested trade direction. This exceeds what annotations provide and fully discloses the tool's method.

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 that efficiently conveys purpose, methodology, and output. It front-loads the main purpose. While it could be broken into bullet points for clarity, it is not overly verbose and every sentence adds value.

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

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

Given the tool's complexity (multi-step scanning, grouping, fetching, computing, ranking), the description is remarkably complete. It explains the model components (FRED + coinpaprika), grouping logic, ranking by edge magnitude, and output format (top N with direction). No output schema exists, but the description adequately describes return values.

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 meaning beyond the schema by explaining that 'limit' controls top N after ranking, 'window' filters volume window (default 1wk), and 'min_edge_pp' sets minimum edge threshold. It ties parameters to the tool's ranking logic, providing helpful context.

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

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

The description clearly states the tool scans high-volume Polymarket markets and returns those where Pipeworx data disagrees most with market price. It specifies the verb (scan/return), resource (Polymarket markets), and the ranking mechanism (by |edge|). It distinguishes itself from siblings like polymarket_arbitrage and bet_research by focusing on edge-based opportunity 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?

The description explicitly says 'Built for the "what should I bet on today" question' and mentions discovering opportunities without manual paging. It provides clear context for when to use the tool. While it doesn't explicitly exclude alternatives or state when not to use it, the sibling tools are implicitly differentiated by the description's focus on edge-based ranking.

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. States behavior (list all when key omitted) but does not disclose read-only nature or potential side effects. However, given the tool's simple 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?

Two concise sentences, front-loaded with purpose, then usage context. 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 simple input schema (1 optional param), no output schema, and no annotations, the description is complete. It explains the two modes of operation. Could mention that return format is a list or single string, but not required.

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 meaning by explaining that omitting key lists all memories. The parameter description in schema is clear, so additional detail is minimal but sufficient.

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

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

Clearly states the tool retrieves a memory by key or lists all memories when key is omitted. Uses specific verbs ('Retrieve', 'list') and resource ('memory'), and distinguishes from sibling tools like 'remember' (which stores) and 'forget' (which deletes).

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

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

Provides explicit context: 'Retrieve context you saved earlier in the session or in previous sessions.' While it doesn't explicitly state when not to use it, the purpose is clear enough to avoid confusion with other 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?

Despite no annotations, the description discloses key behaviors: it fans out to multiple sources in parallel, accepts ISO or relative dates, and returns structured changes, count, and URIs. This provides a good understanding of the tool's operation.

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

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

The description is concise at four sentences, front-loading purpose and then detailing behavior. Each sentence adds value, though slightly dense. 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?

With no output schema, the description still explains return structure (structured changes, total_changes count, URIs). It covers the three parameters, multiple sources, date formats, and usage scenarios. Comprehensive for a tool of this 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%, but description adds value beyond: explains that 'type' is limited to 'company', gives examples for 'since' like '7d' and '30d', and clarifies 'value' accepts ticker or CIK. It also recommends a typical monitoring window.

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: 'What's new about an entity since a given point in time.' It specifies the entity type 'company' and lists the data sources (SEC EDGAR, GDELT, USPTO). This distinguishes it well 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?

The description explicitly says 'Use for "brief me on what happened with X" or change-monitoring workflows,' providing clear usage context. However, it does not mention when not to use or alternatives, which would have been 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 the full burden. It discloses persistence behavior (authenticated vs. anonymous) and session duration (24 hours for anonymous), which is valuable beyond the input schema.

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

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

The description is two sentences, concise and front-loaded with the core action. Every sentence adds value, and the use cases are stated efficiently.

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 of the tool (two string params, no output schema, no nested objects), the description is complete. It covers purpose, usage, and persistence behavior adequately.

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 does not add parameter-specific details beyond what the schema already provides, but the examples in the schema are good. No extra semantic guidance is 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 'store a key-value pair in your session memory', which is a specific verb and resource. It distinguishes itself from sibling tools like 'forget' and 'recall' by focusing on writing 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?

Provides clear context for when to use: 'save intermediate findings, user preferences, or context across tool calls.' It also differentiates between authenticated and anonymous sessions, but does not explicitly mention 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?

No annotations provided, but description details output (ticker, CIK, name, URIs) and mentions it's a single call. Does not disclose rate limits or auth, but behavior is well-covered for a read-only lookup.

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

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

Three concise sentences: purpose, input specifics, output and benefit. No wasted words, front-loaded with main action.

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

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

For a simple lookup with no output schema, description covers purpose, input, and output adequately. Missing error handling or rate limits, but sufficient for most agents.

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; description adds examples and version context, reinforcing parameter meaning. Baseline 3 plus extra value gives 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?

Clearly states it resolves an entity to canonical IDs. Provides specific verb ('resolve'), resource ('entity to canonical IDs'), and context (company type, input formats). Distinct from siblings like ask_pipeworx or drive 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?

Describes when to use: for company entity resolution, replacing multiple lookup calls. Does not explicitly exclude alternatives, but context is clear enough for an agent.

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

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

Despite no annotations, the description details the return values (verdict, structured form, actual value with citation, percent delta) and the data sources (SEC EDGAR + XBRL). It also explains its behavior as a unified replacement for multiple steps, providing good transparency into its operation.

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

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

The description is concise with three sentences, each adding crucial information: purpose, supported domain, return values, and efficiency benefit. No waste, and the key purpose is 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 the tool's simplicity (one parameter) and lack of output schema, the description covers all necessary aspects: what it does, what it returns, its domain, and its advantage over sequential calls. It is complete for effective agent 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?

The schema already describes the parameter fully (coverage 100%), but the description adds value by providing examples of claims and clarifying the domain. This enhances the agent's understanding beyond the schema.

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

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

The description clearly states the tool's purpose: fact-checking natural-language claims against authoritative sources, specifically for company-financial claims. It distinguishes itself from sibling tools like compare_entities and resolve_entity by focusing on verification with external sources, providing a unique function.

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

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

The description specifies the domain (company-financial claims for US public companies) and mentions it replaces sequential calls, implying it's the preferred tool for such verification. However, it does not explicitly state when not to use it or mention alternative tools for other claim types, so some guidance is implicit but not exhaustive.

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