Rxnorm

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

No annotations provided, so description must cover behavior. It explains it picks the right tool and fills arguments, which is good transparency. However, it doesn't mention limits like data source coverage or latency.

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?

Very concise at 4 sentences, front-loaded with purpose. Every sentence adds value, no fluff.

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

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

Given the tool's simplicity (1 param, no output schema), the description is nearly complete. It could mention that results are returned as text, but not essential. The examples provide strong context.

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

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

Schema coverage is 100% and the single parameter 'question' is described as natural language. The description adds value by explaining how the parameter is used (to select tools and fill arguments) with examples.

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

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

The description clearly states it answers plain English questions using the best available data source, with specific examples. It distinguishes itself from sibling tools by acting as a universal question-answering interface.

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, and provides example questions. It implies this is the go-to for natural language queries, while siblings like rxnorm_search are more specific.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds transparency by detailing the fan-out to data packs based on bet classification and the return of an evidence packet and model comparison. It does not mention any undocumented side effects or limitations.

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

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

A single, information-dense paragraph that front-loads the purpose. Every sentence contributes necessary detail, though it could be slightly more structured or shortened without losing clarity.

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 (input flexibility, depth options, classification, fan-out logic) and lack of output schema, the description adequately explains what the output contains (evidence packet plus market-vs-model comparison) and the reasoning behind fan-out logic, leaving no major gaps.

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

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

Schema coverage is 100% with clear descriptions for both parameters. The description adds value by explaining the market parameter's accepted formats (slug, URL, question text) and the depth parameter's semantics ('quick = 2-3 sources, thorough = full fan-out, default thorough'), enhancing the enum values.

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 researches a Polymarket bet by pulling Pipeworx data, accepts multiple input formats (slug, URL, question text), and outlines the processing steps. This clearly distinguishes it from sibling tools like ask_pipeworx.

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

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

Provides explicit use cases ('should I bet on X?', 'what does the data say?', 'is there edge?') and states it's the core demo product. Does not explicitly exclude alternatives but implies ask_pipeworx for general queries.

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

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

No annotations are provided, so the description carries full burden. It discloses data sources (SEC EDGAR, FDA/clinical trials) and output format (paired data + URIs). It does not mention authentication needs, rate limits, error handling for missing entities, or side effects, leaving some behavioral aspects unclear.

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, zero wasted words. Essential information is front-loaded: purpose, entity types with examples, output format, and efficiency gain. Every sentence contributes meaning.

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 only two parameters, no output schema, and no nested objects, the description covers the core functionality well: types, data fields, and output. It could mention potential number of results or error scenarios, but overall it is sufficient for an agent.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value beyond the schema: it explains how the 'values' array should be formatted (e.g., tickers for company, drug names) and details what data is returned for each type, enriching the parameter understanding.

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

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

The description clearly states it compares 2-5 entities side by side, specifies two types ('company' and 'drug') with distinct data fields (e.g., revenue, adverse events), and mentions the output includes paired data and URIs. It distinguishes itself from sibling tools by highlighting it replaces many sequential 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 implies when to use (comparison tasks) and provides context by stating it replaces 8-15 sequential calls. However, it does not explicitly state when not to use or list alternatives, though no obvious siblings overlap.

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

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

No annotations provided, so description carries full burden. It explains it returns 'most relevant tools with names and descriptions' and hints at search behavior. It doesn't describe auth needs or rate limits, but the tool is a simple search, so transparency is good. Could mention whether it supports pagination or fuzzy matching.

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

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

Three sentences, each earned: first says what it does, second specifies output, third gives when-to-use advice. No fluff, front-loaded with action.

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 could mention the structure of returned results (e.g., relevance scores or tool details). But it's a discovery tool, and the purpose is clear. The description is sufficient for the simple task of tool discovery.

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 context by saying 'Natural language description' for query and provides example queries, which is helpful. For limit, it repeats defaults but adds 'max 50' which may not be in schema (schema says 'default 20, max 50' – actually schema includes that, so no extra value). Still, the examples add value.

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

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

