Google_analytics

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

The description discloses that Pipeworx picks the right tool, fills arguments, and returns the result, indicating automated delegation. It does not describe edge cases like unsupported questions or error handling, but with no annotations provided, the description covers the core behavioral promise well. No contradiction with annotations since none 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?

The description is three sentences, each adding value: first states purpose, second explains mechanics, third gives examples. 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 single parameter and no output schema, the description is complete enough for a natural language query tool. It explains input format with examples and the expected behavior. Minor omission: does not specify if the tool can handle follow-ups or multi-turn context, but that is not critical for this single-query interface.

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 schema already documents the 'question' parameter well. The description adds context by showing example questions, but doesn't add technical constraints or format details 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 tool's purpose: to answer a question in plain English using the best available data source, eliminating the need for the user to browse tools or learn schemas. This distinguishes it from siblings like ga_run_report or discover_tools, which are more specialized.

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 this tool: when the user wants to ask a question in natural language without specifying which underlying tool to invoke. It provides clear examples and contrasts with the need to browse tools manually, implying that this is the go-to for open-ended queries.

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

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

Annotations indicate read-only and non-destructive. Description adds rich behavioral details: market resolution, bet classification, fan-out to multiple data packs, and comparison output. 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?

Well-structured with front-loaded purpose, but slightly long. Every sentence adds value; 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 no output schema, description adequately summarizes output (evidence packet, comparison). All parameters covered, and annotations complement completeness.

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

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

Schema coverage is 100%, and description adds substantive meaning beyond schema: explains 'market' accepts three formats, and 'depth' enum options with defaults. Provides concrete examples.

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

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

The description clearly states the tool researches Polymarket bets, specifies input types (slug, URL, question text), and outlines the output (evidence packet, comparison). It distinguishes itself from siblings by being specialized for betting decisions.

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 use cases ('should I bet on X?') and positions itself as the recommended approach for betting context. Lacks explicit when-not-to-use or alternative tools, 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?

No annotations are provided, so the description must fully disclose behavioral traits. It mentions data sources (SEC EDGAR, FDA) and output format (paired data + URIs), but lacks details on potential side effects, latency, or rate limits. It implies a read operation but does not state that explicitly.

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

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

The description is three sentences with no wasted words. The primary action is front-loaded, and each sentence adds necessary detail without redundancy.

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

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

Despite no output schema, the description adequately outlines the return content (paired data + URIs) and covers both entity types. Missing details on error handling or invalid inputs, but overall sufficient for the tool's simplicity.

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 meaningful context: for 'values', it explains how to format inputs for each entity type with examples (e.g., tickers/CIKs for company, names for drug). This enhances 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 compares 2-5 entities side by side, specifying the data returned for each entity type ('company' vs 'drug'). It differentiates from sibling tools by its unique comparative capability.

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 efficiency by noting it replaces 8-15 sequential calls, but provides no explicit guidance on when to use or when not to use this tool compared to alternatives.

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

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

No annotations provided, so the description carries full burden. It states the tool searches by description and returns names and descriptions, but does not disclose any side effects, authentication needs, or performance characteristics. For a search tool, this is adequate 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?

Two concise sentences front-loading the core action and use case, with no wasted words. Every sentence adds value.

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

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

Given the tool's simplicity (search, no output schema), the description covers the key aspects: purpose, when to call, and example queries. It could mention that results are limited to names and descriptions, but that is implied. Completeness is high for this type of tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by suggesting example queries (e.g., 'analyze housing market trends') and specifying default/max for limit, improving clarity beyond schema.

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

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

The description clearly states it searches a tool catalog by description and returns relevant tools with names and descriptions. The specific verb 'Search' and resource 'Pipeworx tool catalog' distinguish it from siblings like ask_pipeworx or ga_run_report.

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 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task,' providing clear when-to-use guidance and implying it's a discovery step before using 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?

With no annotations, the description carries the transparency burden. It discloses that the tool returns citation URIs and replaces multiple sequential calls. Although it doesn't explicitly state read-only or discuss side effects, the content implies a safe query 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?

Two sentences efficiently convey purpose, data included, output format, and a usage alternative. No redundant or filler content; every clause 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 two simple parameters and no output schema, the description covers what the tool returns (list of data categories and citation URIs). It lacks details on pagination or error handling, but these are not critical for a comprehensive profile tool.

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

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

The input schema already provides clear descriptions for both parameters (type enum, value as ticker/CIK). The description adds context beyond the schema by noting that 'value' does not support names and recommending resolve_entity, which improves usability.

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

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

