Mailchimp

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

Annotations declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. Description adds that it's a probe returning scores and signals, and mentions cost implications for Anthropic (BYO key). No contradiction. Could mention rate limits or response time.

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 well-structured sentences. First sentence front-loads action and outcomes; second adds default/optional details. Every sentence earns its place with 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 no output schema, description details return shape (per-model {score, confidence, signals, raw_response} + combined view). Also explains default model and BYO key. Complete for a tool with 4 parameters.

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 description adds context for each parameter: entity (examples), models (supported values), _apiKey (pass-through to Anthropic), context (disambiguation role). Provides meaning beyond schema.

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

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

The description clearly states it probes LLMs for brand knowledge and returns visibility scores per model, with specific verb 'probe' and resource 'LLMs'. It distinguishes from sibling tools like 'scan_competitor_ai_presence' by focusing on direct LLM queries.

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

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

Explicitly states use cases (AI-marketing audits, pre-launch brand checks, competitive monitoring) and default model plus BYO key for Anthropic. Lacks explicit when-not-to-use or direct alternatives among siblings, but context makes usage 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?

Description fully discloses that Pipeworx selects the right tool, fills arguments, and returns results. No annotations provided, so description carries full burden and does so effectively.

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 concise sentences front-loaded with purpose, followed by examples. Every sentence adds value.

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

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

Description is complete for a single-param tool with no output schema; it explains behavior and usage. Minor gap: no mention of limitations or error handling, but acceptable given simplicity.

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

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

Schema coverage is 100%, and description adds context on how to use the single parameter ('describe what you need') with examples, going beyond the schema's minimal 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?

Description uses specific verbs ('ask', 'picks', 'fills', 'returns') and clearly states the tool answers natural language questions by selecting the best data source. It distinguishes from siblings by acting as a meta-tool that abstracts away other 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?

Description explicitly says to describe needs in plain English and provides examples. However, no guidance on when not to use or alternatives, but the tool is designed to be the primary entry point.

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 openWorldHint=true. The description adds significant behavioral context: it resolves the market, classifies the bet type, fans out to relevant data packs, and returns an evidence packet with a comparison. 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 a single paragraph that is front-loaded with purpose. It contains multiple sentences each adding value, though it could benefit from slight restructuring or bullet points for 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 there is no output schema, the description adequately describes the output as an evidence packet and market-vs-model comparison. It covers the tool's workflow and purpose, making it complete for a research tool.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description reinforces the 'depth' enum meaning and 'market' parameter types but does not add new semantic information beyond the schema.

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

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

The description clearly states the tool resolves a Polymarket bet by pulling Pipeworx data. It specifies inputs (slug, URL, question text) and outputs (evidence packet, market-vs-model comparison). It distinguishes itself from sibling tools like 'ask_pipeworx' or 'validate_claim' by being specialized for Polymarket 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 states when to use: 'should I bet on X?', 'what does the data say about this Polymarket market?', or 'is there edge in this bet?'. It implies the tool is for Polymarket bets but does not explicitly state 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?

Without annotations, the description carries the full burden. It discloses data sources (SEC EDGAR, FDA) and return type (paired data + URIs) but omits whether the operation is read-only, side effects, or rate limits. Adequate but not fully 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?

Three concise sentences with front-loaded purpose. No redundant information; each sentence provides distinct value: purpose, per-type details, and return format/efficiency benefit.

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

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

Given no output schema, the description sufficiently outlines return data (paired data + URIs) and key fields per entity type. It could detail the output structure further, but for a comparison tool with clear schema, it is adequately 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% with clear enum and array constraints. The description adds value by explaining what data is retrieved for each type (e.g., 'revenue, net income' for companies), going beyond the schema's basic 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 the tool compares 2–5 entities side by side, differentiating by entity type (company or drug) and listing the specific data points compared. It distinguishes itself from siblings by highlighting the efficiency gain of replacing 8–15 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 usage for parallel comparison of entities, noting it replaces multiple sequential calls. However, it does not explicitly state when not to use it or mention alternative tools like ask_pipeworx for single-entity 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?