The description clearly states it searches a tool catalog by description, returns relevant tools with names and descriptions, and positions it as a discovery tool. The verb 'search' and resource 'tool catalog' are specific and it distinguishes from siblings like ask_pipeworx (likely conversational) and rxnorm_* (domain-specific).

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 says 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task.' This provides clear when-to-use guidance and implies it's for tool selection, not for answering queries directly, differentiating it from ask_pipeworx.

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

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

With no annotations, the description carries full burden. It discloses behavioral traits by stating it returns pipeworx:// citation URIs and bundles multiple sources. However, it does not mention idempotency, authentication, rate limits, or if it's a read-only operation. Adequate but lacks depth.

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

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

The description is concise, with 3-4 sentences front-loading the main purpose. Every sentence adds value: function, specifics, alternatives. No wasted words.

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

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

Given the tool's complexity (combines multiple sources), the description provides a good overview of contained data and return format (citation URIs). However, without an output schema, an agent might need more detail on the exact output structure. Still mostly sufficient for an experienced 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 coverage is 100% and already describes parameters well (type enum, value ticker/CIK). The description adds value by reinforcing the type='company' context, listing data sources, and advising to use resolve_entity for names. This goes 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 specifies that the tool returns a full entity profile across multiple Pipeworx packs, listing exact data sources (SEC filings, XBRL, patents, news, LEI) and distinguishing it from a similar tool (usa_recipient_profile). This is specific, action-oriented, and differentiates 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 explicitly states when to use this tool (replaces 10–15 sequential calls) and when not to (for federal contracts, call usa_recipient_profile directly). However, it does not cover other sibling tools like compare_entities or resolve_entity, so guidance is partial.

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; description only states 'Delete a stored memory by key.' Does not disclose irreversibility, authorization needs, or side effects beyond deletion.

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, direct, no wasted words. Front-loaded with verb 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 has a single required parameter and no output schema, the description is minimal but could still benefit from clarifying that deletion is permanent or that it returns a confirmation.

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

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

Schema description coverage is 100% for the single 'key' parameter, so description adds no extra meaning beyond schema. 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 action (Delete), resource (stored memory), and method (by key). Differentiates from sibling tools like recall and remember.

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

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

No guidance on when to use this vs alternatives (e.g., remember for storing, recall for retrieving). No prerequisites or context provided.

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

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

With no annotations, the description must reveal behavioral traits. It discloses rate-limiting ('5 messages per identifier per day') and that feedback goes to the team. It lacks details on authentication, anonymity, or what happens after sending.

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 purpose, then specifics, then rate limit. Every sentence adds value with no wasted words.

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

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

The tool has 3 parameters including a nested object. The description covers usage context, rate limit, and a privacy guideline. It does not describe the return value, but that is acceptable for a feedback tool.

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

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

Schema coverage is 100%, so parameters are documented. The description adds minor value: for 'message', it suggests '1-2 sentences typical, 2000 chars max.' It does not add significant new 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: 'Send feedback to the Pipeworx team.' It enumerates specific use cases (bug reports, feature requests, missing data, praise) and distinguishes this tool from siblings by being the dedicated feedback channel.

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: 'Describe what you tried in terms of Pipeworx tools/data — do not include the end-user's prompt verbatim.' It also mentions the rate limit. However, it does not explicitly state when not to use this tool versus 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds behavioral context about how the tool searches and groups markets, but does not disclose potential limitations like data freshness or rate limits. Given annotation coverage, a 3 is appropriate.

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

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

The description is well-structured with two clear modes, but is slightly verbose with parenthetical examples and extra explanation. It front-loads the core action. Could be trimmed by a sentence without losing meaning, but overall 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?

For a tool with moderate complexity (two modes, multiple steps), the description covers the logic, use cases, and return value ('ranked opportunities with suggested trade direction + reasoning'). Without an output schema, the description adequately explains what the agent can expect.

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

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

Schema coverage is 100% and the schema's parameter descriptions are adequate (event slug/URL, topic seed question). The description reinforces the parameter use by explaining the two modes, but does not add significant new semantics beyond the schema. Baseline 3 is correct.

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

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