The description clearly states it returns a 'full profile' of an entity across multiple packs, enumerating specific data types (SEC filings, XBRL, patents, news, LEI). This verb-noun structure distinguishes it from siblings like compare_entities (comparison) and resolve_entity (name resolution).

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 advises using usa_recipient_profile for federal contracts instead, and suggests using resolve_entity first if only a name is available. No other alternatives are discussed, but the context is clear for the primary use case.

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 states the core behavior (delete) and identifies the required input (key). No annotations are provided, so the description carries the full burden. It does not mention side effects (e.g., is deletion permanent? are there confirmation prompts?). Could be improved by stating that the action is irreversible.

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 unnecessary words. Perfectly 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?

For a simple delete operation with one required parameter and no output schema, the description is adequate but minimal. It lacks behavioral details (e.g., whether the key must exist, error behavior). The sibling tools context suggests a memory system, but the description doesn't clarify constraints or outcomes.

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 clear description for the 'key' parameter. The description adds no extra semantic beyond the schema. Since schema already documents the parameter well, a 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 uses a strong verb ('Delete') and a specific resource ('stored memory') with a clear parameter ('by key'). It clearly distinguishes from siblings 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?

No guidance on when to use this tool versus alternatives. For example, no mention that deletion is irreversible or that it requires the exact key. With no sibling differentiation in description, the agent must infer from tool names alone.

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 must carry burden. Discloses that it lists metadata (dimensions and metrics) but does not mention if it requires specific permissions or if the list is exhaustive. Adequate 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?

Two sentences, no filler. First sentence states action and object, second sentence adds usage context. 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?

Given low complexity (1 param, no output schema), description is complete enough. Explains purpose and use case. Could mention return format but not strictly necessary.

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% for property_id (described as 'GA4 property ID (numeric)'). Description adds no further meaning beyond schema, so baseline 3 is appropriate.

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

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

Clearly states 'List all available dimensions and metrics for a Google Analytics 4 property', specifying verb (list) and resource (dimensions and metrics) with target (GA4 property). Distinguishes from siblings like ga_run_report which runs reports.

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?

States 'useful for discovering what fields can be used in reports', implying use before ga_run_report. However, no explicit when-not-to-use or alternative tools mentioned, such as ga_list_properties for listing properties.

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 implies read-only behavior (realtime report) and mentions specific metrics like activeUsers, which adds some context. However, it does not disclose rate limits, data freshness, or whether the tool modifies any state. The description is 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 concise (two sentences) and front-loaded with the purpose. However, it could be slightly more structured by separating the purpose from the details of what it shows.

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 somewhat complete but lacks details on return format, pagination, and error handling. For a realtime report tool, users would benefit from knowing the maximum time window or how to interpret the response.

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 does not add additional meaning beyond the schema for the parameters. It restates 'realtime metrics' and 'realtime dimensions' but does not clarify how they differ from standard metrics/dimensions or provide format constraints.

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 a realtime report for a GA4 property and specifies it shows currently active users and realtime metrics. However, it does not differentiate itself from sibling tools like ga_run_report or ga_get_metadata, which could be used for non-realtime data.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. It lacks context about prerequisites, limitations (e.g., only works for GA4 properties with realtime view), or when to choose ga_run_report instead.

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

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

Annotations are empty, so the description must disclose behavior. It states it uses the Admin API and returns account summaries with property details. However, it does not mention pagination behavior beyond the token parameter, rate limits, or whether the tool is read-only.

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

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

The description is concise with two sentences, front-loaded with the key action and resource. It earns its place without extraneous details.

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 (no required params, no output schema), the description is adequate but could mention that it lists all accessible properties, the response structure (list of account summaries), or that it uses the Admin API for broader context.

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 well-documented. The description adds no additional semantic context beyond what the schema already provides.

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

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

The description clearly states the verb 'List' and the resource 'Google Analytics 4 properties', and specifies it uses the Admin API. It is distinct from sibling tools like ga_run_report or ga_get_realtime, which focus on reporting rather than listing properties.

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 the agent needs to list accessible GA4 properties, but it does not explicitly state when to use this tool versus alternatives, nor does it mention prerequisites like authentication.

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. Description correctly states it 'runs a report' (read operation) but does not disclose limits (default 100, max 10000 rows) or potential delays for large queries. The limit is documented in schema but not in 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?

Single sentence with clear structure, front-loaded with purpose. Could be slightly more concise by removing redundant 'Retrieve analytics data' phrase, 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?

Given no output schema, description should explain return format or behavior. It does not. Also lacks details on relative dates (e.g., '7daysAgo') which are in schema but not in description. 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 baseline is 3. Description adds examples for dimensions and metrics but does not add meaning beyond schema for parameters like order_bys or dimension_filter.

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 runs a report on a GA4 property, specifying dimensions, metrics, and date ranges. However, does not distinguish from sibling tools like ga_get_metadata or ga_get_realtime, which also involve GA data retrieval.

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

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

No guidance on when to use this tool versus alternatives. Does not mention prerequisites (e.g., property_id must be valid) or cases where ga_get_realtime or other tools might be more appropriate.

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?

