tarot

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: it interprets natural language questions, selects appropriate data sources, executes queries, and returns results. However, it doesn't mention limitations like response time, data freshness, or potential errors, which would be helpful 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 perfectly structured and concise. The first sentence states the core functionality, the second explains the mechanism, and the third provides clear usage guidance. The examples are relevant and illustrative without being verbose. Every sentence earns its place by adding distinct value.

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

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

For a single-parameter tool with no output schema and no annotations, the description provides strong contextual completeness. It explains what the tool does, how to use it, and gives concrete examples. The only gap is the lack of information about return format or error handling, which would be helpful given the absence of output schema.

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 'question' parameter adequately. The description adds minimal value beyond the schema by emphasizing 'plain English' and 'natural language' in the examples, but doesn't provide additional syntax, format, or constraint details. This meets 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: 'Ask a question in plain English and get an answer from the best available data source.' It specifies the verb ('ask'), resource ('answer'), and mechanism ('Pipeworx picks the right tool, fills the arguments'). It distinguishes itself from sibling tools by offering a natural language interface rather than requiring specific tool knowledge.

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: 'No need to browse tools or learn schemas — just describe what you need.' It contrasts with sibling tools that likely require specific parameters or tool selection. The examples further clarify appropriate use cases, showing it's for natural language queries rather than structured operations.

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, description carries full burden. It discloses data fields per type and resource URIs, but lacks details on error handling, rate limits, or authorization. Decent 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 zero waste. Front-loaded with purpose and key differentiators. Every phrase earns its place.

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

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

Covers essential aspects: types, data fields, and replacement of multiple calls. Lacks output format details, but given no output schema, description is nearly sufficient. Minor gap in limitations (e.g., geographic scope).

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

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

Schema coverage is 100%, and description adds value by explaining 'type' behavior and providing examples for 'values' (e.g., tickers vs. drug names). Enhances schema without redundancy.

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

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

Description clearly states 'Compare 2–5 entities side by side in one call' and distinguishes between company and drug types with specific data sources (SEC EDGAR, FDA, clinicaltrials). No sibling tool offers comparison, so it stands out.

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 explicitly says 'Replaces 8–15 sequential agent calls,' guiding agents to use this for multi-entity comparisons. However, it does not mention when not to use or alternative tools for single entity lookups.

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: it's a search function that returns relevant tools with names and descriptions, and specifies it should be called first in certain contexts. However, it doesn't mention potential limitations like rate limits, authentication needs, or error conditions.

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 with two sentences that each earn their place. The first sentence explains the core functionality, and the second provides crucial usage guidance. No wasted words, and the most important information (what it does) is front-loaded.

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

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

Given the tool's moderate complexity (search function with 2 parameters), no annotations, and no output schema, the description does well by explaining the purpose, usage context, and behavioral aspects. However, it doesn't describe the return format or structure of results, which would be helpful since there's no output schema.

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 description coverage, the baseline is 3. The description doesn't add specific parameter details beyond what's already in the schema (which thoroughly documents both 'query' and 'limit' parameters). It mentions searching 'by describing what you need' which aligns with the 'query' parameter but doesn't provide additional semantic context.

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

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

The description clearly states the tool's purpose with specific verbs ('Search the Pipeworx tool catalog') and resource ('tool catalog'), and explicitly distinguishes it from sibling tools by mentioning '500+ tools available' context. It provides a clear action and scope.

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

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

The description provides explicit usage guidance: 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task.' This gives clear conditions for when to use this tool versus alternatives, including a specific threshold (500+ tools) and context (finding tools for a task).

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 action ('draw multiple random tarot cards') and a key constraint (count range), but lacks details on output format, whether draws are with or without replacement, error handling, or other behavioral traits. It adds basic context but is incomplete for full transparency.

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

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

The description is a single, efficient sentence that front-loads the purpose ('Draw multiple random tarot cards') and follows with a necessary constraint. There is zero waste—every word earns its place, 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 (one parameter, no annotations, no output schema), the description is minimally adequate. It covers the basic action and parameter constraint but lacks details on output (e.g., card details, format) and behavioral nuances. Without annotations or output schema, more context would improve completeness for an AI agent.

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

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

Schema description coverage is 100%, with the single parameter 'count' fully documented in the schema as 'Number of cards to draw (1–78)'. The description repeats this range ('Count must be between 1 and 78') without adding further meaning, such as implications of the count or how randomness is applied. Baseline 3 is appropriate as 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 specific action ('draw multiple random tarot cards') and resource ('tarot cards'), distinguishing it from siblings like 'get_card' (likely retrieves specific cards), 'random_card' (might draw a single card), and 'search_cards' (searches rather than draws randomly). The verb 'draw' combined with 'random' precisely defines the operation.

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 specifying the count range (1-78), but does not explicitly state when to use this tool versus alternatives like 'random_card' (which might be for single draws) or 'search_cards'. There's no guidance on prerequisites, exclusions, or comparative contexts, leaving the agent to infer based on tool names alone.

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

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

