words

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 key behaviors: the tool selects data sources and fills arguments automatically, and it handles natural language questions. However, it lacks details on limitations (e.g., response format, error handling, rate limits) or prerequisites, which are important for a tool with no annotation coverage.

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

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

The description is front-loaded with the core functionality, uses efficient sentences, and includes helpful examples without redundancy. Every sentence adds value: the first explains the tool's role, the second details its automation, and the third provides illustrative use cases.

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 (natural language querying with automated tool selection) and lack of annotations/output schema, the description does well by explaining the process and providing examples. However, it could be more complete by mentioning potential limitations or the types of data sources available, which would help an agent anticipate 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 baseline is 3. The description adds value by explaining the parameter's purpose beyond the schema's 'natural language' note: it emphasizes that questions should be in 'plain English' and provides concrete examples (e.g., trade deficit, adverse events), clarifying the expected input format and scope.

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

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

The description clearly states the tool's purpose: 'Ask a question in plain English and get an answer from the best available data source.' It specifies the verb ('ask'), resource ('answer from data source'), and distinguishes from siblings by emphasizing natural language processing versus structured tool selection (e.g., 'No need to browse tools or learn schemas').

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

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

The description explicitly states when to use this tool: 'just describe what you need' in natural language, and provides clear examples like 'What is the US trade deficit with China?'. It implicitly distinguishes from sibling tools (e.g., autocomplete, find_synonyms) by focusing on broad data queries rather than specific linguistic or memory functions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool is 'useful for autocomplete and spelling suggestions,' which hints at read-only behavior, but doesn't explicitly state whether it's read-only, its performance characteristics, rate limits, or error handling. This leaves significant gaps for a tool with no annotation coverage.

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

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

The description is concise and well-structured with two sentences: the first states the core purpose, and the second adds practical context. Every sentence earns its place without redundancy, making it efficient 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 the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is adequate but incomplete. It covers the basic purpose and usage context but lacks details on behavioral traits, output format, or how it differs from siblings. This meets minimum viability but has clear gaps in providing a full 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?

Schema description coverage is 100%, so the schema already documents both parameters ('prefix' and 'limit') with clear descriptions. The description adds no additional parameter semantics beyond what the schema provides, such as examples of prefix usage or details on result ordering. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Get word completions from a prefix' specifies the verb ('Get') and resource ('word completions'), and 'Useful for autocomplete and spelling suggestions' provides context. However, it doesn't explicitly differentiate from sibling tools like 'find_words' or 'find_related', which might offer similar word-finding 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?

The description implies usage for autocomplete and spelling suggestions, giving some context for when to use it. However, it doesn't provide explicit guidance on when to choose this tool over alternatives like 'find_words' or 'find_synonyms', nor does it mention any exclusions or prerequisites for use.

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 detailed behavioral context: resolves market, classifies bet type, fans out to relevant packs, returns comparison. No contradiction.

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

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

Four sentences, each adding essential information. Front-loaded with purpose, uses examples, 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?

Despite no output schema, the description fully explains return values (evidence packet, market-vs-model comparison). It covers inputs, behavior, and outcome, making it complete for a research 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% with descriptions for both depth and market. The description adds value by explaining the fan-out logic per bet type and the meaning of quick vs thorough, enhancing 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 researches Polymarket bets by pulling Pipeworx data in one call. It specifies inputs (slug/URL/question text) and outputs (evidence packet, market-vs-model comparison). It is distinct from siblings like ask_pipeworx 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 provides explicit use cases: 'should I bet on X?', 'what does the data say?', 'is there edge?'. It positions itself as core demo product but lacks explicit when-not-to-use 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?

With no annotations provided, the description indicates the tool reads data from SEC EDGAR and FDA, returns paired data and URIs, and is non-destructive. However, it lacks details on error handling, latency, or rate limits, leaving some behavioral aspects unspecified.

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

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

The description is three sentences, front-loads the main purpose, and each sentence adds meaningful information without redundancy. It is appropriately sized and well-structured.

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

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