Since no annotations are provided, the description bears full responsibility for behavioral disclosure. It transparently states the rate limit (5 messages per identifier per day) and that it is free. It does not mention any destructive side effects or auth requirements, but for a feedback tool that is acceptable.

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

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

The description is extremely concise: two sentences that cover purpose, usage, and limitations. Every sentence is essential, with no wasted words.

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

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

Given the low complexity (3 parameters, no output schema), the description covers all necessary aspects: purpose, usage, rate limits, and parameter semantics. It is fully 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?

The input schema has 100% description coverage, but the description adds further value by clarifying each enum value in `type` and providing guidance on `message` length and specificity. This goes beyond what the schema alone offers.

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 ('Send feedback') and the recipient ('Pipeworx team'). It enumerates use cases (bug reports, feature requests, missing data, or praise), making the tool's purpose unmistakable and distinct from sibling tools like ask_pipeworx or ga_run_report.

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?

It provides explicit guidance on what to include ('what you tried in terms of Pipeworx tools/data') and what to avoid ('do not include the end-user's prompt verbatim'). It also mentions rate limits and cost. However, it does not explicitly compare to sibling tools or state when not to use this 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?

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds behavioral context: it walks child markets, searches across events, groups them, and checks monotonicity. No contradiction and adds value beyond annotations.

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

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

The description is moderately long but well-structured with clear 'TWO MODES' labeling. It front-loads the main purpose, and every sentence provides essential information (modes, rationale, output summary). 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?

The tool has no output schema, but the description mentions what is returned ('ranked opportunities with suggested trade direction + reasoning'). Given the two-mode complexity, this covers the necessary information. Slightly lacking details on the ranking criteria, but sufficient overall.

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?

Both parameters are described in the schema (100% coverage). The description adds meaningful context by explaining the two modes and giving example values (e.g., slug, seed question), which helps the agent understand usage beyond the schema's 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 finds arbitrage opportunities via monotonicity violations, with two distinct modes ('event' and 'topic'). It distinguishes itself from siblings like 'polymarket_edges' and explains the specific problem it solves (cross-event misses).

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 searches. It explains why topic mode is necessary (Polymarket separates events). It doesn't explicitly state when not to use, but the guidance 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?

The description goes beyond annotations (readOnlyHint, openWorldHint) by detailing internal behavior: scans top markets, groups by asset, fetches price history once, computes model probability, ranks by edge. It also explains the data sources (FRED, coinpaprika) and the model type, providing significant transparency. No contradictions with annotations.

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

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

The description is well-structured but slightly verbose (e.g., 'V1 covers crypto-price bets...'). It front-loads the core action ('Scan the highest-volume Polymarket markets...') but includes implementation details that, while informative, could be trimmed. However, every sentence adds value, so it earns a 4.

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 specifies what is returned ('top N ranked by edge magnitude with suggested trade direction'), which is sufficient for a read-only discovery tool. It covers the main use case and output structure. Given the tool's simplicity and annotations, 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?

Input schema covers all 3 parameters with good descriptions (limit, window, min_edge_pp). The description adds the concept of 'edge' but does not elaborate on parameter semantics beyond what the schema already provides. Since schema_description_coverage is 100%, a 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 specifies a clear verb-resource pair: 'Scan Polymarket markets and return ones where Pipeworx data disagrees most with market price.' It explicitly states the domain (crypto-price bets), the model used (lognormal from FRED + live coinpaprika), and the output (top N ranked by edge magnitude with trade direction). This distinguishes it from siblings like polymarket_arbitrage (arbitrage) and validate_claim (specific claims), as it focuses on opportunity discovery via edge.

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 directly addresses when to use this tool: for the 'what should I bet on today' question, to discover opportunities without manual paging through hundreds of markets. It does not explicitly state when not to use it or alternative tools, but the context is clear enough that an agent can infer it's for initial screening before deeper research (e.g., via bet_research or validate_claim).

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 the burden. It discloses that memories can be retrieved by key or listed, and that they persist across sessions. However, it does not mention whether retrieval is destructive, what happens if key doesn't exist, or performance implications. The basic behavior is clear.

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 action and key functionality. The second sentence adds context about use case. Efficient, though the second sentence could be integrated.

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 schema and no output schema, the description covers the main behavior. However, it lacks details on return format, error handling (e.g., key not found), and whether the memory list is ordered. Adequate but not 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%, so baseline is 3. The description adds the context that omitting key lists all memories, which aligns with the schema's optional key. No additional detail beyond the schema's own 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 retrieves a stored memory by key or lists all memories. The verb 'retrieve' and resource 'memory' are specific, and the dual functionality (by key or list all) is clearly distinguished from siblings like 'remember' and 'forget'.

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

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

The description explicitly says when to use it: 'to retrieve context you saved earlier.' It also implies when not to use key (to list all). However, it does not provide explicit alternatives or exclusions relative to 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?

With no annotations, the description carries full burden. It discloses the parallel fan-out behavior, the structure of the return (structured changes, count, pipeworx URIs), and the acceptable formats for 'since'. It does not cover latency, rate limits, or error handling, but the core behavior is transparent.

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

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

The description is concise with no redundant words. It front-loads the purpose in the first sentence, then details behavior, parameters, and return format efficiently. Every sentence earns its place.

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

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

Given the complexity (fan-out to three sources) and no output schema, the description explains the return structure (structured changes, count, URIs) adequately. It is complete for a monitoring tool, though it could mention error scenarios or empty results.

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 value by explaining the 'type' enum (only 'company' supported), providing concrete examples for 'since' (ISO and relative), and clarifying 'value' accepts ticker or CIK. This goes beyond the schema's basic 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: retrieving what's new about an entity since a point in time. It specifies the fan-out behavior for type='company' to SEC EDGAR, GDELT, and USPTO, immediately distinguishing it from sibling tools like entity_profile which likely provides a full profile.

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

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

The description gives explicit usage contexts: 'brief me on what happened with X' or change-monitoring workflows. It also provides examples for the 'since' parameter. However, it does not explicitly state when not to use this tool vs. siblings, nor does it mention any prerequisites or limitations beyond type='company'.

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 behavioral traits: stores key-value pairs, persists for authenticated users vs. 24-hour expiration for anonymous sessions. It doesn't mention any destructive behavior or limits like maximum key/value size.

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

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

Three sentences, each adding value: purpose, use cases, and persistence details. No wasted words, front-loaded with the core function.

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 simple key-value nature, the description fully covers what an agent needs to know: what it stores, when to use it, and persistence 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 description adds little beyond the schema. The description mentions 'key-value pair' but does not provide additional meaning about parameter constraints beyond what the schema already describes.

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

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

The description clearly states the tool stores a key-value pair in session memory, with specific verb 'store' and resource 'key-value pair'. It distinguishes itself from siblings like 'recall' and 'forget' by explaining the memory type and persistence behavior.

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 mentions when to use it (save intermediate findings, user preferences, context across calls) and provides context about persistence differences between authenticated and anonymous users. However, it doesn't 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?

With no annotations, the description carries full burden. It clearly explains the tool accepts three identifier types, returns canonical fields and URIs, and is scoped to company type in v1. It does not cover error behavior or authentication, but the core behavior is well-described.

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

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

The description is three sentences: first sentence states purpose, second details current version, third explains output and benefit. No wasted words, key information is front-loaded, and structure facilitates quick understanding.

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 2-parameter tool without output schema, the description covers inputs, outputs, and benefit. It lacks output schema but compensates by listing return fields. Minor gaps in error handling are acceptable given tool simplicity.

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 versioning context for the 'type' parameter and example formats for 'value', but the schema description for 'value' already includes the same examples. No additional parameter semantics beyond the schema are provided.

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

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

The description clearly states the tool resolves an entity to canonical IDs, specifies the supported type (company), and lists accepted input formats and outputs. It distinguishes itself by noting it replaces multiple lookup calls, making the purpose unambiguous and differentiated.

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

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

The description indirectly guides usage by stating it replaces 2-3 lookup calls, implying use when consolidating entity resolution. It does not explicitly exclude scenarios or name alternatives, but among the siblings (mostly GA and memory tools), this is the only entity resolver, so context is sufficient.

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

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

The description details the tool's behavior: input (natural-language claim), process (uses SEC EDGAR + XBRL), and output (verdict, structured form, value, citation, delta). Since no annotations exist, the description carries the full burden; it provides a solid overview but lacks details on error handling or limitations.

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

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

The description is three sentences long, with the primary action stated first. Each sentence adds distinct value: purpose, details, and benefit. No extraneous information, making it highly efficient.

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

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

Despite lacking an output schema, the description enumerates all return components (verdict types, extracted form, actual value with citation, percent delta). It covers domain constraints and input format, providing sufficient context for an agent to 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?

The input schema already describes the 'claim' parameter with 100% coverage. The tool description adds concrete examples (e.g., 'Apple's FY2024 revenue was $400 billion'), providing meaningful context beyond the schema, elevating it above 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 states a specific verb ('Fact-check') and resource ('authoritative sources'), with domain constraints (company-financial claims via SEC EDGAR + XBRL). It lists return components, making purpose unambiguous. It implicitly distinguishes from sibling tools like ask_pipeworx by specifying structured output and domain.

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 clearly indicates the tool replaces 4–6 agent calls for financial claim verification, guiding agents to use it for such tasks. It specifies the supported domain (US public company financials), implying when not to use it. However, it does not explicitly name alternative sibling tools.

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