The description clearly states the tool's purpose: finding arbitrage opportunities via monotonicity violations. It distinguishes two distinct modes (event and topic) with concrete examples, making the purpose unambiguous and differentiating it from sibling tools like polymarket_edges.

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

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

The description provides clear guidance on when to use each mode: event for a single Polymarket event, topic for cross-event searches. It gives a concrete example of when cross-event is necessary (separate events for different cutoff dates). It does not explicitly state when not to use, but the context is strong enough for an AI 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?

Annotations already mark it as read-only and non-destructive. The description adds valuable behavioral context: it groups by asset, fetches price history once, computes model probabilities, ranks by |edge|, and suggests trade direction. No contradictions with annotations.

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

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

The description is slightly long but front-loaded with the core action in the first sentence. Each subsequent sentence adds detail about the model and workflow. Could be slightly more concise, but it's 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?

Despite no output schema, the description states it returns top N with edge magnitude and suggested trade direction. For a complex model-driven tool, it provides sufficient context for an AI agent to understand what to expect. Lacks precise field names but is functional.

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 baseline is 3. The description minimally adds context by restating defaults and explaining that ranking is by edge magnitude, which relates to min_edge_pp. No additional semantic depth 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 the tool's purpose: scanning highest-volume Polymarket markets and returning those with largest disagreement between Pipeworx data and market price. It specifies the model (lognormal from FRED + coinpaprika) and the target use case ('what should I bet on today'), distinguishing it from siblings like polymarket_arbitrage.

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

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

The description provides a clear use case ('what should I bet on today') and explains that it avoids manual browsing. However, it does not explicitly state when not to use it or compare to specific alternatives beyond the sibling list.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool can retrieve by key or list all, which is sufficient. However, it doesn't mention if the operation is read-only or if it has side effects (e.g., no deletion). Given the lack of annotations, a score of 3 is appropriate.

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, clear and front-loaded. The first sentence explains what it does, the second provides usage context. It is concise without missing necessary 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 (one optional parameter, no output schema), the description is fairly complete. It explains retrieval and listing behavior. However, it doesn't mention whether the tool is persistent across sessions or if it returns a list of keys vs. full memory content.

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% (one parameter 'key' fully described). The description adds context that omitting the key lists all memories, which clarifies behavior beyond the schema's basic description. Baseline 3 is correct.

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

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

The description clearly states the tool retrieves a memory by key or lists all memories, with a specific verb ('Retrieve') and resource ('stored memory'). It distinguishes itself from sibling tools like 'remember' and 'forget' by being the retrieval counterpart.

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 (omit key for listing). It doesn't explicitly mention alternatives, but given the sibling tools, the usage 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?

With no annotations, the description fully discloses behavior: parallel fan-out to SEC, GDELT, USPTO; accepted input formats for 'since' (ISO and relative); output structure including structured changes, total_changes count, and pipeworx:// URIs. Also notes the current limitation of supporting only 'company'.

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

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

Three sentences, each serving a purpose: purpose, behavior, input/output details, and use case. No redundant words; efficiently packs essential info.

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

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

Given no annotations and no output schema, the description covers all necessary behavioral aspects, input constraints, output format, and intended use. It is self-contained and sufficient for an agent to select and 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%, but the description adds value beyond schema: typical relative values for 'since' (e.g., '30d'), clarification that 'value' can be ticker or CIK, and confirmation that 'type' is limited to 'company'. This aids correct usage.

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 provides recent changes for an entity since a given time, with specifics about entity type 'company' and fan-out to multiple sources (SEC, GDELT, USPTO). This distinguishes it from sibling tools like 'entity_profile' which likely provides static 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?

The description explicitly states use cases: 'brief me on what happened with X' or change-monitoring workflows. It does not explicitly state when not to use, but the implied context differentiates from static or comparison tools 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 discloses key behavioral details: persistence depends on authentication (authenticated users get persistent memory, anonymous sessions last 24 hours). However, it does not mention any side effects, limits (e.g., memory size), or overwrite behavior for existing keys.

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: purpose, usage, and behavioral detail. No wasted words, and the most critical information 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 simplicity (2 simple params, no output schema) and lack of annotations, the description is mostly complete. It covers purpose, usage context, and persistence behavior. Minor gaps: no mention of overwrite behavior or memory size limits, but these are not critical for a simple key-value store.

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

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