The description reveals that the tool searches by natural language, returns relevant tools with names and descriptions, and is intended for discovery. Without annotations, this is sufficient, though it could mention that it does not execute tools or provide detailed usage beyond search results.

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: first states the purpose, second adds return value details, third gives explicit usage guidance. No fluff, front-loaded with key 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?

For a search/discovery tool with no output schema, the description is complete: it explains what it does, what it returns, and when to use it. With 2 parameters and simple behavior, no additional context is needed.

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

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

The description provides a natural language query example for the 'query' parameter, adding context beyond the schema description. The 'limit' parameter is only mentioned in the schema; the description does not add extra meaning, but schema coverage is 100%, so baseline is 3. The example earns an extra point.

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 'Search', the resource 'Pipeworx tool catalog', and the specific behavior 'by describing what you need'. It also distinguishes the tool from siblings by recommending it as a first step when many tools are available.

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

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

The description explicitly says 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task', providing clear guidance on when to use it and its role in a workflow.

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 the burden. It discloses that the tool returns citation URIs and replaces many sequential calls, but does not mention rate limits, authentication requirements, or error behavior. Adequate but missing some behavioral details.

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

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

The description is concise and front-loaded with the main purpose. Each sentence adds essential information without redundancy. It effectively communicates the tool's value and limitations in just a few lines.

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 (multiple data sources) and simple input schema, the description covers what data is returned (SEC filings, XBRL, patents, news, LEI) and output format (pipeworx:// URIs). It also mentions it replaces many calls. However, it could mention if there are any limits on the response or additional usage notes. Still fairly 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%, baseline 3. The description adds value by explaining that type is only 'company' for now, and that value can be a ticker or CIK, explicitly noting that names are not supported and directing to resolve_entity. This exceeds 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 it returns a full profile of an entity across multiple Pipeworx packs, with specific details for company type. It distinguishes itself from siblings like resolve_entity and usa_recipient_profile, making its purpose unmistakable.

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

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

Explicitly states when to use (comprehensive entity profile) and when not to (federal contracts, use usa_recipient_profile directly). Also advises using resolve_entity first if only a name is available, providing clear guidance on 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 states 'delete' which implies destructive action, but does not disclose whether deletion is irreversible, cascading effects, or required permissions. Adequate for a simple key-based delete.

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, minimal and direct. 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), the description is nearly complete. It explains what it does and how to specify the memory. Could mention if the key is case-sensitive or if it returns 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 coverage is 100% with a single required parameter 'key' described as 'Memory key to delete'. The description does not add new semantics beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the verb 'delete' and the resource 'stored memory', with 'by key' specifying the identifier. It distinguishes itself from sibling tools like 'remember' (store) and 'recall' (retrieve).

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 explicit when-to-use or alternatives provided. The tool name and description imply a simple deletion action, but without context on when to forget versus other memory operations, guidance 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?

The description adds significant behavioral context beyond annotations: it discloses the tool fetches the page, extracts title/description/key links, and outputs standard llms.txt markdown format. This is consistent with readOnlyHint and idempotentHint annotations, and no contradictions are present.

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 relatively concise at four sentences, with the main purpose front-loaded. Minor redundancy exists but overall it is well-structured and efficient.

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

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

Given the parameter count (2), 100% schema coverage, and presence of safety annotations, the description is complete enough. It explains the output format ('single text blob') and use cases, though it could briefly mention that the tool only handles HTML pages.

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 both parameters, so the description adds minimal additional meaning. The description mentions extracting 'key links' which relates to max_links, but does not provide further semantics beyond what the schema already offers. 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 generates a production-ready llms.txt file for any URL, specifies the verb 'generate' and resource 'llms.txt file', and distinguishes from siblings by detailing specific use cases (indexing by AI, drafting for own project, auditing competitors). No sibling tools perform similar functions.

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

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