Description discloses data sources and return format (pipeworx:// URIs). While it implies a read operation and mentions performance constraints regarding federal contracts, it does not explicitly state non-destructive behavior or rate limits. With no annotations, the description carries the burden and mostly succeeds.

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

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

Three sentences deliver all necessary information without redundancy. The most important purpose and data sources are front-loaded, followed by the alternative hint. Each sentence earns its place.

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

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

Given 2 simple parameters, no output schema, and no nested objects, the description fully covers what data to expect, the return format, and the tool's role in replacing multiple calls. It is complete 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?

Schema already covers type and value with 100% coverage. Description adds value by explaining that names are not supported and directing users to resolve_entity first. This extra context beyond the schema justifies a score above baseline.

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

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

Description clearly states it returns a full profile of an entity across multiple data sources, specifically listing SEC filings, XBRL data, patents, news, and LEI. It distinguishes itself from sequential calls and mentions an alternative for federal contracts, making its 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?

Explicitly tells when to use (for comprehensive entity profile), when not to use (for federal contracts, use usa_recipient_profile), and provides a prerequisite (use resolve_entity for name lookup). This gives clear guidance for tool selection.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the tool deletes a memory, implying a destructive mutation, but doesn't address critical aspects like permissions needed, whether deletion is permanent or reversible, error handling for non-existent keys, or rate limits. This leaves significant gaps for a mutation 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 a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it highly concise and well-structured for quick comprehension.

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 mutation tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., permanence, permissions), error scenarios, or return values, which are essential for safe and effective use. The high schema coverage doesn't 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?

Schema description coverage is 100%, with the parameter 'key' documented as 'Memory key to delete'. The description adds no additional meaning beyond this, such as key format or examples. Since the schema handles parameter documentation adequately, the 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 'Delete a stored memory by key' clearly states the action (delete) and resource (stored memory) with specific scope (by key). It distinguishes from sibling tools like 'recall' (likely retrieval) and 'remember' (likely storage), providing unambiguous purpose.

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 prerequisites (e.g., existing memory to delete), exclusions, or relationships to siblings like 'recall' or 'remember', leaving usage context implied but unspecified.

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 clearly describes a read-only operation ('Get') without implying mutation, but does not disclose behavioral traits like error handling (e.g., what happens if the identifier is invalid), authentication needs, or rate limits. It adequately covers the basic operation but lacks deeper 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, well-structured sentence that efficiently conveys the tool's purpose, parameter usage, and examples without any redundant information. It is front-loaded with the core action and resource, making it highly concise and effective.

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

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

Given the tool's low complexity (single parameter, no annotations, no output schema), the description is complete enough for basic usage. However, it lacks details on return values (since no output schema exists) and does not address potential errors or edge cases, which could be helpful for an agent invoking the tool.

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

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

The schema description coverage is 100%, so the input schema already fully documents the single parameter 'name_short'. The description adds value by providing specific examples of identifiers (e.g., 'ar01', 'ar00'), which help clarify the expected format, but does not add significant semantic meaning beyond what the schema provides.

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

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

The description clearly states the specific action ('Get') and resource ('a specific tarot card'), and distinguishes it from siblings by specifying retrieval by short name identifier rather than random drawing or searching. It provides concrete examples of identifiers, 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 implicitly indicates when to use this tool (to retrieve a specific card by its short name) versus alternatives like 'random_card' (for random selection) or 'search_cards' (for broader queries). However, it does not explicitly name these alternatives or provide exclusion criteria, leaving some inference required.

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 the rate limit (5 messages per identifier per day) and provides guidelines on message content (be specific, do not include prompt verbatim). This gives adequate transparency 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 three sentences with no fluff. It is front-loaded with the purpose and quickly moves to guidelines and rate limits. Every sentence serves a clear function.

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

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

Given the simplicity of the tool (sending feedback) and the absence of an output schema, the description covers all necessary aspects: purpose, content guidelines, rate limit, and parameter context. It is complete for the tool's requirements.

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 all parameters. The description adds contextual value beyond the schema by explaining the enum values in detail, reinforcing the intended use, and providing rate limit and content constraints. This justifies a score above the baseline.

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

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