Given the tool's simplicity (two params, no output schema), the description provides sufficient context: it explains input values, returned data and URIs, and efficiency gains. It could be slightly more specific about output format but is largely complete.

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

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

Schema description coverage is 100% (both params have descriptions). The tool description adds value by giving concrete examples (tickers/CIKs for company, drug names) and clarifying the metrics returned per type, enhancing 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, specifies two entity types (company, drug) with distinct metrics, and notes it replaces multiple sequential calls, distinguishing it from siblings which are unrelated.

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 implies when to use (comparing entities efficiently) but does not explicitly state when not to use or suggest alternatives. However, no similar siblings exist, so the guidance is adequate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the search functionality and return format ('most relevant tools with names and descriptions'), but lacks details on performance aspects like rate limits, error handling, or authentication needs. It mentions a specific use case (500+ tools) which adds context, but doesn't cover all behavioral traits like pagination or result ordering.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by usage guidance. Both sentences earn their place by providing essential information without redundancy. It's appropriately sized for a search tool with clear structure.

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

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

Given the tool's moderate complexity (search operation with 2 parameters), 100% schema coverage, and no output schema, the description is reasonably complete. It covers purpose, usage context, and return format, though it could benefit from more behavioral details (e.g., how relevance is determined). The absence of an output schema is partially compensated by mentioning what's returned ('tools with names and descriptions').

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

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

