Defillama

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

Annotations already indicate read-only, idempotent, open-world behavior. The description adds valuable behavioral details: it explains the need for a BYO Anthropic API key with direct payment to Anthropic, the default model usage cost (free via Workers AI), and the return structure (per-model and combined view). 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 4 sentences, front-loaded with the core action and result. Every sentence adds useful information without redundancy or fluff. It's structured to quickly convey the tool's purpose, options, and returns.

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

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

Given no output schema, the description adequately covers return structure (per-model and combined view). It explains parameters and their roles. However, it lacks details on what 'confidence' or 'signals' mean, and doesn't address error handling or edge cases (e.g., invalid models list). Still, for a probing tool, it's largely complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds extra meaning: it specifies the default model (Workers AI Llama-3.3-70b), explains the models parameter values ('workers-ai', 'anthropic'), gives an example of the API key format ('sk-ant-...'), and describes the context parameter's role in disambiguation. This goes beyond the schema descriptions.

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

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

The description clearly states the specific action: probe LLMs for brand/product knowledge and return a visibility score per model. It specifies the resource (LLMs), the output format (score, confidence, signals, raw_response), and the use cases (AI-marketing audits, pre-launch checks, competitive monitoring). This distinguishes it from sibling tools like 'scan_competitor_ai_presence' by focusing on scoring.

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

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

The description provides explicit usage context: for AI-marketing audits, pre-launch brand checks, and competitive monitoring. It also gives guidance on model selection (default free model, requiring API key for Anthropic) and clarifies external billing for Anthropic probes. While it doesn't explicitly state when not to use or name alternatives, the context is clear and practical.

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. Clearly states it picks the right tool and fills arguments, implying it is a high-level orchestrator. Does not disclose potential failure modes or latency, but sufficient given simplicity.

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?

Front-loaded with core purpose in first sentence, examples add value. Could trim slightly, but no wasted sentences.

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 (one param, no output schema), description adequately explains tool's role. No need for deeper detail.

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%, and description adds context that the parameter is a natural language request, but adds little beyond schema (which already has 'Your question or request in natural language'). Baseline 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?

Description uses strong verb phrase 'Ask a question' and clarifies it returns an answer from the best available data source, clearly distinguishing it from sibling tools which are specific data tools.

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

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

Explicitly states to use when you have a natural language question, and that it handles tool selection automatically. Provides examples, but no explicit when-not-to-use or alternatives 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?

Annotations indicate readOnlyHint=true, destructiveHint=false, and openWorldHint=true. Description adds substantial behavioral detail: it resolves the market, classifies the bet type, fans out to appropriate packs, and returns an evidence packet with a market-vs-model comparison. This goes well beyond the annotations and fully discloses the internal logic.

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 compact (3-4 sentences) and front-loaded with the primary action. Each sentence serves a purpose: stating what it does, explaining input flexibility, detailing internal process and output, and giving use cases. No redundancy or filler.

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

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

Despite no output schema, the description fully explains what the tool returns: an evidence packet and a market-vs-model comparison. It covers input variations, internal classification, and pack fan-out logic. The complexity is high (multiple data sources, classification), but the description leaves no critical gaps for an agent to use it correctly.

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

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

Input schema has 100% description coverage for both parameters ('market' and 'depth'). Description adds practical meaning: for 'market' it explains acceptable formats (slug, URL, or question text), and for 'depth' it clarifies 'quick' vs 'thorough' with source counts. While the schema already describes the basics, the description enhances usability with concrete examples and detailed behavior.

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's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It identifies the specific verb (research), resource (Polymarket bet), and mechanism (pulling Pipeworx data). This distinguishes it from sibling tools like 'ask_pipeworx' or 'validate_claim' by focusing on bet-specific research.

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 provides explicit use cases: 'should I bet on X?', 'what does the data say about this Polymarket market?', or 'is there edge in this bet?'. It also implies it's the preferred method over manual pack discovery ('agents that get bet-relevant context here convert better than ones that have to discover the packs themselves'), offering guidance on when to use. However, it does not explicitly state when not to use or list alternative tools.

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

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

No annotations provided, so description bears full burden. It discloses the specific data returned for each entity type, the source (SEC EDGAR), and that it returns paired data and URIs. It does not mention whether it's read-only or any side effects, but for a comparison tool, this is reasonably transparent.

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

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

