superhero

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 behavioral traits: Pipeworx 'picks the right tool, fills the arguments, and returns the result,' which explains the automation process. However, it lacks details on limitations (e.g., rate limits, data source availability, error handling) or authentication needs, leaving gaps for a tool that interacts with external data sources.

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, followed by explanatory context and concrete examples. Every sentence earns its place: the first defines the purpose, the second explains the automation, the third provides usage guidance, and the examples clarify application. No redundant or verbose language is present.

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 or output schema, the description is moderately complete. It covers the high-level process and usage but omits details on response format, error conditions, or data source constraints, which could hinder an agent's ability to handle edge cases 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 value by emphasizing the parameter should be in 'plain English' or 'natural language,' providing examples that illustrate the expected format beyond the schema's generic description. This enhances understanding of how to formulate the question parameter effectively.

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 it from sibling tools by emphasizing natural language processing instead of browsing tools or learning schemas. The examples further clarify its unique role.

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: 'No need to browse tools or learn schemas — just describe what you need.' It provides clear alternatives (implicitly suggesting not to use sibling tools like discover_tools for simple queries) and includes specific examples ('What is the US trade deficit with China?') to illustrate appropriate use cases.

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, openWorldHint=true, and destructiveHint=false, so the description carries less burden. It adds useful behavioral context: resolves the market, classifies the bet, fans out to appropriate data packs, and returns an evidence packet with comparison. No contradiction 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 four sentences, each providing distinct value: input methods, classification, fan-out mechanism, and usage context. It is slightly longer than necessary but remains front-loaded with the action verb and key points.

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 the tool (market resolution, classification, fan-out), the description covers the main outcomes and input types. No output schema exists, but it explains the return value (evidence packet + comparison). Minor gaps like error handling or performance are acceptable 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%, so baseline is 3. The description adds meaning by explaining the 'market' parameter's possible forms and noting that 'depth' defaults to 'thorough' and contrasts 'quick' vs 'thorough'. This goes beyond the schema's enum 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 function: researching a Polymarket bet by pulling Pipeworx data. It specifies three input types (slug, URL, question text) and the output (evidence packet and market-vs-model comparison). It also distinguishes itself from siblings by positioning it as the core demo product that avoids manual pack discovery.

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

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

The description provides explicit usage context with example questions like 'should I bet on X?' and 'what does the data say about this Polymarket market?'. It contrasts with alternatives by stating that agents using this tool convert better than those using other tools, though it does not explicitly name sibling tools or state when not to 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?

With no annotations provided, the description carries the full burden. It discloses that the tool returns paired data and resource URIs, and that it replaces multiple calls. However, it does not mention side effects, authentication needs, rate limits, or whether it's a read-only operation.

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

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

The description is concise with three sentences, front-loaded with the main action. Every sentence adds value with no redundancy.

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

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

Given the absence of an output schema, the description provides adequate context about return values (paired data + URIs) and entity-specific metrics. It could include more detail about error cases or data freshness, but overall it is sufficient.

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

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

The input schema has 100% coverage, but the description adds significant meaning by explaining what data is returned for each type (e.g., revenue for companies, adverse-event counts for drugs) and clarifying the format of values (tickers/CIKs for companies, drug names for drugs).

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 and distinguishes between 'company' and 'drug' types with specific data points for each. It explicitly contrasts with making 8-15 sequential calls, making the purpose 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 clear context on when to use the tool (comparing entities) and highlights efficiency gains over sequential calls. However, it does not explicitly mention when not to use it or suggest alternatives, leaving a minor gap.

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 behaviors: it's a search operation (implying read-only, non-destructive), returns a limited set of results ('most relevant tools'), and has a specific call order recommendation ('Call this FIRST'). However, it doesn't mention potential limitations like rate limits, authentication needs, or error handling, leaving some gaps in 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 front-loaded and highly concise, consisting of two sentences that each earn their place: the first defines the tool's function and output, and the second provides critical usage guidance. There is no wasted text, and the structure efficiently communicates essential information 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?

Given the tool's moderate complexity (search functionality with 2 parameters), no annotations, and no output schema, the description does a good job of covering context. It explains the tool's role in a large catalog and when to use it, but it doesn't describe the return format (e.g., structure of results) or potential errors, which would be helpful for an agent to interpret outputs correctly.

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

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

