Jira

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

The description explains that Pipeworx picks the right tool and fills arguments, revealing its internal orchestration behavior. With no annotations provided, the description carries full burden and does a good job disclosing that the tool may invoke other tools and return results automatically.

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 that front-load the core purpose, then explain the mechanism, and provide examples. Every sentence adds value 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 simplicity (one required parameter, no output schema), the description is complete enough. It covers what the tool does, how it works, and provides examples. The only minor gap is that it doesn't mention potential limitations (e.g., scope of questions), but it's not necessary for this simple tool.

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

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

The schema already provides a clear description for the single parameter 'question' (100% coverage). The description adds value by providing examples of valid questions and clarifying that it accepts natural language, but the baseline of 3 is appropriate since the schema already explains the parameter sufficiently.

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

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

The description clearly states the tool's purpose: it answers questions in plain English by selecting the best data source. The verb 'ask' and resource 'answer' are specific, and the examples ('What is the US trade deficit with China?') distinguish it from sibling tools that are more specialized (e.g., Jira 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?

The description explicitly says 'No need to browse tools or learn schemas — just describe what you need,' which indicates when to use this tool (as a general-purpose question-answer tool) and implies not to use it when you need to use a specific tool directly. However, it does not explicitly state when not to use it or mention alternatives, but the context of sibling tools provides implicit guidance.

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

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

Annotations already indicate readOnlyHint=true and openWorldHint=true. The description adds valuable context: it explains that the tool resolves the market, classifies bets dynamically, fans out to appropriate data packs, and returns a market-vs-model 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 a single paragraph of 4-5 sentences, efficiently covering purpose, inputs, process, and outputs. It front-loads key information but includes some promotional language ('core demo product') that could be trimmed for conciseness.

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 explains the return value: an evidence packet and market-vs-model comparison. It covers the dynamic fan-out logic and classification. However, it omits details on the format of the evidence packet or comparison, which 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?

Schema coverage is 100% with descriptions for both parameters. The description adds meaning by clarifying that 'market' accepts slug, URL, or question text, and that 'depth' defaults to thorough. This extra context enhances understanding beyond the schema.

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

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

The description clearly states the tool's purpose: research a Polymarket bet by resolving the market, classifying it, and fetching relevant data packs. It specifies accepted inputs (slug, URL, question text) and outputs (evidence packet plus comparison). It distinguishes itself from siblings by describing its unique value as an integrated research tool.

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

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

The description provides explicit use cases: 'should I bet on X?', 'what does the data say?', 'is there edge?'. It also implies this tool should be preferred over manual pack discovery, but does not explicitly state when to use alternatives or exclude scenarios, leaving slight ambiguity.

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

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

No annotations exist, so description fully discloses behavior: for companies, it pulls financial data from SEC EDGAR/XBRL; for drugs, adverse events, approvals, and trials. Mentions return format and citation URIs, and notes efficiency gains by replacing multiple calls.

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, no wasted words. Front-loaded with purpose and followed by concrete examples. 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?

No output schema, but description explains what is returned (paired data and URIs) and covers key behavioral aspects. Slight gap: does not mention error cases or edge conditions like invalid tickers.

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

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

Schema has 100% coverage, but description adds meaningful context: explains enum options ('company' vs 'drug') and how to format values (tickers vs drug names) with examples. Enhances usability beyond schema alone.

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

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

The description clearly states the tool compares 2-5 entities (companies or drugs) side by side, with specific verbs and resources. It distinguishes from siblings like entity_profile by focusing on comparisons rather than single-entity profiles.

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

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

Provides explicit use cases such as 'compare X and Y' or 'X vs Y' and explains the data pulled for each type. Lacks explicit when-not-to-use statements but context is clear.

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

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

The description explains that the tool 'returns the most relevant tools with names and descriptions,' which sets expectations about the response format. Since no annotations are provided, the description carries the full burden of behavioral disclosure. It lacks details on ordering, latency, or whether the query is semantic or keyword-based, but the overall behavior is sufficiently clear for an agent.

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

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