Two sentences: first sentence states the core purpose, second provides type-specific details and output characteristics. No extraneous words, well front-loaded with the most important 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 complexity of comparing multiple entities with different data points per type, the description covers the main aspects: entity types, data fields, source, and output format (paired data + URIs). It also mentions efficiency gains. Lack of output schema is compensated by description. Could add error handling details, but overall 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?

Input schema has 100% description coverage, and the description adds substantial value beyond schema by explaining the meaning of 'values' for each type (e.g., tickers/CIKs for company, drug names) and providing examples. This enriches the parameter semantics significantly.

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

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

The description clearly states the tool compares 2-5 entities side by side, with specific data for 'company' (revenue, net income, cash, long-term debt from SEC EDGAR) and 'drug' (adverse-event report count, FDA approval count, active trial count). It distinguishes from siblings by mentioning it replaces 8-15 sequential agent 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 gives clear context for when to use (comparing 2-5 entities of a type) and implies it's for batch operations, but does not explicitly state when not to use or provide alternative tools for single entity queries. The mention of replacing sequential calls provides additional 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?

No annotations provided, so description carries burden. It states no parameters needed, implying a simple call. However, it doesn't disclose return format, freshness, or pagination. Adequate for a parameterless tool, but could add context like 'returns a map of chain names to TVL values'.

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 short sentences, front-loaded with purpose. Zero wasted words. Perfectly concise for the simplicity of the tool.

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 parameters, no output schema, and no annotations, the description is adequate for a simple list call. It's complete enough for the agent to select and invoke. Could optionally mention return format or caching, but not required for this level of complexity.

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

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

No parameters exist, so schema coverage is 100%. The description adds value by confirming no input is needed, which is helpful. Baseline for 0 params is 4, as per guidelines.

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 returns TVL for each blockchain with a specific verb ('Get') and resource ('TVL for each blockchain'). It distinguishes itself from siblings like 'defi_protocol_detail' or 'defi_tvl_protocols' by targeting chains, not protocols.

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

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

The description implicitly says it's for chain-level TVL, not protocol-specific data. No explicit when-not or alternatives, but the sibling context and 'no parameters' hint at simplicity. Lacks explicit exclusion of protocol-level 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 must disclose behavior. It states it returns TVL history, chain breakdowns, and token info, which implies a read-only operation. However, it does not disclose potential rate limits, data freshness, or any side effects. Given no annotations, a score of 3 is appropriate as the description adds some behavioral context 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 a single sentence that efficiently conveys the tool's purpose and what it returns. 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 only one parameter, no output schema, and no annotations. The description covers the return value ('TVL history, chain breakdowns, and token info') which is adequate for a simple retrieval tool. It could mention that the result is a JSON object, but the description is mostly complete given the tool's simplicity.

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

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

Schema description coverage is 100% (the single parameter 'protocol' is described with examples). The description does not add much beyond the schema for this parameter, but the schema already provides sufficient semantics. Since coverage is high, baseline is 3; the description's mention of 'specific DeFi protocol' reinforces the parameter's purpose, earning a 4.

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

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

The description uses a specific verb 'get' and clearly identifies the resource ('detailed TVL history, chain breakdowns, and token info for a specific DeFi protocol'). It distinguishes itself from siblings like defi_tvl_protocols (which lists protocols) and defi_chain_tvl (which focuses on chains) by emphasizing per-protocol details.

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: when you need detailed info about a single protocol. It does not explicitly state when not to use it or mention alternatives, but the sibling list provides context. A brief exclusion would improve clarity.

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 mentions 'returns daily fee/revenue figures' but does not disclose any behavioral traits like rate limits, data freshness, or whether historical data is available. The tool name implies a focus on fees, but the description is 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?

The description is short (two sentences) and front-loaded with the key action. However, it could be more concise by avoiding redundancy (e.g., 'fee or revenue data' and 'daily fee/revenue figures' say similar things).

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 2 parameters with full schema coverage but no output schema, the description should clarify the return format or data structure. It does not, leaving the agent unsure what the output looks like. The description is complete enough for a simple tool but lacks behavioral 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%, so baseline is 3. The description does not add meaning beyond the schema; it simply restates 'fee or revenue data' and 'daily fee/revenue figures'. The schema already explains protocol slug and data_type 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 clearly states it gets fee/revenue data for a DeFi protocol and specifies daily figures. This distinguishes it from siblings like defi_tvl_protocols (TVL) and defi_yields (yields). However, it does not explicitly differentiate from potential fee-related siblings not present.

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 others like defi_protocol_detail or defi_tvl_protocols. The description lacks context on prerequisites or scenarios, leaving the agent to infer from the name alone.

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

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