Schema description coverage is 100%, so the schema already documents both parameters ('query' and 'limit') thoroughly. The description adds no additional parameter semantics beyond what's in the schema—it doesn't explain parameter interactions, default behaviors, or usage nuances. This meets the baseline of 3 for high schema coverage without extra value from 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 with specific verbs ('Search the Pipeworx tool catalog') and resource ('tool catalog'), and distinguishes it from siblings by emphasizing its search functionality. It explicitly mentions what it returns ('most relevant tools with names and descriptions'), making the purpose highly specific 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 provides explicit usage guidelines: it states when to use it ('Call this FIRST when you have 500+ tools available and need to find the right ones for your task'), which includes a threshold condition (500+ tools) and a specific scenario (finding tools for a task). It implicitly suggests alternatives by positioning this as a first step, though it doesn't name specific sibling tools, the guidance is clear and actionable.

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

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

Discloses that it aggregates data from multiple sources (SEC, XBRL, USPTO, GDELT, GLEIF) and returns pipeworx:// citation URIs. Also notes efficiency gains (replaces 10-15 sequential calls). No annotations provided, so description carries full burden and does so well.

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

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

Description is concise, front-loaded with purpose, and each sentence adds value. No redundant 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 complexity (multiple data types) and lack of output schema, description is complete: lists what data is returned and in what format. Also provides alternative tool usage, making it self-contained.

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?

Adds meaning beyond schema: explains that type is currently only 'company', and value can be ticker or zero-padded CIK. Also clarifies that names are not supported and recommends resolve_entity. 100% schema coverage with extra guidance.

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

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

The description specifies that the tool provides a full profile of an entity across multiple Pipeworx packs, listing specific data types (SEC filings, revenue, patents, news, LEI). It distinguishes itself from sibling tools like resolve_entity and usa_recipient_profile by clarifying scope and alternatives.

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

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

Explicitly states when to use this tool (for comprehensive entity profile) and when not to (for federal contracts, use usa_recipient_profile). Also advises using resolve_entity first if only a name is available, as names are not supported.

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 deletes a memory, implying a destructive mutation, but fails to mention critical details like whether deletion is permanent, requires specific permissions, has side effects, or returns confirmation. This leaves significant gaps in understanding the tool's 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 single, efficient sentence with zero waste. It is front-loaded and directly communicates the tool's purpose without unnecessary elaboration, making it 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's destructive nature (deletion), no annotations, and no output schema, the description is incomplete. It lacks information on behavioral traits (e.g., permanence, permissions), return values, or error handling, which are essential for a mutation tool. The context signals do not compensate for these gaps.

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

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

The input schema has 100% description coverage, with the 'key' parameter fully documented. The description adds no additional meaning beyond the schema, such as format examples or constraints. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, though the description offers no compensatory value.

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 ('Delete') and resource ('a stored memory by key'), distinguishing it from sibling tools like 'remember' (create) and 'recall' (retrieve). It precisely communicates the tool's function without ambiguity.

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 deleting memories by key, but provides no explicit guidance on when to use this tool versus alternatives (e.g., 'list_all' for viewing or 'recall' for accessing). It lacks context on prerequisites or exclusions, leaving usage inferred rather than stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states it's a read operation ('Get'), but doesn't cover aspects like error handling (e.g., what happens if ID is out of range 1–731), rate limits, authentication needs, or response format. For a tool with no annotations, this leaves significant 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 a single, efficient sentence that front-loads the purpose and key details (data fields and ID requirement). Every word earns its place with no redundancy or unnecessary information, making it highly concise and well-structured for 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?

Given the tool's low complexity (single required parameter, no nested objects) and no output schema, the description is minimally adequate. It covers what data is retrieved but lacks details on behavioral aspects like error handling or response structure. With no annotations to fill gaps, it should do more to be fully complete, but it meets the basic threshold for a simple read tool.

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

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

Schema description coverage is 100%, with the input schema fully documenting the 'id' parameter as a numeric superhero ID in range 1–731. The description adds no additional parameter semantics beyond what the schema provides, such as format examples or edge cases. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but doesn't detract either.

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 ('Get') and resource ('biography details for a superhero by ID'), specifying the exact data fields retrieved (full name, aliases, publisher, first appearance, alignment). It distinguishes from siblings like 'get_hero' and 'get_powerstats' by focusing on biography details rather than general hero info or power stats. However, it doesn't explicitly contrast with 'list_all', which might return broader lists.

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 is provided on when to use this tool versus alternatives. The description implies usage for retrieving biography details by ID, but it doesn't mention when to choose this over 'get_hero' (which might include biography) or 'list_all' (which might list heroes without details). There are no explicit when/when-not statements or named alternatives.

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

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