The description is three sentences, each adding distinct value: the first states the core purpose, the second explains the output, and the third gives a clear usage directive. No extraneous information. Front-loaded with the action and resource.

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 (simple search with two parameters, no output schema, no nested objects), the description is complete. It explains the input format, output content, and the strategic context (call first). The return value is described as 'names and descriptions,' which is sufficient for a discovery tool. No output schema is needed because the output is a list of tool definitions.

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

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

Schema description coverage is 100% (both 'query' and 'limit' are documented in the schema). The description adds value by explaining the format of 'query' with examples ('natural language description of what you want to do (e.g., "analyze housing market trends")') and providing context for 'limit' (default and max values). This goes beyond the schema's bare descriptions.

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

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

The description clearly states the tool's purpose: 'Search the Pipeworx tool catalog by describing what you need.' It specifies the action ('search'), the resource ('Pipeworx tool catalog'), and the return value ('most relevant tools with names and descriptions'). It also differentiates from siblings by implying a discovery/filtering role, which is distinct from the other tools like ask_pipeworx, recall, or jira_* 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?

The description explicitly says 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task.' This provides a clear when-to-use directive and indicates that it's a preliminary step before selecting a specific tool. No exclusions or alternatives are needed as it is a unique discovery tool among siblings.

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

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

No annotations are provided, so the description carries the full burden. It transparently lists the data returned: 'recent SEC filings, latest revenue/net income/cash position fundamentals, USPTO patents ... news ... LEI, and pipeworx:// citation URIs.' It does not mention read-only nature or rate limits, but the return format 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 a single, dense paragraph, but it is front-loaded with the purpose and usage. Every sentence adds value. It could be slightly more scannable with bullet points, but it remains efficient and clear.

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

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

The tool has no output schema, so the description must explain return values. It does so by listing data categories and mentioning citation URIs. It also explains parameter constraints and the need for name resolution. For a tool that replaces 10+ pack tools, this is sufficiently 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?

The input schema already covers both parameters exhaustively (type enum and value string description). The description adds context that names are not supported and advises using 'resolve_entity' first. This adds meaning beyond the schema.

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

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

The description clearly states the tool's purpose: 'Get everything about a company in one call.' It specifies the verb ('get') and resource ('everything about a company'), and it implicitly distinguishes from siblings like 'compare_entities' (which compares) and 'resolve_entity' (which resolves names to identifiers).

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: 'Use when a user asks “tell me about X”, “give me a profile of Acme”, ... or you’d otherwise need to call 10+ pack tools...' It also specifies when not to use it (when only a name is available, use 'resolve_entity' first), giving clear 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 full burden. It states the tool deletes a memory, implying irreversibility, but does not clarify side effects (e.g., whether related data is also affected) or confirm if deletion is permanent.

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 conveys the core action without extraneous words. It is front-loaded and 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?

The tool is simple (one required parameter, no output schema), but the description lacks context about the return value (e.g., success indication), error cases (e.g., key not found), or concurrency implications. Given its simplicity, more completeness is expected.

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 describes the 'key' parameter. The description does not add further meaning beyond what the schema provides, which is acceptable given full 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 'Delete a stored memory by key' uses a specific verb ('Delete') and resource ('stored memory'), making the purpose clear. However, it does not differentiate from sibling tools like 'remember' or 'recall', which could also be related to memory management.

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 like 'remember' or 'recall'. The description does not mention prerequisites, caveats, or scenarios where deletion is appropriate.

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

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

Annotations are empty, so description carries burden. It states the tool returns full issue details, but does not disclose if it requires authentication, rate limits, or any side effects. With no annotations, more detail would be helpful.

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 a single sentence, concise and front-loaded with the main purpose. Could be slightly more structured but 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?

For a simple read operation with 2 parameters and no output schema, the description is adequate. It states the input and what is returned. However, it could mention that the optional 'fields' parameter allows selecting specific fields to reduce response size.

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 both parameters are described in the schema. The description does not add additional meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