With no annotations, the description carries full burden. It accurately indicates this is a read-only operation with no parameters, providing sufficient transparency for a simple data 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 very concise (two sentences) and front-loads the purpose. Every sentence is necessary and 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 tool has no parameters, no annotations, and no output schema, the description adequately explains what the tool does. It might benefit from mentioning the data format or time range, but it's complete for a simple query.

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

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

The input schema has zero parameters, and the description confirms this ('No parameters needed'). Since there are no parameters to explain, the description adds value by explicitly stating the lack of parameters.

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 retrieves stablecoin market data with specific categories (market cap and chain distribution), which distinguishes it from sibling tools like defi_chain_tvl or defi_protocol_detail.

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 does not explicitly state when to use this tool vs alternatives, but the 'no parameters needed' note implies it's for a broad overview. No guidance on exclusions.

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

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

With no annotations, the description carries the burden. It indicates the tool is a read operation (retrieves TVL) and returns specified fields. However, it does not disclose pagination, rate limits, or data freshness (e.g., whether TVL is real-time or historical). This is acceptable for a simple data 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 two sentences with no wasted words. It first states the purpose and then lists output fields. The information is front-loaded and sufficient.

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

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

Given the tool's low complexity (2 optional parameters, no output schema), the description is complete enough for an agent to use it correctly. It specifies inputs, filtering behavior, and output fields. No additional details (e.g., return format) are needed since the tool likely returns a standard list.

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 (search and category). The description adds context by stating that search is case-insensitive substring match and gives example categories, but this is already implied by the schema. Thus, it adds minimal value 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 retrieves TVL for all DeFi protocols, with optional filters by name or category. It lists the output fields (protocol name, TVL, chain, category) and distinguishes from siblings like defi_chain_tvl (chain-level TVL) and defi_protocol_detail (single protocol details).

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 optional filtering parameters but does not explicitly state when to use this tool vs alternatives. However, the sibling context and tool name make it clear this is for broad protocol TVL queries, while siblings like defi_protocol_fees or defi_yields are for other metrics.

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 must disclose behavioral traits. It mentions that results include APY, TVL, and project info, which gives some idea of the output. However, it does not mention whether the tool is read-only, rate limits, pagination, or any side effects. The description is neutral but lacks depth for a tool with no 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 two sentences and efficiently conveys purpose and optional filters. It is front-loaded with the core function. One point off because the second sentence could be more concise or integrated.

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 should explain return values, but it only vaguely mentions 'APY, TVL, and project info.' With a moderate complexity of three optional filters and no required parameters, the description is incomplete for an agent to fully understand what data to expect or how to use the results.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds a brief mention of filtering by project name, minimum TVL, or minimum APY, which aligns with the schema but adds no new meaning. The baseline is 3, and no extra value is provided.

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

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

The description clearly states that the tool retrieves DeFi yield pool opportunities with APY, TVL, and project info. It is specific about the resource (DeFi yield pools) and the verb (Get). However, it does not distinguish itself from sibling tools like defi_chain_tvl or defi_protocol_detail, which also deal with DeFi data, so it loses one point.

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 does not provide any guidance on when to use this tool versus the other DeFi sibling tools. It only mentions optional filters but no when-to-use or when-not-to-use context. With five DeFi-related siblings, this lack of guidance is a significant gap.

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

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

Description implies search functionality but does not detail behavior like pagination, sorting, or whether it handles partial matches. However, the input schema clarifies the query and limit parameters. No annotations provided, so the description carries the burden; it adds the 'returns most relevant' but lacks specifics on ranking.

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

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

Two sentences with no wasted words. Front-loaded with key action and resource, then immediate call to action. Highly concise.

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 return format or limitations. However, the description and schema together cover the basics: natural language query, limit. Slight gap in not describing the structure of returned results (e.g., relevance order).

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 does not add extra meaning beyond what's in 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 uses specific verb 'search' and resource 'tool catalog', clearly stating it returns tool names and descriptions. Distinguishes from siblings like ask_pipeworx, defi tools, and memory tools by being a discovery tool for the catalog itself.

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

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