No annotations are provided, so the description carries the full burden. It describes the tool as a read operation ('Get full data'), which implies it's non-destructive, but doesn't explicitly state safety aspects like read-only nature, authentication needs, rate limits, or error handling. The description adds minimal behavioral context beyond the 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 action ('Get full data') and includes all necessary details without redundancy. Every word earns its place by specifying the resource, parameter, and data inclusions clearly.

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 low complexity (1 parameter, no nested objects) and high schema coverage, the description is adequate for basic understanding. However, with no annotations and no output schema, it lacks details on behavioral traits (e.g., error handling) and return values, which could be important for an AI agent to use it 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 has 100% description coverage, with the 'id' parameter documented as 'Numeric superhero ID (1–731)'. The description adds value by reinforcing the parameter's purpose ('by their numeric ID') and implying the data returned, but doesn't provide additional syntax, format details, or constraints beyond what the schema already covers.

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 ('Get full data') and resource ('a superhero by their numeric ID'), and specifies what data is included ('powerstats, biography, appearance, and images'). It distinguishes from siblings like get_biography and get_powerstats by indicating it returns comprehensive data rather than specific subsets. However, it doesn't explicitly contrast with list_all, which might retrieve multiple heroes.

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 by stating 'by their numeric ID', suggesting this tool is for retrieving detailed information about a specific hero when the ID is known. However, it provides no explicit guidance on when to use this versus alternatives like get_biography for partial data or list_all for multiple heroes, nor does it mention prerequisites or exclusions.

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

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