Description clearly states the tool gets a single Jira issue by its key, includes an example, and specifies 'Returns full issue details.' This distinguishes it from siblings like jira_search (which searches) and jira_list_projects (which lists projects).

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 implies when to use (when you have an issue key and want full details), but does not explicitly say when not to use or mention alternatives like jira_search for listing issues.

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

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

No annotations provided, so description must disclose behavior. It states it retrieves details, which is a read operation, but does not mention any side effects or permission requirements. Adequate but minimal.

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

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

Single sentence, concise and front-loaded with the purpose. No extraneous 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?

With no output schema, description does not explain what fields are returned (e.g., name, description, lead). For a simple project get, this might be acceptable, but more detail could help an agent judge if the tool meets its needs.

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

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

Schema coverage is 100% with a single parameter 'project_key' described as 'Project key (e.g., "PROJ") or numeric project ID'. Description does not add further meaning beyond the schema, so baseline 3 is appropriate.

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

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

Description uses clear verb 'get' and specifies resource 'specific Jira project by key or ID'. Distinguishes from sibling 'jira_list_projects' which retrieves multiple projects. Could be more precise about output (e.g., fields returned).

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 implies use when a specific project's details are needed, but does not explicitly contrast with jira_search or jira_get_issue. No guidance on when not to use or alternatives.

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

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

The description discloses the scope ('accessible to the authenticated user') and indicates it's a list operation. With no annotations provided, the description carries the burden of behavioral transparency and does so adequately, though it doesn't mention pagination or rate limits.

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 sentence that is concise and front-loaded with the key action and resource. Every word 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 tool's simplicity (no parameters, no output schema), the description is complete enough. It states what the tool does and its scope. The absence of return value description is acceptable since there is 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?

Schema coverage is 100% and there are zero parameters, so the description needs to add no additional parameter info. A baseline of 4 is appropriate since the schema fully covers the parameter semantics.

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

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

The description uses a specific verb ('List') and a clear resource ('all Jira projects') and adds the scope 'accessible to the authenticated user', which clearly distinguishes it from sibling tools like jira_get_project (single project) or jira_search (issues).

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

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

The description implies when to use this tool: to list all projects. It doesn't explicitly state when not to use it or mention alternatives, but the context of sibling tools (e.g., jira_get_project for a single project) provides implicit 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 carries the burden. It states the tool searches and returns results, but does not mention if it is read-only, whether it can be used with JQL injections, or any side effects. The behavior is generic.

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 sentence, concise and front-loaded with the purpose. Every word adds value 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 no output schema, the description does not specify the exact fields returned or the structure of results. For a search tool, this might be acceptable, but it lacks details on error handling or pagination.

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 each parameter is described. The description does not add significant meaning beyond the schema; it repeats 'JQL' but does not elaborate on the query language beyond the example 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 searches Jira issues using JQL and returns key fields. It distinguishes itself from sibling tools like jira_get_issue (single issue) and jira_list_projects (list projects).

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 searching issues via JQL but does not explicitly contrast with other tools or provide when-not-to-use guidance. No alternatives or exclusions are mentioned.

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?

Without annotations, the description carries the full burden. It discloses rate limits (5 per identifier per day), that the team reads digests daily, and that feedback affects the roadmap. It does not detail the response format, but for a feedback tool this is acceptable.

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

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

The description is a single, dense paragraph, but every sentence adds value. It is front-loaded with the purpose and usage context. Could be slightly more structured (e.g., bullet points), but it remains concise and 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?

Given no output schema, the description covers usage constraints and content guidelines well. It omits what the tool returns, but for a feedback submission tool, the return is likely minimal. Overall, it provides sufficient context for correct invocation.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by advising to describe issues in terms of Pipeworx tools/packs, which improves feedback quality. This extra guidance raises the score.

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: submitting feedback to the Pipeworx team about bugs, features, data gaps, or praise. It is distinct from sibling tools, all of which serve different functions.

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

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