The description clearly states the action (send feedback) and the specific use cases (bug reports, feature requests, missing data, praise). It distinguishes itself from sibling tools which are about queries and memory 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 explicitly lists when to use the tool (bug reports, feature requests, etc.) and provides guidance on content (describe what you tried, avoid end-user prompt). It mentions rate limits. However, it does not explicitly state when not to use it or name alternatives, though this is clear from context.

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

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

No annotations are provided, so the description carries the full burden. It discloses the tool's behavior (draws a random card and returns meanings), but does not mention potential traits like randomness source, rate limits, or error conditions. It adds basic context but lacks depth for a higher score.

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 key action ('Draw a single random tarot card') and adds necessary detail ('with its upright and reversed meanings'). Every word earns its place with zero waste, 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 (0 parameters, no output schema, no annotations), the description is complete enough for basic use. It specifies what the tool does and what information is returned. However, without an output schema, it could benefit from more detail on the return format (e.g., structured data or text), preventing a score of 5.

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?

There are 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description does not add parameter details, which is appropriate, but since there are no parameters, it compensates by fully describing the tool's function, warranting 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 specific action ('Draw a single random tarot card') and the resource ('tarot card'), including what information is provided ('upright and reversed meanings'). It distinguishes from siblings by specifying 'single random' versus other tools like 'draw_cards' (likely multiple), 'get_card' (likely specific), and 'search_cards' (likely query-based).

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 context ('random tarot card') but does not explicitly state when to use this tool versus alternatives like 'draw_cards' or 'get_card'. It provides clear intent for obtaining a random card with meanings, but lacks explicit exclusions or named alternatives, which would be needed for a score of 5.

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

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

No annotations are provided, so the description carries the full burden. It describes the tool's behavior (retrieval/listing of memories) and hints at persistence across sessions, but lacks details on permissions, rate limits, error handling, or return format. It adequately covers basic operation but misses deeper behavioral context.

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

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