No annotations are provided, so the description carries full burden. It states it's a read operation ('Get'), implying non-destructive, but doesn't disclose behavioral traits like error handling (e.g., for invalid IDs), rate limits, authentication needs, or response format. For a tool with zero annotation coverage, this leaves significant 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 a single, efficient sentence with zero waste. It front-loads the purpose and includes all necessary details (statistics listed, resource specified). Every word earns its place, making it 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's low complexity (single parameter, no output schema, no annotations), the description is adequate but has clear gaps. It covers the purpose and parameters indirectly via schema, but lacks output details, error handling, and usage guidelines. For a simple read tool, it meets minimum viability but could be more 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%, with the single parameter 'id' fully documented in the schema (numeric, required, range 1–731). The description adds no additional parameter semantics beyond what the schema provides, such as format details or examples. 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 verb ('Get') and resource ('power statistics for a superhero by ID'), specifying the six specific statistics (intelligence, strength, speed, durability, power, combat). It distinguishes from siblings like 'get_biography' (biographical data) and 'list_all' (listing heroes), but doesn't explicitly contrast with 'get_hero' (which might return broader hero 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?

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, when not to use it, or how it differs from 'get_hero' (which could potentially include power stats). Usage is implied by the purpose but not explicitly stated.

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

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

With no annotations provided, the description carries the full burden. It states the tool lists data but does not disclose behavioral traits like whether it's read-only, pagination behavior, rate limits, authentication needs, or error handling. This leaves significant gaps for an agent to understand 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 a single, efficient sentence that front-loads the purpose ('List all superheroes') and specifies the data returned. Every word adds value without redundancy, making it highly concise and well-structured for 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?

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate for a basic list operation. However, it lacks details on output format (e.g., structure of the list) and behavioral context (e.g., performance or limitations), which could be helpful for an agent despite the low 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?

The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description appropriately does not include parameter details, earning a baseline score of 4 for not adding unnecessary information beyond the schema.

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

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

The description clearly states the verb ('List') and resource ('all superheroes in the database'), specifying the exact data returned ('IDs, names, and slugs'). It distinguishes from siblings like 'get_biography' (specific biography), 'get_hero' (single hero), and 'get_powerstats' (power statistics) by emphasizing comprehensive listing without filtering.

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

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

The description implies usage for retrieving a complete list of superheroes, which contrasts with siblings that fetch specific data (e.g., 'get_hero' for a single hero). However, it lacks explicit guidance on when not to use it or alternatives, such as advising against it for filtered searches or when only partial data is needed.

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 full burden. It discloses the rate limit and that it's free, and what content to include/exclude. It doesn't mention whether feedback is private or public, but overall it is fairly transparent for a feedback tool.

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

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

The description is very concise at three sentences, with the most important information front-loaded. Every sentence earns its place 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?

Given the simplicity of the tool (no output schema, nested objects have descriptions, all params covered), the description fully covers purpose, usage, and behavioral constraints. It is complete for an AI agent to use correctly.

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

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

Schema coverage is 100% with detailed descriptions for each parameter. The description adds extra guidance beyond the schema, specifically advising not to include the user's prompt verbatim, which adds semantic value to the 'message' parameter.

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

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

The description clearly states the verb ('send feedback') and the resource ('Pipeworx team'), and specifies use cases (bug reports, feature requests, missing data, praise), which distinguishes it from sibling tools like ask_pipeworx or discover_tools.

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

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

Explicitly tells when to use the tool (for bug reports, etc.) and provides specific guidance: describe what you tried in terms of Pipeworx tools/data, do not include the end-user's prompt verbatim, and notes the rate limit of 5 messages per day. This gives clear contextual 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?

Annotations indicate readOnlyHint=true, openWorldHint=true, destructiveHint=false. The description adds behavioral context: it checks monotonicity violations, returns ranked opportunities with reasoning, and explains cross-event edge case. No contradiction 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 structured with a clear purpose, two modes explained, and a note about cross-event catching cases missed by single-event. It is fairly concise but could be slightly tighter.

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

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

Given no output schema, the description mentions the return type ('ranked opportunities with suggested trade direction + reasoning'). Could be more precise about return structure, but it provides adequate context for this analytic 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 each parameter described. The description adds meaning by explaining the two modes: event slug/URL vs topic/seeds, with examples. This enriches the schema beyond basic types.

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 arbitrage opportunities on Polymarket by checking for monotonicity violations across related markets.' It distinguishes two modes (event and topic) and differentiates 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 clear guidance on when to use each mode, including a real example of when cross-event mode is necessary ('Polymarket lists each cutoff as its own event'). However, it does not explicitly state when not to use the tool or mention alternatives.

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

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

The description adds significant behavioral detail beyond annotations: it's read-only, uses a lognormal model from FRED and coinpaprika, groups by asset, fetches price history once, and computes edge. Annotations already mark it as read-only and non-destructive, so no contradiction.

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

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

The description is well-structured and informative, starting with the core action and then detailing the model and use case. It is slightly verbose but every sentence adds value.

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

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

For a tool with 3 parameters and no output schema, the description completely covers the algorithm, data sources, output format (top N with trade direction), and intended use case, leaving no major gaps.

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

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

Schema covers 100% of parameters with descriptions. The description adds value by explaining the role of each parameter in the ranking process (e.g., 'Top N after ranking') and defaults, but the schema already provides basic meaning.

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

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

The description clearly states it scans high-volume Polymarket markets to find where Pipeworx data disagrees with market price, using a specific model for crypto bets. It distinguishes from siblings like 'polymarket_arbitrage' by focusing on edge magnitude rather than arbitrage.

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

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

The description explicitly says it's built for the 'what should I bet on today' question, helping discover opportunities without manual browsing. While it provides clear context, it does not mention when not to use or alternative tools.

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

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

No annotations are provided, so the description carries the full burden. It describes the tool's behavior (retrieval or listing based on key presence) and mentions persistence across sessions, which is useful context. However, it lacks details on error handling (e.g., what happens if key doesn't exist), return format, or any limitations like rate limits or permissions, leaving 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 appropriately sized and front-loaded: the first sentence states the core functionality, and the second adds context about usage. Every sentence earns its place by providing essential information without redundancy, making it efficient and easy to parse.

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

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