The description provides explicit contexts for when to use the tool (getting a client's site indexed, drafting for own project, auditing competitors), but does not include explicit when-not-to-use or alternatives. Given the absence of closely related siblings, this is sufficient.

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

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

No annotations provided, so description must disclose behavior. It states it returns name, stats, and settings, but does not mention whether it is read-only, any rate limits, or error conditions. The mutation intent is not clear (read operation implied but not explicit).

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?

One sentence with key information. No fluff, but could include more details on return format without becoming too long.

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 and no annotations, the description is incomplete. It does not explain the structure of the returned details, pagination, or error handling. For a tool with only 2 parameters, it should provide more context about what is returned.

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 no extra meaning beyond the schema; it simply says 'by ID' which matches the list_id 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 it gets details of a Mailchimp audience by ID, specifying return fields (name, stats, settings). This distinguishes it from sibling tools like mailchimp_list_audiences which lists all audiences.

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 like mailchimp_list_audiences. No mention of prerequisites (e.g., needing to have list_id from list operation).

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 the burden. It states it returns 'campaign settings, tracking, and report summary', which gives some behavioral insight into what fields are returned. However, it doesn't disclose side effects (likely none), authentication requirements beyond the apiKey parameter, or any rate limits. With no annotations, a score of 3 is adequate but not thorough.

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: the first states the purpose and the second lists return contents. No wasted words. Front-loaded with the core 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 the tool's low complexity (2 parameters, no output schema, no nested objects), the description is reasonably complete. It explains what it gets and the categories of returned data. Could be improved by noting that it requires a valid campaign_id from mailchimp_list_campaigns.

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 ('Mailchimp API key' and 'Campaign ID'). The description adds no additional meaning beyond what the schema provides. Baseline 3 is appropriate when schema already documents parameters well.

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 'Get details of a specific Mailchimp campaign by ID', which is a specific verb ('Get') and resource ('campaign details'). It distinguishes from siblings like mailchimp_list_campaigns (list vs. get) and mailchimp_get_audience (different resource).

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 explicit guidance on when to use this tool vs. alternatives. For example, it doesn't mention that you need to call mailchimp_list_campaigns first to get the campaign_id. The context of 'by ID' implies it's for a specific campaign, but no when-not-to-use or alternative conditions.

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 mentions returns 'audience name, member count, and stats', which gives some behavioral insight but does not disclose potential pagination limits (though count/offset are in schema) or any rate limiting or authentication details beyond the schema's apiKey.

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-loading the main action and key return fields. It is concise and to the point, with 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 is a list operation with no output schema and 3 parameters, the description is adequate but could be improved by mentioning pagination behavior or typical use cases. It covers the essential information but lacks depth for a fully self-contained description.

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 parameters are well-documented in the schema. The description does not add additional semantics beyond the schema; it simply states the overall purpose. 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 'List all audiences (lists) in your Mailchimp account' with a specific verb and resource. It differentiates from siblings like mailchimp_get_audience by indicating a list operation with summary stats.

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

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

The description implies usage for retrieving all audiences, but no explicit when-to-use or alternatives are given. Siblings like mailchimp_get_audience suggest a more detailed single audience retrieval, but the description does not guide when to choose one over the other.

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 the description carries the burden. It discloses that campaigns are listed and returns specific fields, but does not mention mutability (likely read-only), rate limits, or authentication details beyond the _apiKey parameter. The description is adequate 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 concise: one sentence stating the purpose and one sentence listing returned fields. 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 that there is no output schema, the description does not fully explain the return structure (e.g., whether it's an array, pagination details). However, the tool is relatively simple and the schema covers parameters well. The description is minimally complete but could mention pagination or max count.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no additional parameter meaning beyond the schema's own descriptions. For example, 'status' filter values are already listed in the schema.

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

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

The description clearly states the tool lists email campaigns from a Mailchimp account and specifies the returned fields (title, type, status, send time). This differentiates it from siblings like mailchimp_get_campaign (single campaign) and mailchimp_list_audiences (audiences).

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 versus alternatives. However, the sibling names provide implicit context: use this for listing campaigns, while mailchimp_get_campaign is for a specific campaign. No guidance on filtering or prerequisites 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?

With no annotations, the description should disclose behavioral traits. It mentions returns (email, status, merge fields) and implies a read operation. However, it does not mention pagination behavior beyond schema hints, rate limits, or authorization requirements beyond the API key.

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 covering purpose and return fields. No fluff, but could be slightly more structured (e.g., separate sentence for returned fields).

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 5 parameters, full schema coverage, no output schema, and no annotations, the description is adequate but minimal. It explains the core function but lacks details on pagination, filtering behavior, and error conditions.

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 parameters. The description adds no extra meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description uses specific verbs and resources: 'List members (subscribers) of a specific Mailchimp audience.' It also specifies returned fields (email, status, merge fields), clearly distinguishing it from sibling tools like mailchimp_list_audiences and mailchimp_list_campaigns.

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

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

The description implies usage for listing subscribers but does not explicitly state when to use this tool vs alternatives. It lacks guidance on prerequisites (e.g., list_id required) or situations where other tools might be more appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It includes a rate limit (5 messages per identifier per day) and states the tool is 'Free.' These are key constraints. However, it does not detail what happens to the feedback after submission (e.g., storage, visibility) or what the response looks like, leaving some gaps.

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—three sentences that front-load the purpose, immediately list use cases with a key usage guideline, and end with a behavioral constraint. Every sentence is necessary and well-organized.

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 and the absence of an output schema, the description provides adequate context for correct invocation: purpose, parameter guidance, rate limit, and what not to include. It does not explain the return value or confirmation behavior, but for a feedback tool this is minor. The description 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 description coverage is 100%, and the input schema already describes all parameters (type enum, context object, message length) with clear descriptions. The description adds no new parameter-specific information beyond restating the message length limit, so baseline score of 3 is appropriate.

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

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

The description starts with a clear verb+resource ('Send feedback to the Pipeworx team') and explicitly lists the types of feedback (bug reports, feature requests, missing data, praise). This distinguishes the tool from siblings like ask_pipeworx (for queries) or discover_tools (for exploration).

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 specifies exactly when to use the tool (for bug reports, feature requests, etc.) and provides a critical 'do not' (avoid including the end-user's prompt verbatim). While it does not explicitly name alternatives, the intended use is clearly separated from querying or discovery 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?

Annotations already indicate idempotent, read-only, and non-destructive behavior. The description adds valuable behavioral context: it notes the data is derived from CF analytics-engine, contains no PII, is cached for 5min-1h, and is self-aggregating. This goes beyond annotations and helps the agent understand transient vs steady-state signals.

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 long but well-structured: a concise high-level summary followed by bullet-style use cases and technical details. Every sentence adds value, though it could be slightly tighter 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 low complexity (1 optional parameter, no output schema, full annotation coverage), the description covers all essential aspects: purpose, usage guidance, behavioral traits, and parameter semantics. It mentions the return format (top tools, packs, volume) adequately for decision-making.

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 only parameter (window) has a comprehensive enum description that explains its purpose and impact on results. Schema coverage is 100%, and the description adds interpretive guidance (shorter vs longer windows) that the schema alone does not provide.

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 top tools, top packs, and total call volume over a recent window. It uses specific verbs ('Returns') and resources, and the three listed use cases further clarify its purpose. It distinguishes from siblings like ask_pipeworx and discover_tools by focusing on aggregate analytics rather than individual queries.

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

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

The description explicitly lists three use cases (discovering hot data sources, confirming canonical choice, seeing alignment) and provides guidance on window selection ('Shorter windows surface what's hot right now; longer windows show steady-state demand'). It does not explicitly mention when not to use or alternatives, but the context from siblings is sufficient.

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 aligns with readOnlyHint and openWorldHint, adding context on modes and logic. Does not mention potential performance concerns (e.g., large topic searches), but overall adds value beyond 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?

Well-structured with clear sections, though slightly verbose. Every sentence contributes meaning; front-loads purpose and then details modes.

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?

Complex tool with no output schema; description covers modes, search behavior, and return format (ranked opportunities). Sufficient for an agent to understand usage without 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. Description enhances with concrete examples and explanation of when each parameter is used, adding meaning 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?

Description clearly states tool finds arbitrage via monotonicity violations, names two modes (event and topic), and differentiates within tool. While sibling comparison is not explicit, the purpose is highly specific and actionable.

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 explains when to use each mode, provides examples, and highlights why cross-event mode catches cases missed by single-event mode. No ambiguity.

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

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

Beyond annotations (readOnlyHint, openWorldHint), the description details the model (lognormal from FRED, live coinpaprika), grouping by asset, fetching price once, and ranking by edge. This provides rich behavioral context.

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

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

The description is informative but slightly lengthy. It is front-loaded with the core purpose and uses efficient sentences, though some details (e.g., V1, model specifics) could be trimmed for brevity.

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

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

With no output schema, the description mentions return values (top N ranked by edge magnitude with suggested trade direction) but lacks explicit format details. Overall, it covers essential aspects for agent 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% with clear descriptions. The description adds minimal extra meaning beyond restating parameter roles (e.g., 'Top N edges' for limit, 'min edge' for min_edge_pp). 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 scans high-volume Polymarket markets and returns those where Pipeworx data disagrees with market price. It specifies the model and purpose, distinguishing it from sibling tools 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 explicitly targets the 'what should I bet on today' question, indicating a clear use case. However, it does not explicitly exclude other scenarios or contrast with sibling tools.

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

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

Annotations already declare readOnly, idempotent, openWorld, nondestructive. Description adds behavioral details: fetches live prices, returns leg-by-leg data and spread in percentage points, and explains the delta is a real arb signal. 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?

Well-structured with front-loaded purpose, then mode breakdown, then return description. Every sentence adds value. Slightly verbose with example, but still concise overall.

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

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

No output schema, but description fully explains return values (leg-by-leg prices, spread). For a read-only data tool with good annotations and parameter coverage, this is complete enough.

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

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

Schema coverage is 100% with parameter descriptions. Description adds significant context: explains topic list as pre-mapped shortcuts and that explicit parameters override topic mapping, adding 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?

Clearly describes it calculates cross-venue spread between Kalshi and Polymarket, explains why spreads exist (different participant pools), and distinguishes two modes (topic shortcuts and explicit tickers). Differentiates from sibling tools by being specific to this pair.

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

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

Provides clear context on when to use (arbitrage signal) and explains two usage modes. However, does not explicitly state when not to use or contrast with sibling polymarket_arbitrage, leaving some ambiguity.

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

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

Description explains that memories are stored 'in the session or in previous sessions', providing context about persistence. No annotations provided, so description carries full burden; it adds value by clarifying scope. Would benefit from noting any size limits or expiration, but still strong.

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

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

Two sentences with zero waste. First sentence states action and dual behavior, second provides usage context. 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?

For a simple retrieval tool with one optional parameter and no output schema, the description is complete enough. It explains behavior with and without key. Could mention return format, but not essential 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 has 100% coverage with a single parameter 'key' described as 'Memory key to retrieve (omit to list all keys)'. Description adds context about retrieval vs listing, complementing schema well. No additional param info needed.

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 retrieves a stored memory by key or lists all memories when key is omitted, using specific verb 'Retrieve' and resource 'memory'. Distinguishes from sibling tools like 'remember' and 'forget'.

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

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

Explicitly states when to use (retrieve context saved earlier) and provides clear usage pattern: omit key to list all, include key for specific memory. Does not mention alternatives but given the tool's specific function, this is sufficient.

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 for behavioral disclosure. It explains the parallel fan-out to three sources, the return format (structured changes + count + URIs), and the accepted date formats. For a read-only tool, this is transparent, though it does not mention error handling or limitations (e.g., only company type supported).

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

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

The description is four sentences long, front-loaded with the core purpose, and every sentence adds information. There is no redundancy or fluff.

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

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

Given no annotations and no output schema, the description covers inputs, behavior, output structure, and use cases. It is self-contained for a data retrieval tool, though it could mention potential errors for invalid inputs. Overall, it is sufficiently complete.

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

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

Schema coverage is 100%, but the description adds meaning: it explains the fan-out behavior for type='company', gives examples for 'since' (ISO and relative), and suggests typical values like '30d' or '1m'. This goes beyond the basic 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 that the tool retrieves 'what's new about an entity since a given point in time' and specifies that for type='company' it fans out to SEC EDGAR, GDELT, and USPTO in parallel. It distinguishes itself from sibling tools like entity_profile (static profile) and compare_entities (comparison) by focusing on change monitoring.

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

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

The description explicitly provides use cases: 'brief me on what happened with X' or change-monitoring workflows. It explains the format of the 'since' parameter (ISO date or relative). However, it does not explicitly state when not to use the tool or mention 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?

Discloses behavioral differences between authenticated (persistent) and anonymous (24-hour) sessions, which is useful context beyond the schema. No contradictions with annotations (none provided).

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, no fluff. First sentence defines action, second gives use cases, third adds behavioral nuance. Highly efficient.

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

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

Tool is simple with 2 required string params and no output schema. Description fully covers purpose, usage guidance, and behavioral notes. No gaps given the 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%, and description adds practical context like example keys (subject_property, target_ticker) and value types (findings, addresses). This enriches the bare schema without redundancy.

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

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

Clearly states it stores a key-value pair in session memory, with explicit use cases like saving findings, preferences, or context across calls. Distinguishes itself from siblings like 'forget' (deletion) and 'recall' (retrieval).

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

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

Explicitly says when to use (save intermediate findings, user preferences, context across tool calls) but does not explicitly mention when not to use or alternatives. However, siblings like 'recall' and 'forget' imply complementary use.

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

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

With no annotations, the description carries the full burden. It discloses that the tool is a single call and returns specific fields, but it does not cover error conditions, rate limits, or authentication requirements. The description implies a read-only operation but lacks comprehensive behavioral disclosure.

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-loading the purpose and version details. Every word earns its place, with 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 the simplicity of the tool (2 parameters, no output schema, no annotations), the description provides a complete picture: what it does, how to use, and what it returns. It could be improved by describing the response format, but overall it is sufficient.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds concrete examples (e.g., 'AAPL', '0000320193', 'Apple') and clarifies that v1 supports only 'company', which enhances understanding beyond the schema.

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

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

The description clearly states the verb 'resolve' and the resource 'entity', specifying the outcome of getting canonical IDs. It also distinguishes itself by noting it replaces 2-3 lookup calls, differentiating from sibling tools that may require multiple steps.

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

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

The description provides clear context on when to use (when you have a ticker, CIK, or company name) and gives examples. However, it does not explicitly state when not to use or mention specific 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 already indicate safe, idempotent read operation. The description adds behavioral details like ranking, surfacing most/least recognized, and return structure, which go beyond annotations. 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?

Description is compact (6 sentences) with purpose front-loaded. Every sentence adds information without repetition 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?

Tool has no output schema but description explains return values (ranked list with score, confidence, signal density). Given 4 parameters and clear process, the description is complete enough 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% so baseline is 3. The description adds extra meaning for the 'entities' parameter (first entry as subject) and for 'context' (disambiguates common names), providing 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 compares AI visibility across multiple entities, using 'side-by-side', 'probes each entity with ai_visibility_check', and 'ranks by score'. It distinguishes itself from the sibling ai_visibility_check by emphasizing multi-entity comparison and ranking.

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 in competitive AI-marketing audits and includes an example question. It implies when to use (multi-entity comparison) and implicitly contrasts with ai_visibility_check for single entities, but does not explicitly mention when not to use or compare to other siblings like compare_entities.

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 covers the tool's behavior: input (natural-language claim), supported data sources, and output (verdict, structured form, actual value with citation, delta). It does not mention side effects, permissions, rate limits, or error handling, but for a read-only look-up tool this is reasonable transparency.

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

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

Two sentences front-load purpose and domain, then list output and value proposition. Every sentence adds meaningful information with 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 the tool's complexity (single parameter, no output schema, no annotations), the description adequately covers what claims it handles, what sources it uses, and what outputs it returns. It lacks details on handling unsupported claims or edge cases, but overall is sufficient for 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?

Schema coverage is 100% with one parameter (claim). The description adds value beyond the schema by providing examples and clarifying the domain (company-financial, public US companies). It does not cover formatting details for the claim but the examples suffice.

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 (fact-check), resource (natural-language claim against authoritative sources), and domain (company-financial claims for US companies via SEC EDGAR + XBRL). It distinguishes from siblings by mentioning it replaces 4–6 sequential agent calls, implying efficiency over simpler tools like resolve_entity or entity_profile.

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 (for fact-checking financial claims) and mentions it replaces multiple calls, but does not explicitly state when not to use it or provide alternatives. It gives examples of supported claims but no exclusion criteria, so it is clear but not exhaustive.

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