The description is two sentences, front-loaded with the core functionality and followed by usage context. Every sentence adds value without redundancy, making it efficient 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 moderate complexity (retrieval/listing with persistence), no annotations, and no output schema, the description does well by covering purpose, usage, and parameter semantics. However, it lacks details on return values or error cases, leaving some gaps for a tool that handles stored data.

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 parameter. The description adds value by explaining the semantic effect of omitting the key ('omit to list all keys'), which clarifies usage beyond the schema's technical specification. With 1 parameter and high coverage, this earns above baseline.

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'). It distinguishes from siblings by specifying it retrieves context saved earlier, unlike tools like 'draw_cards' or 'search_cards' which imply different 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 guidance on when to use the tool ('retrieve context you saved earlier in the session or in previous sessions') and when not to use it (by omission, suggesting it's not for creating or modifying memories). It implicitly distinguishes from alternatives like 'remember' (for storing) and 'forget' (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 provided, so the description carries full burden. It discloses parallel fan-out to three sources, accepted date formats (ISO and relative), and return structure (structured changes, total_changes, pipeworx:// URIs). This is comprehensive for a read-only tool with no side effects.

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

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

Four sentences, each essential. Front-loaded with purpose, then details in logical order. No wasted words; the description is compact yet informative.

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 elements (structured changes, count, URIs). It covers all input parameters, date parsing, entity type limitation, and parallelism. For a tool of this complexity, the description is very 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%, but the description adds significant value: explains type enum (only company), gives date examples ('2026-04-01', '7d') with usage hint for typical monitoring ('30d' or '1m'), and clarifies that value can be ticker or CIK. It also describes the output format beyond schema.

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

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

The description clearly states it reports recent changes for an entity since a time point, listing specific sources (SEC EDGAR, GDELT, USPTO). The verb 'brief me on what happened' strongly indicates purpose, and it is distinct from sibling tools like 'entity_profile' or 'compare_entities'.

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

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

Explicitly states 'Use for brief me on what happened with X or change-monitoring workflows'. While it does not list exclusions or alternatives, the context is clear and sufficient for an agent to decide when to invoke.

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 adds context beyond basic functionality: it explains persistence differences ('Authenticated users get persistent memory; anonymous sessions last 24 hours'), which is crucial for understanding data retention. It does not cover aspects like error handling or rate limits, but the added context is valuable.

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 action, followed by usage examples and behavioral details. Every sentence adds value 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 (2 required parameters, no output schema, no annotations), the description is mostly complete. It covers purpose, usage, and key behavioral traits (persistence rules). However, it lacks details on return values or error cases, which could be helpful for a storage tool, though not strictly required without an output schema.

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 both parameters ('key' and 'value') with examples. The description does not add any parameter-specific details beyond what the schema provides, such as formatting constraints or usage tips. Baseline 3 is appropriate as the schema handles 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 specific action ('Store a key-value pair') and resource ('in your session memory'), distinguishing it from sibling tools like 'recall' (likely for retrieval) and 'forget' (likely for deletion). It provides concrete examples of what can be stored ('intermediate findings, user preferences, or context across tool calls'), making the purpose explicit 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 offers clear context on when to use this tool ('to save intermediate findings, user preferences, or context across tool calls'), which helps guide its application. However, it does not explicitly state when not to use it or name alternatives (e.g., compared to 'recall' or 'forget'), missing full sibling differentiation.

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

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

No annotations are provided, so the description bears full responsibility. It mentions that the call replaces 2-3 lookup calls (saving effort), returns ticker, CIK, name, and URIs. It is clearly a read-only operation though not explicitly stated. It does not cover authentication or rate limits, but for a look-up tool, the behavior is well-described.

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

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

The description is three sentences, front-loaded with the primary purpose. Every sentence provides new information: purpose, version/type details with examples, return value, and efficiency gain. No wasted words. Structure is optimal for quick agent 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 tool's simplicity (2 parameters, no nested objects, no output schema), the description sufficiently covers what the tool does, what it returns, and how it integrates (replacing multiple calls). It does not mention error handling or entity-not-found scenarios, but for a typical lookup tool, this is acceptable. Sibling tools are unrelated, so no cross-comparison 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?

Input schema coverage is 100% with descriptions for both parameters. The description adds value by providing concrete examples (AAPL, 0000320193, Apple) and interpreting the 'type' parameter as v1-supported. It also clarifies what the function returns, which is not in the schema. This enriches the schema without redundancy.

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 (resolve), resource (entity to canonical IDs), and scope (across Pipeworx data sources). It distinguishes itself from alternatives by noting it replaces 2-3 lookup calls, and sibling tools are unrelated (cards, memory, search). The verb 'Resolve' with the specific outcome 'canonical IDs' and examples (ticker, CIK, name) leave no 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 explicitly says when to use: when you need canonical IDs for an entity, and it replaces multiple calls. It implies usage by stating 'v1: type="company"', suggesting current scope. However, it lacks explicit when-not-to-use instructions or comparisons with sibling tools, though siblings are unrelated. Still, context is clear enough.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It only states the search functionality without mentioning important behavioral aspects like whether this is a read-only operation, what permissions might be required, how results are returned (format, pagination), or any rate limits. For a search tool with zero annotation coverage, this is insufficient.

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 with a single sentence that contains zero wasted words. It's front-loaded with the core purpose and efficiently communicates the essential information 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?

Given the lack of annotations and output schema, the description is incomplete for a search tool. It doesn't explain what the tool returns (card objects? just names? full descriptions?), how results are structured, or any behavioral constraints. The description alone doesn't provide enough context for an agent to fully understand how to work with this tool.

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

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

The description adds minimal value beyond the input schema, which already has 100% coverage with a clear parameter description. The description mentions 'keyword' which aligns with the schema's 'query' parameter, but doesn't provide additional semantic context about how the search works, what constitutes a match, or search syntax beyond what's 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 specific action ('search'), target resource ('tarot cards'), and scope ('by keyword — matches against card names and descriptions'). It distinguishes this tool from its siblings (draw_cards, get_card, random_card) by specifying it's for keyword-based searching rather than random selection or direct retrieval.

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

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

The description provides clear context for when to use this tool ('Search tarot cards by keyword'), which implicitly distinguishes it from siblings that don't involve keyword searching. However, it doesn't explicitly state when NOT to use it or name specific alternatives, keeping it from a perfect score.

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 burden. It describes return values (verdict, structured form, value, citation, delta) and supported claim types. However, it does not disclose limitations (e.g., only US public companies, date ranges) or behavior on unsupported claims.

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 focused sentences, each adding essential information: purpose, scope, returns, and efficiency gains. No wasted words, and the most important info is front-loaded.

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

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

For a single-parameter tool with no output schema, the description covers purpose, supported claims, return format, and efficiency. It omits error handling or edge cases but is largely complete for its 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%, providing baseline 3. The description adds value by giving example claims and explaining the types of claims supported (revenue, net income, cash), enhancing understanding beyond the schema's simple claim 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: fact-checking natural-language claims against authoritative sources, specifically company-financial claims. It distinguishes itself from sibling tools like ask_pipeworx or compare_entities by specifying its niche 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 explicitly states that v1 supports company-financial claims (revenue/net income/cash for US public companies), indicating scope. It also mentions replacing 4-6 sequential agent calls, guiding when to use this tool. However, it does not explicitly state when not to use it or mention alternatives.

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