Given the tool's moderate complexity (single optional parameter, no annotations, no output schema), the description is adequate but has clear gaps. It explains what the tool does and when to use it, but lacks details on return values (since no output schema) and behavioral aspects like error handling. For a retrieval tool with no structured output, more context on expected results would improve 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 schema description coverage is 100%, so the schema already documents the single parameter 'key' with its description. The description adds value by explaining the semantics: 'omit key' to list all keys, which clarifies the optional nature and dual functionality. This goes beyond the schema's basic description, earning a score 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 clearly states the tool's purpose with specific verbs ('retrieve', 'list') and resources ('previously stored memory by key', 'all stored memories'). It distinguishes from siblings by mentioning 'context you saved earlier' which implies it's for retrieving user-saved data, unlike tools like 'get_biography' or 'get_powerstats' that likely fetch predefined 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 provides explicit usage guidance: 'Retrieve a previously stored memory by key, or list all stored memories (omit key).' It specifies when to use (retrieve or list memories) and how (with or without key), and mentions context 'saved earlier in the session or in previous sessions,' which helps differentiate from tools like 'remember' (likely for saving) or 'forget' (likely for deleting).

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool fans out in parallel to three sources, accepts specific date formats, and returns a structured response with URIs. It does not mention authentication, rate limits, or error handling, but for a read-only discovery tool, this is reasonably 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 a single, well-structured paragraph. It front-loads the purpose ('What's new...'), then details behavior and output. Every sentence adds essential information without redundancy or verbosity.

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

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

Given the absence of an output schema, the description compensates by outlining the return structure (changes + count + URIs). It covers input parameters, supported sources, and date formats. It does not mention pagination, limits, or ordering, but for a tool of this complexity, the description is largely complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the 'since' parameter format with examples (ISO date and relative strings), confirming only 'company' is supported for 'type', and describing the return structure (structured changes, total_changes count, pipeworx:// URIs), which is not in the schema.

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

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

The description clearly states the tool's purpose: finding what's new about an entity (company) since a given time, with specific fan-out to SEC EDGAR, GDELT, and USPTO sources. This distinguishes it from siblings like entity_profile (which likely provides static profile) and compare_entities (comparison). The verb 'brief me' reinforces the specific use case.

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 'Use for "brief me on what happened with X" or change-monitoring workflows,' giving clear usage context. It does not mention when to avoid using this tool or provide alternatives, but the guidance is sufficient for typical scenarios.

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 persistence characteristics ('authenticated users get persistent memory; anonymous sessions last 24 hours'), and mentions the scope ('across tool calls'). However, it does not cover potential errors, rate limits, or authentication requirements beyond the persistence note.

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 appropriately sized and front-loaded, with two concise sentences that directly address purpose and behavioral context. Every sentence adds value: the first states the core function and usage, while the second provides important persistence details. There is no redundant or unnecessary 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 the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is largely complete. It covers purpose, usage context, and key behavioral traits like persistence. However, it lacks details on return values (since no output schema exists) and does not mention potential side effects or error conditions, leaving minor gaps in full contextual 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?

The input schema has 100% description coverage, with clear documentation for both required parameters ('key' and 'value'). The description does not add significant meaning beyond what the schema provides, as it only generally references 'key-value pair' without detailing parameter usage or constraints. The baseline score of 3 is appropriate given the comprehensive 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 with specific verbs ('store a key-value pair') and resource ('in your session memory'), distinguishing it from siblings like 'forget' (remove) and 'recall' (retrieve). It explicitly mentions what can be stored ('intermediate findings, user preferences, or context across tool calls'), making the purpose 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 clear context on when to use this tool ('to save intermediate findings, user preferences, or context across tool calls'), but does not explicitly mention when not to use it or name alternatives like 'forget' for deletion. It implies usage for persistence needs but lacks explicit exclusions or comparisons with sibling tools.

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

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

No annotations provided, so the description carries the burden. It describes inputs and outputs well but does not disclose if the operation is read-only, any permissions needed, or error behavior. It gives a good overview but lacks safety or cost details.

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 succinct sentences conveying all essential information: purpose, inputs, outputs, and benefit. 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?

Covers inputs, outputs, and replaces multiple calls. No output schema, but description lists return fields. Lacks details on error handling or when entity not found, but overall adequate 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% with descriptions for both parameters. The description adds value by providing concrete examples (AAPL, CIK, Apple) and clarifying the value parameter can be a ticker, CIK, or name. This goes beyond the schema enum and 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 it resolves an entity to canonical IDs, specifies the return values (ticker, CIK, name, URIs), and mentions it replaces multiple lookup calls. It distinguishes itself from sibling tools which handle queries, biographies, etc.

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

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

It explicitly says 'in a single call' and 'replaces 2-3 lookup calls,' providing clear when-to-use context. It also notes v1 supports only 'company' type. However, it does not explicitly mention when not to use or list 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 discloses return type, verdict options, and citation format. It does not mention authorization or rate limits, but the information provided is sufficient for basic use.

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 fluff. First sentence defines core purpose, second adds specifics and value. 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 single-parameter tool with no output schema, the description is exceptionally complete. It covers scope, source, return structure, and even performance benefit over alternative approaches.

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

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

Schema coverage is 100% and the description adds context beyond the schema: it specifies supported claim types and provides examples, helping agents understand valid input format.

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 ('natural-language claim against authoritative sources'), and distinguishes from siblings by noting it replaces 4-6 sequential agent calls. It clearly defines scope (company-financial claims) and sources (SEC EDGAR + XBRL).

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

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

Provides clear context on when to use (for company-financial claims) and implies replacement of a chain of tools. However, it lacks explicit 'when not to use' or direct naming of alternatives among siblings.

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