The description explicitly tells when to use the tool for different feedback types and provides clear guidance on what to avoid (e.g., not pasting the end-user prompt). It also mentions rate limits and that the tool is free, which helps the agent decide when to invoke it.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true. The description adds behavioral context about the two modes and that it returns ranked opportunities with reasoning. It doesn't cover potential external dependencies or limitations, but overall it complements annotations 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?

The description is concise and well-structured: first sentence states the purpose, then explains the two modes in separate sentences. Every sentence adds value, and the most important information is front-loaded. 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 tool's complexity (two modes, cross-event searching) and the absence of an output schema, the description is remarkably complete. It explains what each mode does, when to use it, and what results to expect (ranked opportunities with direction and reasoning). It adequately covers the main behavioral aspects.

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 3. The description adds meaning by explaining the 'event' parameter as a Polymarket slug or URL, and the 'topic' parameter as a seed question. It also ties each parameter to its respective mode, enhancing understanding beyond the schema.

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

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

The description clearly states the tool finds arbitrage opportunities on Polymarket by checking monotonicity violations. It distinguishes two distinct modes (event and topic) and explains their specific use cases, making the purpose specific and differentiated from siblings.

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

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

The description provides explicit guidance on when to use each mode: event mode for a single event slug, topic mode for cross-event searches. It explains a scenario where single-event mode misses opportunities (May≤June rule), effectively indicating when not to use a mode. This is clear and helpful.

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

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

Annotations declare readOnlyHint and openWorldHint, and the description adds detailed behavioral traits: scans top markets, groups by asset, fetches price history once, computes model probabilities, and ranks by edge. No contradictions exist.

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

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

The description is front-loaded with the core purpose and then provides relevant details. It is slightly verbose but every sentence adds value, and it is 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?

For a complex tool with no output schema, the description adequately explains inputs, process, and output format. It covers the scope of the tool without overexplaining internal model details.

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 clear parameter descriptions. The tool description adds minimal extra meaning beyond stating defaults and usage context. Baseline 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 explicitly states the tool scans high-volume Polymarket markets to find where Pipeworx data disagrees most with market price, using a specific model. It clearly distinguishes itself from siblings like bet_research and compare_entities by focusing on opportunity discovery.

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

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

The description states it's built for the 'what should I bet on today' question, providing clear usage context. It does not explicitly mention when not to use or name alternatives, but the context is sufficient for an agent to decide.

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

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

Since no annotations are provided, the description carries the full burden. It discloses that the tool is read-only (retrieve/list) and specifies that it works across sessions. This is sufficient for a simple memory retrieval 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 sentence of 22 words, front-loaded with the action and resource. No superfluous 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 simplicity (1 optional parameter, no output schema, no nested objects), the description is complete. It covers usage and behavior. Could add a note about the return format, but not essential.

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

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

Schema coverage is 100% with one parameter. The description adds context by explaining that omitting 'key' lists all memories, which is beyond the schema description. This is clear and useful.

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 'Retrieve' and the resource 'stored memory', and distinguishes between retrieving by key and listing all memories. It effectively differentiates from sibling tools like 'remember' and 'forget'.

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

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

The description explains when to use the tool ('retrieve context you saved earlier') and implies when not to use it (when you need to list all memories, omit key). However, it does not explicitly exclude alternatives or mention when not to use it.

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

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

With no annotations provided, the description fully bears the burden of behavioral disclosure. It explains that the tool fans out to multiple external sources (SEC, GDELT, USPTO) in parallel, returns structured changes, a total_changes count, and citation URIs, and details the 'since' parameter format. This is comprehensive 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 reasonably concise, with each sentence contributing value. It front-loads the core purpose and includes examples. Slightly verbose in listing use-case paraphrases, but overall efficient.

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

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

Given the tool has 3 required parameters and no output schema, the description provides adequate context: it explains the return structure (structured changes, count, URIs) and data sources. It could mention error handling or limitations but is largely complete for a monitoring 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%, providing a baseline of 3. The description adds meaningful context beyond the schema: it explains the 'since' parameter accepts ISO dates or relative shorthand with examples, clarifies that 'value' can be a ticker or CIK, and notes that 'type' only supports 'company'. This enhances usability.

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

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