Schema description coverage is 100%, so the baseline is 3. The description doesn't add significant parameter semantics beyond what's in the schema (e.g., it doesn't elaborate on query formatting or limit implications). It mentions the tool catalog context which relates to the query parameter, but this is minimal enhancement over the schema's natural language description.

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

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

The description clearly states the tool's purpose with specific verbs ('Search the Pipeworx tool catalog') and resource ('tool catalog'), and distinguishes it from siblings by specifying it returns 'tools with names and descriptions' rather than words or synonyms. It explicitly mentions the catalog context ('Pipeworx tool catalog') which differentiates it from the sibling tools that appear to be linguistic operations.

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

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

The description provides explicit usage guidelines: 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task.' This gives clear when-to-use criteria (large catalog, task-specific tool discovery) and implies alternatives (other tools for smaller sets or different needs). It effectively guides the agent on when to prioritize 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?

With no annotations, the description carries full burden. It discloses the tool returns pipeworx:// URIs and consolidates many calls. However, it does not mention potential issues like entity not found, rate limits, or authentication. Still, it provides substantial behavioral context.

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

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

The description is a single paragraph of four sentences, front-loaded with the main purpose. Every sentence adds value: purpose, data sources, output format, and usage advice. No redundant or 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?

Despite no output schema, the description clearly explains the return format (pipeworx:// URIs) and covers all relevant data categories. It also mentions the limitation (federal contracts excluded) and provides a fallback tool. Complete for 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%, and the description adds significant meaning: explains the type parameter supports only 'company', clarifies value can be ticker or CIK, and provides guidance to use resolve_entity for names. This goes beyond the schema descriptions.

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

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

The description clearly states the tool returns a full profile of an entity across multiple data sources in one call, listing specific data types and output format. It distinguishes itself from sibling tools by explicitly mentioning when to use an alternative (usa_recipient_profile) and hints at a prerequisite (resolve_entity for names).

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

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

The description explicitly states when to use this tool (for comprehensive company profiles) and when not to (for federal contracts, use usa_recipient_profile). It also implies a prerequisite (use resolve_entity if only a name) and the efficiency gain (replaces 10–15 sequential calls).

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 but only covers basic functionality. It doesn't disclose behavioral traits like rate limits, error conditions, response format, or whether results are sorted/filtered. The description is functional but lacks operational context.

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

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

The description is perfectly concise and front-loaded: a single sentence stating the core purpose followed by a comprehensive list of relation types. Every element serves a clear purpose with zero wasted words.

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

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

Given no annotations, no output schema, and 3 parameters, the description is incomplete. It explains what the tool does but not how it behaves operationally—missing details on response format, error handling, or performance characteristics that would help an agent use it effectively.

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 minimal value by listing relation types with codes, which the schema already documents clearly. No additional parameter semantics beyond what's in 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 specific action ('Find words related to') and resource ('a given word'), with explicit differentiation from sibling tools by listing all relation types. It distinguishes itself from find_rhymes and find_synonyms by being more comprehensive.

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 through the detailed relation type list, suggesting when to use specific codes, but lacks explicit guidance on when to choose this tool over siblings like find_rhymes or find_synonyms. No clear when-not-to-use or alternative scenarios are provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool finds and ranks rhymes but doesn't describe what 'score' means, whether results are paginated, error handling, rate limits, or performance characteristics. This leaves significant gaps in understanding how the tool behaves beyond its basic function.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('find words that rhyme') and adds a key behavioral detail ('ranked by score'). There's zero wasted text, making it appropriately sized and easy to parse quickly.

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 annotations and no output schema, the description is incomplete for a tool with behavioral complexity. It doesn't explain what 'score' represents, the format of returned results, or any constraints on the input word. For a tool that ranks results, more context about the ranking mechanism and output structure is needed.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters ('word' and 'limit'). The description adds no additional parameter semantics beyond what's in the schema, such as explaining word format constraints or score calculation. Baseline 3 is appropriate when the schema does all the parameter documentation work.

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 'find' and the resource 'words that rhyme with a given word', specifying the exact function. It distinguishes from sibling tools like 'find_synonyms' or 'find_related' by focusing specifically on rhyming words, not synonyms or related concepts.

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 no guidance on when to use this tool versus alternatives like 'find_synonyms' or 'find_related'. It mentions ranking by score but doesn't explain when rhyming is preferred over other word-finding methods, leaving the agent without contextual usage instructions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds value by specifying that results are 'ranked by similarity score,' which isn't obvious from the name or schema. However, it lacks details on error handling, rate limits, data sources, or output format (e.g., whether it returns a list of strings or structured objects). For a tool with no annotations, this leaves gaps in understanding its behavior.

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

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

The description is extremely concise—a single sentence that efficiently conveys the core functionality. Every word earns its place: 'Find synonyms' states the action, 'for a word' specifies the input, and 'ranked by similarity score' adds critical behavioral context. It's front-loaded with the main purpose.

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

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

Given the tool's moderate complexity (2 parameters, no annotations, no output schema), the description is minimally adequate. It covers the basic purpose and ranking behavior but lacks details on output structure, error cases, or usage distinctions from siblings. Without an output schema, the agent doesn't know what the return values look like (e.g., list of strings vs. objects with scores).

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 fully documents both parameters ('word' and 'limit'). The description doesn't add any parameter-specific information beyond what's in the schema. According to the rules, when coverage is high (>80%), the baseline score is 3 even with no param info in the description.

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

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

The description clearly states the tool's purpose: 'Find synonyms for a word, ranked by similarity score.' It specifies the verb ('find'), resource ('synonyms'), and key behavioral aspect ('ranked by similarity score'). However, it doesn't explicitly differentiate from sibling tools like 'find_related' or 'find_words', which might also involve word relationships.

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 no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'find_related' or 'autocomplete', nor does it specify contexts where synonyms are preferred over other word-finding operations. The agent must infer usage from the name and description 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes the tool as an 'advanced word search' but doesn't mention critical behaviors like whether it's read-only, how results are ordered, if there are rate limits, or what the output format looks like. For a search tool with no annotation coverage, this leaves significant gaps in understanding 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 a single, efficient sentence that front-loads the core purpose ('Advanced word search') and lists the constraint types. It avoids redundancy and wastes no words, though it could be slightly more structured by explicitly separating the constraint categories for easier parsing.

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

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

Given the complexity of a word search with multiple constraint types, no annotations, and no output schema, the description is incomplete. It doesn't explain how constraints combine (e.g., AND/OR logic), what the return values look like, or behavioral aspects like error handling. This leaves the agent with insufficient context for reliable tool 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?

The input schema has 100% description coverage, so the schema already documents all four parameters (limit, sounds_like, meaning_like, spelled_like) with clear descriptions. The tool description adds value by summarizing the constraint types (meaning, pronunciation, spelling) but doesn't provide additional syntax, examples, or interaction details beyond what the schema offers, meeting the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose as an 'advanced word search' that finds words matching constraints on meaning, pronunciation, and spelling. It specifies the verb ('find') and resource ('words') with the scope of constraints, but doesn't explicitly differentiate from sibling tools like 'find_synonyms' or 'find_rhymes' which might overlap in word-finding 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?

The description provides no guidance on when to use this tool versus alternatives like 'find_synonyms' or 'find_rhymes'. It mentions a 'combination of constraints' but doesn't specify scenarios, exclusions, or prerequisites for choosing this over other word-finding tools, leaving the agent to infer usage based on the parameters 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?

No annotations are provided, so the description carries full burden. While 'Delete' implies a destructive mutation, it doesn't disclose whether this requires specific permissions, whether deletion is permanent or reversible, what happens if the key doesn't exist, or any rate limits. This leaves significant behavioral gaps for a destructive 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 a single, efficient sentence with zero wasted words. It's appropriately sized for a simple tool with one parameter and gets straight to the point without unnecessary elaboration.

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

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

For a destructive tool with no annotations and no output schema, the description is incomplete. It doesn't address important contextual aspects like what 'stored memory' means in this system, whether deletion has side effects, what confirmation or response to expect, or how this tool relates to sibling memory operations.

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

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

Schema description coverage is 100%, so the schema already documents the single 'key' parameter. The description adds no additional meaning beyond what the schema provides, such as explaining what constitutes a valid memory key format or providing examples. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the action ('Delete') and resource ('a stored memory by key'), making the purpose immediately understandable. However, it doesn't distinguish this tool from potential siblings like 'recall' or 'remember' that might also work with stored memories, preventing a perfect score.

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 no guidance on when to use this tool versus alternatives. With sibling tools like 'recall' and 'remember' that likely interact with stored memories, there's no indication of when deletion is appropriate versus retrieval or creation.

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 rate limiting (5 per day per identifier) and advises describing attempts in terms of Pipeworx tools/data. It doesn't mention authentication or post-submission response, 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 four sentences, front-loaded with purpose, then usage guidelines, then rate limit. Every sentence adds value, and there is no fluff. It is highly concise and well-structured.

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

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

Given the tool has 3 parameters (one nested), no output schema, and is a straightforward feedback tool, the description covers purpose, parameter usage, rate limits, and content restrictions. No critical information is missing.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by detailing the 'type' enum options beyond the schema's short descriptions, and adds context about what to include in 'message'. This extra context justifies 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 clearly states the tool sends feedback to the Pipeworx team, listing specific use cases (bug reports, feature requests, data gaps, praise). It distinguishes itself from siblings, which are data retrieval or analysis tools, by being a feedback mechanism.

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 tells when to use the tool for various feedback types and instructs not to include the end-user's prompt verbatim. It also mentions rate limits. Although it does not explicitly state when not to use it, the context of sibling tools makes the use case clear.

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

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

Annotations already declare the tool as readOnlyHint=true and destructiveHint=false. The description adds significant behavioral context: it walks child markets, searches across events, groups, and checks monotonicity. It also describes the return type (ranked opportunities with reasoning). No contradictions.

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

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

The description is well-structured, starting with the main purpose and then detailing two modes. While slightly verbose, each sentence adds value, and front-loading aids quick scanning.

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

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

Given the lack of an output schema, the description adequately explains the return value (ranked opportunities with trade direction and reasoning). It covers both modes, their behavior, and the rationale for cross-event use, making it self-contained 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?

With 100% schema coverage, the description adds value by explaining the two modes and providing examples for each parameter (slug/URL for event, topic seed for topic). This enriches understanding beyond the schema descriptions.

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

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

The description clearly identifies the tool's function: finding arbitrage opportunities on Polymarket via monotonicity violations. It specifies two modes (event and topic) with concrete examples, setting it apart from siblings like polymarket_edges.

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

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

The description provides explicit guidance on when to use each mode, including a case where cross-event mode is necessary (e.g., separate events for different cutoffs). Though it does not compare with sibling tools, the mode selection is well explained.

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 provides detailed behavioral information: the model source (FRED, coinpaprika), the step-by-step process (scans top markets, groups by asset, fetches price history once, computes model probability, ranks), and the output format (top N with suggested trade direction). Annotations already mark it as read-only and non-destructive, but the description adds rich context about the computation 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 a single paragraph that efficiently conveys all necessary information. It is not overly long, and every sentence adds value. Could be slightly more structured (e.g., bullet points) but is concise enough.

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

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

For a tool with no output schema, the description explains the return type (top N ranked by edge magnitude with suggested trade direction). It covers the model briefly but sufficiently for an agent to understand what the tool produces. Given the complexity and the absence of an output schema, the description is complete.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description repeats defaults (limit default 10, max 25; window default 1wk; min_edge_pp default 0.5) but adds no new semantic meaning beyond the schema. A baseline score of 3 is appropriate.

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

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

The description uses specific verbs and nouns: 'Scan', 'return', 'disagree', 'computes model probability', 'ranks by |edge|'. It clearly distinguishes itself from a simple market listing or arbitrage tool, and explicitly states its purpose: to discover trading opportunities.

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

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

The description explicitly states the intended use case: 'Built for the "what should I bet on today" question — agents/users discover opportunities without paging through hundreds of markets by hand.' This gives clear guidance on when to use. It does not, however, mention when not to use or compare to siblings like 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 provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's behavior: retrieving or listing memories based on the presence of the key parameter, and clarifies persistence across sessions. However, it lacks details on error handling (e.g., what happens if the key doesn't exist) or performance aspects like rate limits, leaving some gaps.

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 and highly efficient: two sentences that directly convey purpose, usage, and parameter semantics without redundancy. Every sentence earns its place by adding critical information, making it easy for an AI agent to parse and apply.

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

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

Given the tool's moderate complexity (one optional parameter, no output schema, no annotations), the description is mostly complete. It covers purpose, usage, and parameter behavior adequately. However, it lacks details on return values (since no output schema exists) and error conditions, which could help the agent handle edge cases more effectively.

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 description coverage is 100%, so the schema already documents the single parameter 'key' and its optional nature. The description adds meaningful context by explaining the semantic effect of omitting the key ('list all stored memories'), which goes beyond the schema's technical documentation, though it doesn't provide additional syntax or format details.

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

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

The description clearly states the tool's purpose with specific verbs ('retrieve', 'list') and resources ('previously stored memory', 'all stored memories'), distinguishing it from siblings like 'remember' (store) and 'forget' (delete). It explicitly mentions retrieving context saved earlier in the session or previous sessions, making the scope 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 provides explicit guidance on when to use this tool vs. alternatives: 'Use this to retrieve context you saved earlier in the session or in previous sessions.' It also specifies when to omit the key parameter to list all memories, offering clear operational context without misleading information.

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 discloses important behavior: parallel fan-out across multiple sources, accepted input formats (ISO dates and relatives), and return structure (structured changes, total_changes, URIs). It does not mention potential delays or rate limits, but the provided information is substantial.

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, information-dense sentences. The first sentence states the purpose, followed by technical details and usage guidance. No extraneous information.

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

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

Given no output schema, the description adequately describes the return value (structured changes, count, URIs). It also explains the fan-out to multiple sources. Could mention pagination or limits, but overall sufficient for the tool's complexity.

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

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

Although the input schema has 100% description coverage, the description adds valuable context beyond the schema: e.g., 'only company supported today' for type, examples for since, and ticker/CIK formats for value. This enhances the agent's understanding.

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

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

The description clearly states the tool's purpose: retrieving what's new about an entity since a given time. It specifies data sources (SEC, GDELT, USPTO) and the use case, distinguishing it from siblings 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?

Explicitly suggests use cases like 'brief me on what happened' or change-monitoring workflows. While it doesn't list when not to use or alternatives, the context is clear enough for an agent to decide when to invoke 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: the tool performs a write operation ('store'), specifies storage duration ('persistent memory' vs. '24 hours'), and implies session-scoped memory. However, it lacks details on error conditions (e.g., key collisions) or performance limits, leaving minor gaps.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by usage guidelines and behavioral details. Every sentence adds value—no redundancy or fluff. It efficiently covers purpose, usage, and key behavioral traits in three concise sentences, making it easy to parse.

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

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

Given the tool's moderate complexity (write operation with session memory), no annotations, and no output schema, the description is largely complete. It covers purpose, usage, and key behavioral aspects like persistence rules. However, it lacks details on return values or error handling, which would be beneficial for full 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?

The input schema has 100% description coverage, with clear documentation for both 'key' and 'value' parameters. The description adds minimal semantic context beyond the schema, mentioning examples like 'subject_property' and 'user_preference' (which overlap with schema examples) and general use cases. This meets the baseline of 3 since the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with specific verbs ('store a key-value pair') and resource ('in your session memory'), distinguishing it from sibling tools like 'forget' (deletion) and 'recall' (retrieval). It explicitly mentions what can be stored ('intermediate findings, user preferences, or context across tool calls'), making the purpose unambiguous and distinct.

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

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

The description provides explicit guidance on when to use this tool ('to save intermediate findings, user preferences, or context across tool calls'), and implicitly distinguishes it from alternatives like 'recall' (for retrieval) and 'forget' (for deletion). It also clarifies usage contexts with 'authenticated users get persistent memory; anonymous sessions last 24 hours', offering clear when-to-use criteria.

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 the description carries full behavioral burden. It discloses that v1 only supports 'company' type, and explains input examples and output fields (ticker, CIK, name, URIs). However, it does not explicitly state that the tool is read-only or mention potential side effects, rate limits, or error behavior.

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

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

The description is a concise two-sentence structure. The first sentence states the purpose, and the second provides versioning, type support, examples, outputs, and benefit. No unnecessary words.

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

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

Given the tool has two required parameters with full schema descriptions, and no output schema, the description adequately covers inputs and outputs. It also explains the tool's efficiency advantage. However, it does not address error cases (e.g., no match found) or potential limitations beyond versioning.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds significant value by providing concrete examples of valid inputs (e.g., 'AAPL', '0000320193', 'Apple') and detailing the exact output fields, which enhances understanding beyond the schema alone.

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 entities to canonical IDs, specifies the support for company type, and lists accepted input formats (ticker, CIK, name). It also mentions the output and distinguishes itself by stating it replaces 2-3 lookup calls.

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

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

The description highlights efficiency (single call, replaces multiple lookups) but does not explicitly address when not to use this tool or mention alternative sibling tools. Context from sibling names suggests alternatives like ask_pipeworx or find_related, but no guidance is provided.

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

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

No annotations provided, so description carries full burden. It describes return values (verdict, structured form, actual value with citation, percent delta) and mentions replacing sequential agent calls, but omits details on side effects, authentication needs, or rate limits. Adequate but not exhaustive.

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

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

Two sentences with no redundant information. First sentence states purpose and scope, second sentence lists outputs and efficiency benefit. Every sentence is earned.

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 single parameter, no output schema, and no annotations, description sufficiently covers input format, domain, and output structure. Could mention limitations or error handling, but overall complete 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 has 100% coverage with description for 'claim' parameter. Description adds value by providing examples and clarifying natural-language format, going beyond schema details.

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 identifies the tool as fact-checking natural-language claims against authoritative sources, with specific domain of company-financial claims for public US companies via SEC EDGAR and XBRL. Verb 'validate_claim' plus resource and scope are explicit, and no sibling tool competes, so differentiation is not needed.

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

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

Description specifies the supported claim type (company-financial, public US companies) and mentions the sources used, implying when to use. However, it does not explicitly state when not to use or list alternatives, but given unrelated siblings, the guidance is adequate.

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