Schema coverage is 100% and the schema descriptions are already detailed (e.g., example keys like 'subject_property', 'target_ticker'). The description adds a general purpose but does not add meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool stores a key-value pair in session memory, with specific use cases like saving intermediate findings, user preferences, or context across tool calls. The verb 'store' and resource 'session memory' are precise, and it distinguishes from siblings like 'forget' and 'recall'.

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 (to save context across calls) and differentiates use cases (authenticated vs anonymous sessions). However, it does not explicitly state when not to use it or mention alternative tools like 'recall' for retrieval, though the distinction is implied.

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

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

With no annotations, the description adequately discloses behavior: it is a read-only lookup that returns structured data including URIs. It notes version limitations (v1 only supports 'company'). No contradictions or hidden side effects mentioned.

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 covering purpose, input, output, and efficiency gain. No wasted words; critical information 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 simple lookup with two parameters and no output schema, the description fully covers what the tool does, what it accepts, and what it returns. No gaps identified.

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 practical examples (AAPL, 0000320193, Apple) for the value parameter and reiterates the type restriction. This provides concrete guidance beyond the schema text.

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 resolves entities to canonical IDs, specifies it's for companies in v1, and lists accepted inputs and outputs. It clearly distinguishes from sibling tools which are mostly unrelated (e.g., ask_pipeworx, rxnorm 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 mentions it replaces 2–3 lookup calls, implying when to use for efficiency. While not listing exclusions, the context is sufficient given no sibling competitors for this specific resolution 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, the description should fully disclose behavior. It doesn't mention that this is a read-only operation, whether the suppress flag indicates hidden data, or if the tool handles invalid RxCUIs gracefully. The description adds minimal behavioral context beyond what the input schema already 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?

Two concise sentences; front-loaded with purpose and lists return fields efficiently. No fluff, but the second sentence could be integrated into the first without loss.

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 (single required parameter, no output schema), the description is mostly adequate but lacks usage context (e.g., prerequisite of knowing RxCUI) and does not mention any limitations or error handling. It meets minimal completeness but could better support the 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 coverage is 100% and the description adds value by listing returned fields (name, synonym, etc.) but does not explain the rxcui parameter's format or provide examples beyond the schema's own example '7052'. Baseline 3 is appropriate as schema already describes the parameter.

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

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

The description clearly states the tool gets properties for a drug by its RxCUI, listing specific return fields (name, synonym, term type, language, suppress flag). It distinguishes itself from siblings like rxnorm_search (search) and rxnorm_related (related concepts) by focusing on a single concept ID lookup.

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

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

No guidance on when to use this tool vs alternatives. It doesn't mention that the user must first know the RxCUI (e.g., from rxnorm_search), nor does it contrast with rxnorm_interactions or rxnorm_ndc which serve different purposes.

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 clearly states the tool may return errors due to retirement, which is critical for the agent. It also mentions the optional source filter. However, it doesn't describe what the tool returns on success or failure beyond potential errors, which is a minor gap.

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: the first clearly states the purpose, and the second provides critical usage guidance. Every sentence is necessary and front-loaded. No wasted words.

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

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

Given the simple input schema (two string parameters, no output schema), the description adequately covers the tool's purpose, the retirement warning, and the source filter. It doesn't explain return values or error handling beyond potential errors, but for a tool with no output schema and a clear warning, this is sufficient.

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

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