Explicitly states 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task.' This is a clear directive on when to use the tool, though no explicit when-not or alternative names given, the context strongly implies its primary role.

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. Description mentions returns citation URIs and replaces many calls, but does not explicitly state the tool is read-only, safe, or idempotent. Missing disclosure of potential side effects or authorization needs.

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: first defines purpose and contents, second provides URI info and alternative use cases. No redundant words, front-loaded with key 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?

Despite no output schema, description fully explains return values (citation URIs) and covers critical edge cases (federal contracts and name resolution). Sufficient for the tool's complexity.

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

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

Schema coverage is 100%, but the description adds context beyond parameter descriptions by detailing what data the profile includes (SEC, XBRL, patents, etc.), enhancing understanding of how parameters map to results.

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

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

The description clearly states the tool returns a 'full profile of an entity across every relevant Pipeworx pack in one call,' specifics for 'company' type (SEC filings, XBRL, patents, news, LEI), and mentions it replaces 10-15 sequential calls. This distinguishes it from sibling tools like resolve_entity and compare_entities.

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

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

Explicitly says when to use (full profile) and when not ('For federal contracts call usa_recipient_profile directly'). Also advises using resolve_entity if only a name is available, providing clear decision criteria.

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

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

No annotations are provided, so the description bears the full burden of behavioral disclosure. It states the delete operation but does not mention whether the deletion is permanent, reversible, or requires confirmation. There is no info on error conditions (e.g., key not found) or return value.

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, concise sentence that efficiently conveys the core purpose. 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 simplicity (one required parameter, no output schema, no nested objects), the description is adequate but lacks behavioral details such as idempotency, error handling, or confirmation. The lack of annotations further reduces completeness.

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

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

The schema provides 100% coverage with a description for the 'key' parameter. The tool description adds little beyond the schema, but the schema itself is sufficient. With only one parameter and full coverage, a score of 4 is justified.

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

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

The description clearly states the action (delete), the resource (stored memory), and the identifier (key). It distinguishes itself from sibling tools like 'recall' and 'remember', which likely perform read and write operations respectively.

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

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

The description implies usage by specifying 'by key', but does not provide explicit guidance on when to use this tool versus alternatives like 'recall' or 'remember'. No context on prerequisites or side effects is given.

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 mark it as read-only, idempotent, and non-destructive. Description adds context about fetching the page and extracting title/description/key links, which aligns 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?

Two sentences plus a bullet list of use cases. Front-loaded with the primary action. 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 (2 params, no output schema), the description explains the output format and use cases adequately. Missing explicit mention of error handling or edge cases is acceptable.

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

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