The description clearly states the tool's purpose as answering 'what's new with a company' and provides multiple example queries. It is specific about the resource (company news/changes over time) and distinguishes itself from siblings by its unique function, as no other sibling tools perform similar monitoring.

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 when-to-use examples (e.g., 'what's happening with X?') and context for its broad data sources. However, it does not explicitly state when not to use this tool or offer alternatives, which is acceptable given its specialized nature.

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 key behavioral traits: authenticated users get persistent memory, anonymous sessions last 24 hours. This adds value beyond what schema provides.

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, no waste. It is front-loaded with the core action and then adds usage context and behavioral notes.

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

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

Given the simple key-value nature with 2 required parameters, no output schema, and no nested objects, the description provides sufficient context about memory persistence and session types. It could mention that values are overwritten on same key, but overall it is complete enough.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add additional parameter meaning beyond the schema examples, but it is not necessary given full 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 stores a key-value pair in session memory, using specific verbs 'store' and 'save'. It distinguishes itself from siblings like 'recall' and 'forget' by specifying the action of saving 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 clear context for when to use the tool: to save intermediate findings, user preferences, or context across tool calls. It does not explicitly exclude alternatives, but it does imply usage scenarios that differentiate it from 'forget' and 'recall'.

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 describes the return types (IDs plus pipeworx:// citation URIs) but does not explicitly state that the tool is read-only or has no side effects. It adequately covers what to expect but misses a clear statement of non-destructiveness.

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, consisting of four sentences that front-load the core purpose and usage. Every sentence adds critical information without redundancy or fluff.

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

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

Given no output schema, the description sufficiently explains what the tool returns (identifiers and citation URIs) and provides examples. It covers the main use case and the relationship to other tools, making it complete for an agent to invoke 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%, so the schema already documents both parameters. The description adds value by providing concrete examples (e.g., 'Apple' → AAPL/CIK) that clarify how to use the 'value' parameter and what formats are accepted, enhancing understanding beyond the schema's 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: 'Look up the canonical/official identifier for a company or drug.' It specifies the types of identifiers (CIK, ticker, RxCUI, LEI) and provides concrete examples, distinguishing it from sibling tools by noting it replaces multiple lookup calls.

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

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

The description explicitly advises using this tool 'BEFORE calling other tools that need official identifiers,' giving clear guidance on when to use it. It does not explicitly state when not to use, but the context implies it is unnecessary if identifiers are already known.

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

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

No annotations are provided, so the description bears the full burden. It discloses that this is a v1 tool limited to company-financial claims via SEC EDGAR + XBRL, and describes the return verdict types and output structure (structured form, actual value, citation, percent delta). It does not mention rate limits, authentication requirements, or potential side effects, but the tool is read-only and non-destructive.

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

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

The description is concise and well-structured, front-loading the core purpose, then usage guidance, domain specifics, return details, and efficiency note. Every sentence adds value without redundancy. It is short but packed with essential information.

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

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

Given the tool's complexity (fact-checking with a single parameter), no output schema, and no annotations, the description covers purpose, usage, domain, return values, and efficiency. It could be slightly more explicit about the limitation to US public companies, but overall it provides sufficient context for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents the single 'claim' parameter. The description adds value by explaining that the claim should be in natural language and providing concrete examples ('Apple's FY2024 revenue was $400 billion'), which helps the agent understand the expected format and domain.

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 factual claims against authoritative sources. It specifies the domain (company-financial claims for public US companies) and provides concrete examples. This differentiates it from sibling tools like ask_pipeworx or compare_entities, which are not directly about fact-checking.

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

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

The description gives explicit when-to-use guidance with example query patterns ('Is it true that…?', 'Verify the claim that…'). It clarifies domain restrictions (only company-financial claims) and notes that the tool replaces multiple sequential calls, indicating efficiency. However, it does not explicitly mention when not to use or provide alternative tools for other types of claims.

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