Schema description coverage is 100% (both parameters have descriptions), so the baseline is 3. The description does not add any additional meaning beyond what the schema already provides (e.g., it doesn't clarify the format of the RxCUI or the effect of the source filter).

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

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

The description clearly states the tool checks drug-drug interactions for a given RxCUI, distinguishing it from sibling tools like rxnorm_get_properties or rxnorm_search which have different purposes. The verb 'Check' and resource 'drug-drug interactions' are specific, though the retired status note may slightly distract from the core 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 explicitly warns that the NIH retired this API in January 2024, advising against use and directing to alternative tools (PubMed or drug label lookups). This provides clear when-not-to-use guidance and suggests appropriate alternatives, fully satisfying the dimension.

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

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

Annotations are empty, so description carries full burden. It discloses that the tool gets NDC identifiers, but no behavioral traits like rate limits, authentication needs, or data freshness are mentioned. Adequate for a simple lookup 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?

Two sentences, front-loaded with action and resource, no wasted words. Could be slightly more structured but 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 low complexity (1 param, no output schema), description is mostly adequate. However, lacks details on return format (e.g., list or object) and potential errors. Complete enough for basic use.

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% (one parameter with description). The description adds meaning by explaining what the output is (NDC codes) but doesn't elaborate on the input parameter beyond the schema. 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 verb (Get), resource (NDC identifiers), and target (drug by RxCUI), distinguishing it from sibling tools like rxnorm_get_properties or rxnorm_search. It also explains what NDC codes are, adding context.

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?

Implied usage: when you need NDC codes for a known RxCUI. No explicit when-not-to-use or alternatives mentioned. Sibling tools exist for properties, interactions, etc., but no comparison provided.

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

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

No annotations are provided, so the description carries the burden. It explains the tool retrieves related concepts, which implies a read-only operation, but doesn't specify any restrictions or side effects. Adequate but minimal.

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

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

Two concise sentences, front-loaded with the core purpose, then a usage hint. No unnecessary words.

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

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

The tool has only 2 parameters with full schema coverage and no output schema. The description covers the purpose and a key use case, but could be more complete by mentioning the return type or typical response structure.

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 details about the parameters beyond what the schema already provides (e.g., rxcui required, tty optional filter).

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

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

The description clearly states the tool gets 'related concepts for a drug' and lists examples (brand names, generics, ingredients, dose forms), distinguishing it from siblings like rxnorm_get_properties or rxnorm_search.

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

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

It says 'useful for mapping between brand and generic names,' implying a use case, but doesn't explicitly state when to use this vs. siblings like rxnorm_search or rxnorm_get_properties.

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

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

With no annotations, the description carries full burden. It accurately describes the search behavior and return types. Does not mention pagination or limits, but is clear for a search 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?

Two sentences, concise and front-loaded with purpose. Every word adds value.

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

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

Given the single parameter, no output schema, and simple search function, the description is complete enough for an agent to use effectively.

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

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

Schema coverage is 100% and the schema already describes the parameter. The description adds context (e.g., examples) but does not significantly expand 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?

Clearly states the verb 'search', resource 'drugs by name (brand or generic)', and lists what is returned (concept groups with RxCUI, names, synonyms, term types). It distinguishes itself from siblings like rxnorm_get_properties and rxnorm_interactions.

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?

Implies usage for searching drugs by name, but no explicit guidance on when to use versus siblings. No mention of when not to use or prerequisites.

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 responsibility for behavioral disclosure. It transparently lists the data sources (SEC EDGAR + XBRL), the possible verdict types, and the output structure. It does not disclose rate limits, authorization requirements, or potential side effects, but the tool is read-only and low-risk, making this acceptable.

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

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

The description is extremely concise: two sentences. The first sentence states the core purpose and scope. The second sentence lists the return values and a key benefit. 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 simple input schema (one required string parameter) and absence of output schema, the description adequately covers what the tool does, the input format, and the output structure. It could mention limitations more explicitly (e.g., only US public companies, only three financial metrics), but the scope is clearly stated as 'company-financial claims'. Overall, sufficient for an agent to decide.

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% (the only parameter 'claim' has a description with examples). The tool description adds context by specifying the domain of acceptable claims (company-financial) and explaining that the tool processes the claim end-to-end. This extra context justifies a score above the baseline of 3.

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

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

The description clearly states the tool's purpose: fact-checking natural-language claims against authoritative sources. It specifies the domain (company-financial claims for US public companies) and lists the return types (verdict, structured form, actual value, citation, delta). This distinguishes it from sibling tools, none of which perform claim validation.

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 defines the scope (v1 supports company-financial claims for US public companies) and notes it replaces 4–6 sequential agent calls, implying it is the preferred method within its domain. However, it does not explicitly state when not to use it (e.g., claims outside finance or non-US companies).

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