Schema covers both parameters (url and max_links) with descriptions. The description does not add significant detail beyond what the schema provides, so score is baseline 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 generates a production-ready llms.txt file by fetching a page and extracting metadata. It distinguishes itself from sibling tools which cover different domains like AI visibility, betting, and DeFi.

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 (indexing a client's site, drafting for own project, auditing competitors) but does not specify when not to use it or mention alternatives.

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

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 rate limiting and that it is 'Free', but omits behavioral details such as whether the operation is synchronous or any side effects beyond sending. For a simple feedback tool this is acceptable but not exhaustive.

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

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

The description is three sentences, each serving a purpose: stating the action/use cases, providing a content guideline, and noting rate limit/cost. No redundant or vague text.

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

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

Given the tool's low complexity (3 parameters, no output schema) and the richness of the schema descriptions, the description covers all essential aspects: purpose, usage, rate limit, content guidelines, and cost. No gaps remain for effective 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?

All parameters have schema descriptions, and the tool description adds extra guidance on message content ('Describe what you tried...') beyond the schema. This helps the agent craft appropriate input, though the schema already provides good enum descriptions for 'type'.

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 ('Send') and clearly identifies the resource ('feedback'). It also lists concrete use cases (bug reports, feature requests, etc.), making it easy to distinguish 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?

The description provides clear context for when to use the tool and includes a specific instruction (do not include the end-user's prompt verbatim) and a rate limit. However, it does not explicitly mention when not to use it or suggest alternative tools for related actions.

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 readonly, idempotent, and not destructive. The description adds value by explaining the data source (CF analytics engine), privacy (no PII), and caching behavior (5min-1h). 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 moderately concise with a clear structure: purpose sentence, bulleted use cases, then technical notes. It could be slightly tighter but is well-organized and front-loaded.

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

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

Despite no output schema, the description sufficiently explains what is returned (top tools, packs, volume), the data source, privacy, and caching. Given the tool's simplicity (one parameter with enum), it is fully complete.

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

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

Schema coverage is 100% and includes a good description of the parameter. The description adds context about shorter vs longer windows, but this is largely redundant with the schema's enum description. 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 uses a specific verb phrase 'what other AI agents are calling on Pipeworx right now' and explicitly states it returns top tools, top packs, and call volume. It distinguishes itself from sibling tools by focusing on aggregated usage trends, which no other sibling tool covers.

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 three explicit use cases (discovering hot data sources, confirming canonical tools, seeing alignment). It does not explicitly mention when not to use or alternatives, but the context 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=true, openWorldHint=true, and destructiveHint=false, which the description does not contradict. The description adds behavioral context: the tool searches markets, groups them, checks monotonicity, and returns ranked opportunities with reasoning. It explains the limitation of single-event mode and how cross-event mode addresses it, aligning with openWorldHint.

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 moderate length. It front-loads the main purpose and then explains modes. While it is detailed, it could be slightly more compact without losing clarity. Structure is logical: purpose, modes, examples, and output summary.

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 description covers the main behavior, modes, and expected output ('ranked opportunities with suggested trade direction + reasoning'). No output schema is provided, but the description gives a high-level idea. It does not mention pagination, rate limits, or error handling, but for a read-only search tool, the description is sufficiently complete for an agent to use correctly.

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

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

The input schema has 100% coverage, with both parameters ('event' and 'topic') having descriptions. The description goes beyond schema by providing usage examples, explaining the distinction between modes, and clarifying that 'topic' triggers a cross-event search. This adds significant semantic value.

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

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

The description clearly states the tool's purpose: 'Find arbitrage opportunities on Polymarket by checking for monotonicity violations across related markets.' It specifies two modes ('event' and 'topic') with concrete examples, and the resource is explicitly Polymarket. This distinguishes it from sibling tools like 'polymarket_edges' by its specific arbitrage-finding function.

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 each mode: single-event mode for one event's child markets, cross-event mode for related markets across separate events. It gives an example scenario where cross-event mode is needed (May≤June rule). However, it does not explicitly state when not to use the tool or mention alternatives beyond the two modes.

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?

Beyond annotations (readOnlyHint, openWorldHint), the description details the algorithm: scans top markets, groups by asset, fetches price history once, computes model probability, ranks by |edge|. It fully explains the non-destructive, read-only nature and model usage.

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 informative but slightly verbose; however, all sentences contribute context. It is front-loaded with purpose and structured logically.

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

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

For a tool with 3 optional params, no output schema, and simple algorithm, the description fully covers return format (top N with edge magnitude and trade direction) and overall behavior. No gaps remain.

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% and the description repeats the same parameter descriptions verbatim (e.g., 'Top N edges to return after ranking'). No additional meaning is added beyond the schema, meeting the baseline for high 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 scans high-volume Polymarket markets and returns those where Pipeworx data disagrees with market price, using specific verb-resource pairs and distinguishing from siblings like polymarket_arbitrage by specifying 'V1 covers crypto-price bets'.

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 positions the tool for the 'what should I bet on today' question, framing it as an opportunity discovery tool. However, it lacks explicit when-not-to-use guidance or mention of 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, openWorldHint, idempotentHint, and destructiveHint=false, so the description's additional behavioral details (e.g., typical spread range of 2-25pp, leg-by-leg price returns, spread calculation as Kalshi minus Polymarket) add meaningful context without contradicting 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 somewhat lengthy but well-structured with clear sections ('TWO MODES', 'Returns'). Each sentence adds information, and the core purpose is front-loaded. A minor reduction in length could improve conciseness, but it remains effective.

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

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

Given the tool's complexity (cross-venue, two modes, no output schema), the description covers all essential aspects: purpose, parameter explanations, return format (leg-by-leg prices and spread), and usage context. It does not need to explain return values since they are described. The description is complete for effective agent selection and invocation.

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

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

The input schema provides 100% coverage of parameters, but the description adds value by explaining the override behavior for explicit parameters (kalshi_event_ticker and polymarket_event_slug) and listing exact topic values. This supplements the schema's descriptions with usage context and 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 computes cross-venue spreads between Kalshi and Polymarket for the same question. It distinguishes itself from sibling tools like polymarket_arbitrage and polymarket_edges by explicitly focusing on the cross-venue arb signal, using a specific verb ('cross-venue spread') and resource ('Kalshi and Polymarket').

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 describes two modes (topic and explicit custom pairing) and provides examples of pre-mapped shortcuts. While it doesn't explicitly state when not to use this tool, the context implies it's for cross-venue arbitrage, and the sibling tools are available for single-venue analysis. The usage guidance is clear but could benefit from explicit exclusions.

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

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

No annotations provided, so description carries full burden. Clearly states it retrieves stored memories and that omitting key lists all. Discloses scope: saved earlier in session or previous sessions. No contradictions.

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

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

Two sentences, front-loaded with action, no wasted words. First sentence covers core purpose and variant behavior, second adds usage context.

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 simple tool (1 optional param, no output schema), description is complete enough. Explains key behavior and scope. Could optionally mention return format or persistence duration, 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 description coverage is 100%, so baseline 3. Description adds meaning by explaining 'key' is the memory key to retrieve, and omitting lists all keys. Also provides context that memories are saved from earlier sessions.

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 specifies verb 'retrieve' and resource 'memory' by key, also explains listing all memories if key omitted. Clearly distinguishes from sibling 'remember' (store) and 'forget' (delete).

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 when to use: to retrieve previously stored context. Also explains variant behavior (omit key to list all). However, does not mention when not to use or compare with alternatives beyond 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?

With no annotations, the description carries full burden. It discloses the parallel fan-out to multiple data sources, accepted input formats, and return structure (structured changes, total_changes, URIs). This adequately characterizes the tool's behavior for selection and invocation.

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 (5 sentences), well-structured, and front-loaded with the core purpose. Every sentence adds value—no redundancy or filler.

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 3 parameters, no output schema, and no annotations, the description covers purpose, inputs, outputs, and use cases. It lacks error handling or pagination details, but is sufficiently complete for a query 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 covers 100% of parameters, but the description adds practical guidance: 'since' accepts ISO/relative and suggests '30d'/'1m'; 'value' confirms ticker/CIK; 'type' restricts to company. This extra context helps the agent choose correct values beyond the schema.

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

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

The description clearly states the verb ('what's new') and resource ('entity'), and differentiates itself by specifying the time-windowed change-monitoring use case, which distinguishes it from sibling tools like entity_profile (static) and compare_entities (comparison).

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 recommends using this tool for 'brief me on what happened with X' or change-monitoring workflows, providing clear use context. However, it does not mention when not to use it or alternatives for other entity types.

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 behavioral traits: it stores key-value pairs, distinguishes between authenticated (persistent) and anonymous (24-hour) sessions, and implies memory duration. This is sufficient for the tool's simplicity.

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, each adding value: first states the core function, second gives use cases, third explains persistence behavior. 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 simplicity (2 simple params, no output schema, no annotations), the description is complete. It covers purpose, usage, and behavioral nuances. Could be improved by mentioning what happens on overwrite, but not strictly necessary.

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 baseline is 3. The description adds a bit of context about what values can be stored (findings, addresses, etc.), but does not add meaning beyond the schema's parameter 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 'Store a key-value pair in your session memory', which is a specific verb+resource combination. It also distinguishes itself from sibling tools like 'recall' and 'forget' by focusing on storage, not retrieval or deletion.

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 this tool ('save intermediate findings, user preferences, or context across tool calls') and provides context about persistence for authenticated vs anonymous users, though it does not explicitly mention when not to use it or suggest alternatives.

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

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

With no annotations, the description bears full burden for behavioral disclosure. It explains input formats, return values, and versioning (v1 only supports company). However, it does not state whether the operation is read-only or if there are side effects, authentication needs, or error behavior.

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

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

The description is two sentences, front-loaded with core purpose and scope. Every sentence serves a purpose: first defines the tool, second provides version details and output summary. 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 simplicity of the tool (2 params, no output schema), the description is sufficiently complete. It covers input format, version constraints, and output fields. Missing aspects like error handling or authentication are minor in this 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 description coverage is 100%, baseline 3. The description adds value beyond the schema by providing examples (AAPL, 0000320193, Apple) and explicitly listing accepted formats for the value parameter, enhancing understanding.

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

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

The description clearly states the tool resolves entities to canonical IDs across Pipeworx data sources, specifying the verb (resolve), resource (entity), and scope. It provides a concrete example for type=company, distinguishes from siblings by focusing on entity resolution, and notes 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 implies when to use by stating it replaces 2-3 lookup calls, consolidating lookups. However, it does not explicitly mention alternatives or when not to use, nor compare with sibling tools. The context is clear but lacks explicit exclusions.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds value by detailing the process: probes each entity, ranks by score, and surfaces most/least recognized. It also mentions the return fields (score, confidence, signal density). No contradictions.

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

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

The description is concise (3 sentences), front-loaded with purpose, and structured effectively. Every sentence adds value: purpose, method, use case, and return format. 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 no output schema, the description adequately describes the return values (ranked list with score, confidence, signal density). It mentions the use of 'ai_visibility_check' and the constraint of 2-8 entities (present in schema). It could mention error handling or performance considerations, but overall complete for a non-destructive read tool.

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

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

With 100% schema description coverage, the description still adds meaning beyond the schema. It clarifies that the first entity is treated as the 'subject' for narrative, explains model dependencies (e.g., 'omit for just workers-ai'), and contextualizes the usage of '_apiKey'.

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: comparing AI visibility across multiple entities side-by-side. It specifies the verb 'compare' and the resource 'AI visibility', and distinguishes itself from sibling tools like 'ai_visibility_check' (single entity) and 'compare_entities' (more general).

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 use ('competitive AI-marketing audits') with an example query. It implies alternatives by mentioning probing with 'ai_visibility_check', but does not explicitly state when not to use this tool or list exclusions.

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

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

Annotations already indicate read-only and idempotent behavior. The description adds critical behavioral detail: 'Partial failures degrade gracefully — bundlephobia's first measurement on a new version can take 5-30s; sources_failed will list it if it times out, the rest still returns.' This discloses latency and partial failure modes beyond what annotations capture.

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 functional and informative, with a clear structure: composite nature, use case, output, limitations, failure behavior. However, it could be more concise (e.g., bullet points for output fields) and avoid some redundancy. Still, every sentence adds value and it is front-loaded with the core purpose.

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

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

Given 2 parameters, no output schema, and unrelated siblings, the description provides comprehensive context: purpose, usage trigger, ecosystem scope, output summary, and graceful degradation. An agent can fully understand when and how to use the tool without additional information.

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 covers both parameters with descriptions (package accept scoped packages, version defaults to latest). The description does not add significant extra meaning beyond the schema; it mentions the default version but that is already in the schema. With 100% schema coverage, 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 it is a composite check for npm packages, combining data from deps.dev and bundlephobia. It specifies the exact action ('should I add this npm package'), the scope (npm ecosystem), and the information returned (license, advisories, bundle size, etc.). This distinguishes it from sibling tools which focus on different domains (defi, entities, etc.).

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

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

The description explicitly tells when to use the tool: 'Use whenever an agent asks 'is X safe / popular / small' or 'what does adding lodash cost me'. It also provides clear exclusion criteria: 'NPM ecosystem only in v1; PyPI / Maven / Cargo / Go fall under deps.dev:version directly.' This guides the agent to select the correct tool.

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

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

With no annotations, the description carries full behavioral disclosure burden. It explains the tool returns a verdict, extracted structured form, actual value with citation, and percent delta. It also mentions the underlying data sources (SEC EDGAR + XBRL). Missing details on auth, rate limits, or error handling, but overall transparent.

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

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

The description is two sentences long, both front-loaded with key information. The first sentence states the core purpose, the second adds details on scope, output, and benefits. No unnecessary words.

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

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

Given the tool has only one parameter, no output schema, and no annotations, the description covers the essential aspects: purpose, supported domain, output format, and efficiency. It could mention unsupported claim types explicitly, but current detail is sufficient for an agent to use it correctly.

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

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

Schema coverage is 100% for the single 'claim' parameter, and the description adds examples and clarifies the natural-language format (e.g. 'Apple's FY2024 revenue was $400 billion'). This provides context beyond the schema property description.

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

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

The description clearly states the tool's purpose: fact-check a natural-language claim against authoritative sources, with a specific scope of company-financial claims for US public companies. It differentiates from siblings like 'compare_entities' and 'entity_profile' by focusing on verification with a structured verdict.

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 indicates when to use the tool (for company-financial claims) and notes that it replaces 4-6 sequential agent calls, implying efficiency benefits. However, it does not explicitly state when not to use it or provide alternatives for other domains.

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