Sam's Club MCP

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

Describes behavior beyond annotations: explains token is JWT, optional, and two login modes. Annotations indicate idempotent and non-destructive, which aligns with description.

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?

Each sentence adds value, front-loaded with audience. Could be slightly tighter but overall well-structured and informative.

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

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

Given no output schema, description explains what happens (returns link or logs in). Adequate for a simple auth tool with one optional parameter.

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 0% coverage, but description adds meaning: token is optional JWT from browser; calling with no args returns a link. This compensates for missing 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 explicitly states the tool authenticates users for MCP.AI IDE agents, detailing two methods (permanent config or session token). It clearly distinguishes from sibling tools like 'connect' or 'marketplace'.

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 when-to-use guidance: for logging in via browser, copy token, and choose between permanent (config) or session (pass token). Lacks explicit when-not-to-use, but context 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?

The description adds behavioral context beyond annotations: it reveals the output structure (authenticated, pending, connect_url) and conditional behavior. Annotations already declare readOnlyHint, idempotentHint, destructiveHint. No contradiction.

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, no fluff. Front-loaded with the main purpose. Every sentence adds value: first states overall function, second explains the two cases.

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 parameters and no output schema. The description sufficiently explains what the return value means in two common scenarios. However, it does not mention error cases or rate limits, though these may be covered elsewhere.

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, and schema description coverage is 100%. The description adds no parameter info (unnecessary), but it does explain the output's meaning for different states, which is the only value 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?

The description clearly states the tool returns connection status and URLs. It explains two scenarios (all connected vs missing credentials). However, it does not differentiate from the sibling 'authenticate' tool, which might have overlapping purpose.

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

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

Implied usage: useful for checking connection state and obtaining URLs. No explicit guidance on when to use this tool vs alternatives like 'authenticate'. The context from the description suggests it's for status checking, but not explicitly stated.

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

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

The description discloses key behavioral traits: invoke works even if the MCP is not installed, may require credentials (returns connect link) or payment (returns checkout/top-up link), and install/uninstall/subscribe/cancel require workspace owner/admin. Annotations (readOnlyHint=false, destructiveHint=false) are consistent with the described side effects, 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 a single substantial paragraph that effectively conveys a large amount of information. It is front-loaded with the primary purpose and then details the core flow and key distinctions. While it is moderately long, every sentence adds value and the structure is logical, though a bit dense.

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 (13 parameters, 10 actions, no output schema), the description covers the essential aspects: purpose, flow, parameter roles, and behavioral notes. It is fairly complete for an AI agent to select and invoke the tool correctly, though a more structured breakdown (e.g., per-action details) would enhance 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?

With 0% schema coverage, the description must compensate. It explains the main parameters (action, query, mcp_id, tool_id, arguments, etc.) within the flow description and notes defaults. However, some parameters like conversation, request_name, report_context, request_details, and tier_slug are not individually described, which leaves gaps. Score 4 because it covers the most critical parameters but not all.

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 'THE official mcp.ai marketplace' and serves as the in-platform catalog and runtime for MCPs/tools. It distinguishes itself by saying 'use THIS tool FIRST' before external registries, and outlines the core flow (search -> describe -> invoke), making it distinct from sibling tools like openfinance or toolkit_info.

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

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

The description provides explicit guidance on when to use this tool (for discovering MCPs, running them, installing, etc.) and contrasts it with alternatives: 'use THIS tool FIRST, before any external/generic registry'. It also distinguishes between invoke (one-off, no permanent addition) and install (permanent), and notes actions for billing and bug reporting.

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 provide destructiveHint=true. The description adds that connection data is deleted, data becomes unavailable, and an add_connection_url is returned for reconnection. This enriches the behavioral understanding beyond annotations, with 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 two sentences, to the point, and front-loaded with the key 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?

For a simple tool with one parameter and no output schema, the description covers the action and result (reconnection URL). However, it is incomplete because it omits parameter semantics, leaving the agent unsure what to pass as 'item'.

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 has one parameter 'item' (string) with 0% coverage. The description does not explain what 'item' is (e.g., bank ID or connection ID). With no schema description, the description must compensate but fails to clarify the parameter's meaning.

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 revokes Open Finance consent and deletes connection data. It uses specific verbs ('Revokes', 'deletes') and identifies the resource (bank connection). It distinguishes from siblings like openfinance_list_connections or openfinance_get_item_status.

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 use when disconnecting a bank, and mentions returning a reconnection URL, providing context. However, it lacks explicit when-not-to-use guidance or comparison to alternatives like openfinance_force_sync.

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 waiting up to 60s, polling behavior, return structure with status fields, error conditions (needs_action), and timeout handling. Annotations are consistent and description adds depth beyond them.

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 and front-loaded, but slightly verbose with multiple details. Every sentence contributes value, though could be tightened without loss of 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?

Covers behavior, parameters, return values, error states, and timeouts. No output schema, but description provides sufficient detail for the agent to understand what to expect.

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

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

With 0% schema coverage, the description fully explains both parameters: items can be an array of selectors or omitted for all, and wait controls synchronous vs fire-and-forget. No ambiguity.

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

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

The description explicitly states the tool forces a re-sync and waits, naming the HTTP method and behavior. It distinguishes from siblings like openfinance_get_item_status and openfinance_list_connections by focusing on the sync action.

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: 'when a balance or transaction list looks stale' and explains alternatives like fire-and-forget with wait:false. Also hints at fallback to openfinance_get_item_status for timeout cases.

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, and non-destructive. Description adds real-time behavior, structured warning on CREDIT error, and response shape—greatly exceeds annotation baseline.

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 covering purpose, usage constraint, error handling, and response shape. No filler, 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?

With one required parameter, no output schema, and clear annotations, the description fully explains input, behavior, error cases, and output structure—complete for this 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 0%, so description must compensate. It adds that account_ids is an array with a 1–50 size limit, which is not in the schema. This meaningfully clarifies usage 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 it returns real-time balance for an account ID, specifies HTTP endpoint, and distinguishes from sibling list tools by focusing on balance payload.

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 input constraint (array of 1–50 IDs) and error handling nuance for CREDIT accounts, but does not explicitly state when to use versus sibling tools or when not to 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?

Beyond annotations (readOnlyHint, idempotentHint), the description adds critical context about provider_incident blocks and data unreliability, warning not to present them as real.

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, front-loaded with purpose, and every sentence adds value without fluff.

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

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

Given no output schema, the description mentions batch shape and provider incident but lacks full return object structure, which would be helpful for a tool with one parameter.

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 0% schema coverage, the description explains the account_ids parameter as an array with a 1-50 constraint, but could clarify the value format (e.g., account ID strings).

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 returns full account objects with extended creditData by account IDs, distinguishing it from sibling tools like openfinance_list_accounts and openfinance_get_account_balance.

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

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

It specifies to pass account_ids as an array of 1-50 items, but does not explicitly provide when-not-to-use or alternative tool recommendations.

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 idempotentHint=true. The description adds critical behavioral details: that payments[] reflect payments registered during this bill's cycle (typically previous bill payment), and that Pluggy does not return a paid/status field. This goes 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?

The description is well-structured: front-loaded summary, then details on included fields, exclusions, usage steps, and important caveats. Every sentence is necessary and adds value. 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?

Without an output schema, the description explains the batch shape ({ results, errors }) and lists the returned fields. It also addresses common misunderstandings (payments relationship, lack of paid status) and provides cross-reference to a superior tool for paid status. Fully complete for the tool's complexity.

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

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

The only parameter (bill_ids) has no description in the input schema (0% coverage). The description explains it is an array and advises using openfinance_list_credit_card_bills to discover IDs, adding meaning beyond the schema. However, it could more explicitly state the format (e.g., array of strings from the list tool).

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 bill-level detail for credit card bills by ID, listing specific fields (financeCharges, payments[] with subfields). It explicitly distinguishes what it does NOT return (individual transactions) and suggests the alternative tool.

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

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

The description provides explicit guidance: when to use (to get bill-level detail), when not to use (for itemized transactions, use openfinance_list_transactions), and prerequisites (use openfinance_list_credit_card_bills first to discover ids). It also advises on interpreting payments[] for paid status.

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, non-destructive. Description adds that it returns status, executionStatus, and connector metadata, and explains collective vs single-entity behavior. 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?

Two sentences, front-loaded with key verb and resource, no wasted words. Efficiently communicates core functionality and usage variations.

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

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

Given low complexity (1 param, no output schema), the description sufficiently covers input behavior and output shape. Could add more detail on executionStatus values or metadata, but current info is adequate for a status-check 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 0% schema description coverage, the description fully explains the 'item' parameter: omitting returns all banks with count/items, passing returns single bank. This adds essential meaning beyond the schema's minimal type declaration.

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

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

Description clearly states it returns bank connection status with example values (UPDATED, UPDATING, LOGIN_ERROR), and distinguishes between omitting 'item' (all banks) vs passing 'item' (single bank). This is specific and differentiates from siblings like openfinance_list_connections.

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 omit or include the 'item' parameter, providing clear usage context. No direct alternative or when-not-to-use mentioned, but the guidance is adequate for selecting the 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds significant behavioral context beyond annotations: explains response aggregation, the `provider_incident` block, credit balance interpretation, and the `creditData` fields for billing cycles. This depth justifies a score above baseline.

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 every sentence adds value. It front-loads the main purpose and then details parameters, edge cases, and cross-references. Slightly long, but efficient for the complexity covered.

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

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

Given the tool's complexity (two optional parameters, rich response with nested fields, sibling competition, provider incident handling, credit nuances), the description is remarkably complete. It covers return fields, parameter behavior, edge cases, and links to the appropriate sibling tool, compensating fully for the lack of an output schema.

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

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

Schema description coverage is 0%, so the description must compensate. It fully explains both `item` (target a single bank or omit for all) and `type` (filter by BANK/CREDIT), and describes how the response structure changes based on `item`. This adds substantial meaning beyond the schema's basic types.

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 accounts for a bank connection, listing BANK and CREDIT types with detailed fields. It distinguishes from siblings by explaining that omitting `item` aggregates all banks, while passing `item` targets a single bank, and explicitly references `openfinance_list_credit_card_bills` for standardized bill amounts.

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

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

The description provides explicit guidance on when to omit vs. pass `item`, warns about the connector-dependent meaning of CREDIT `balance`, advises against treating it as 'this month's bill', and cautions about unreliable data during provider incidents. It also directs users to a sibling tool for standardized credit card bills.

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 and idempotentHint, making the safety profile clear. The description adds behavioral details beyond annotations: it is cached for the adapter session and returns a single aggregated response with no batch ids. This adds useful context without contradiction.

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, each serving a distinct purpose: first stating the function and caching, second listing the return fields and their significance. No extraneous words, and the structure leads with the primary 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?

Despite the lack of an output schema, the description thoroughly explains the return value structure, including field usage (id for update) and language preferences. It also mentions caching behavior, making it complete for an agent to use the tool 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 tool has no parameters, so the input schema requires no explanation. The description compensates by detailing the output fields (id, description, descriptionTranslated, parentId, parentDescription), which adds meaning beyond the empty schema. A baseline of 4 is appropriate given zero 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 the tool returns Pluggy's transaction category taxonomy, naming the specific API endpoint (GET /categories). It distinguishes from siblings by indicating it's a taxonomy listing, not a transactional operation, and references a related sibling (openfinance_update_transaction_category) to show the connection.

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 implicit guidance by explaining the fields, especially that `id` is used by openfinance_update_transaction_category, suggesting when to use this tool (before updating transactions). However, it does not explicitly state when not to use it or contrast with alternatives, leaving a minor 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds value by detailing returned fields and the special add_connection_url, which is beyond the 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 sentence that efficiently conveys the purpose and key details without any superfluous information.

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

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

Given no output schema and zero parameters, the description adequately covers the return format. However, it could mention if the list is paginated or 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?

There are no parameters, so the description compensates by explaining the output structure, which adds meaning beyond the empty 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 'Returns the saved bank connections for this install' with specific fields listed, and distinguishes from other list tools by focusing on bank connections.

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 saved connections but does not provide explicit guidance on when to use versus alternatives like authenticate or connect. However, the context is clear enough.

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

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

Adds significant behavioral context beyond readOnlyHint/idempotent hints: explains derived payment_status logic, connector asymmetry, warning behavior when product not enabled, and the complex payment cycle alignment. 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?

Dense but not excessively long; every sentence adds value. However, the information could be more structured (e.g., bullet points for payment_status logic). Front-loaded with key output 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?

Covers all aspects: return fields, derived status, opt-in behavior, connector limitations, edge cases like PAST_DUE_UNCONFIRMED, and links to related tools. No output schema exists, so description fills the gap thoroughly.

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 0%, so description must compensate. It explains include_open_bill and account_ids in detail, but does not describe page, page_size, or the required account_id beyond context. Partial compensation; pagination parameters are undocumented.

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

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

The description explicitly states it 'Returns CLOSED credit card bills for a CREDIT-type account' and lists the fields, clearly distinguishing it from sibling tools like openfinance_get_credit_card_bill (single bill) and openfinance_list_transactions (itemized purchases).

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 comprehensive guidance: when to use (closed bills), when to opt-in include_open_bill, explains payment attribution semantics, warns against assuming payment status from payments array, and explicitly names alternatives (e.g., openfinance_list_transactions for itemized purchases).

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, idempotentHint, destructiveHint. The description adds context about error handling (returns {total:0, results:[], warning} instead of throwing) and the variety of fields returned (balance, rates, dueDate, etc.), enhancing transparency 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?

The description is front-loaded with the core purpose and lists relevant investment types and fields. It is fairly verbose but each sentence adds value; however, it could be slightly more concise by grouping similar 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 4 optional parameters and no output schema, the description explains the output structure (total, results, warning) and many fields, but lacks parameter documentation. The error behavior and field coverage are helpful, but parameter semantics are missing.

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 0%, yet the description does not explain any of the four parameters (item, page, type, page_size). It only describes output fields. This is a significant gap; the description should clarify parameter usage and constraints.

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 investment portfolio data for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.) and fields. It distinguishes from sibling tools like openfinance_list_accounts or openfinance_list_transactions by focusing on investments.

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 investment portfolio data) and includes error behavior (returns a warning structure). However, it does not explicitly mention when not to use it or compare to alternatives like openfinance_list_investment_transactions.

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 detailed return fields (e.g., expenses breakdown) and bulk support. Annotations already declare readOnly and idempotent; description adds meaningful context about data content without contradicting.

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 succinct paragraphs: first paragraph defines purpose and output, second adds usage guidance and bulk support. Information is front-loaded and 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?

Given the tool's complexity (4 params, no output schema) but rich annotations, the description covers core functionality, return data, and usage flow. Pagination is assumed but not detailed; overall adequate for correct invocation.

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

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

With 0% schema description coverage, the description explains investment_id and investment_ids parameters, including the prerequisite for investment_id. However, page and page_size are not mentioned, leaving some gap.

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 movement history for an investment position, listing specific transaction types and fields. It distinguishes itself from sibling tools like openfinance_list_investments by indicating the prerequisite.

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 instructs to use after openfinance_list_investments to obtain investment_id. Provides usage context but does not enumerate when not to use or discuss alternatives beyond the single sibling.

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, non-destructive behavior. The description adds useful behavioral traits: sequential fetching with rate-limit spacing and return structure '{ results, errors }' per connection.

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 redundant words. First sentence states action and endpoint; second sentence explains parameter usage and behavior. Front-loaded 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?

The description covers parameter usage, behavioral traits (rate-limiting, sequential), and basic return structure. For a single-parameter list tool without output schema, it is fairly complete, though result fields are not detailed.

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 0% schema description coverage, the description fully compensates by explaining that 'items' is an array of connection selectors (item_id uuid, connector_id, or connector_name) and that one entry maps to one connection.

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 'Lists loan contracts per bank connection (GET /loans)', specifying the verb (list), resource (loan contracts), and scope (per bank connection). It distinguishes from sibling list tools by focusing on loans.

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

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

The description provides explicit guidance on when to pass or omit the 'items' parameter, and explains sequential querying with rate-limit spacing. However, it does not directly compare usage to sibling list 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 readOnlyHint=true and idempotentHint=true, but description adds extensive behavioral details: pagination behavior (auto vs manual, up to 5000 ceiling, truncated warning), error handling (returns error block instead of throwing), detail levels (compact/rich/raw) with token impact, PENDING/POSTED variance per connector, provider_incident block, and bulk support via account_ids. 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 long but justifiably so given the tool's complexity (8 parameters, multiple edge cases, sibling differentiation). It is front-loaded with the main purpose and most critical differentiator. Some minor redundancy exists (e.g., repeating the auto-pagination explanation), but overall every sentence provides 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?

Despite no output schema, the description covers return shape (pagination structure, truncated flag, warning/error pattern), detail field contents (creditCardMetadata, merchantInfo), and connections to sibling tools for additional info (dates from openfinance_list_accounts, connection health from openfinance_get_item_status). Addresses provider incidents and bulk execution. Complete enough for effective tool 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 description coverage is 0%, so description fully compensates by explaining every parameter: from/to as ISO dates, page (omit for auto-pagination, explicit for manual), page_size (max 500), account_id (required), account_ids (bulk), search_queries (case- and accent-insensitive substring match, OR semantics), detail (compact/rich/raw with specific behaviors). Adds essential context beyond type definitions.

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 transactions for bank accounts (BANK or CREDIT type). It immediately distinguishes itself for CREDIT accounts as the ONLY way to get itemized transactions, linking to bills via creditCardMetadata.billId. It also contrasts with sibling tools like openfinance_list_credit_card_bills for bill totals and openfinance_list_accounts for dates.

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 usage guidance: for CREDIT accounts, use this for itemized transactions; for bill totals, use openfinance_list_credit_card_bills. Advises checking connection health via openfinance_get_item_status if total is 0 for CREDIT accounts. Clearly differentiates from siblings and gives context on when to use 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 indicate readOnlyHint, idempotentHint, and destructiveHint false, which the description aligns with. Extra context includes the 5000-transactions-per-account cap with truncation flag, and provider_incident block behavior, which adds significant 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?

The description is lengthy and contains some redundancy (e.g., 'you do NOT need to call...'), and uses non-English terms (entradas, saídas). However, it is well-organized with clear sections, earning a middle score.

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 7 parameters, no output schema, and tool complexity, the description covers behavior, parameter semantics, limits, and incidents. It lacks explicit return structure details, but the summary format is described. Overall 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 0%, but the description explains most parameters: item accepts multiple formats, from/to are ISO dates, granularity defaults to monthly, detail options and type filters. top_n is implied via 'largest N' but not fully detailed. Overall, it adds substantial meaning.

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 performs consolidated cash-flow analysis for a bank connection in one call, resolving accounts internally. It distinguishes from siblings like openfinance_list_transactions and openfinance_list_accounts by noting you do not need to call those first.

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

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

The description provides explicit use cases such as 'análise anual/mensal' and 'fluxo de caixa', and clarifies how to adjust granularity for raw rows. It also mentions omitting item to analyze all linked banks. However, it does not explicitly exclude scenarios like single-account analysis.

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, idempotentHint, destructiveHint. The description adds valuable behavioral context: returns global indicator, degraded components, open incidents, and flags incidents affecting connected banks. 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?

Moderately concise; every sentence adds value, though slightly longer than minimal. Well-structured with clear cause, use case, and output details.

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 and no output schema, the description is remarkably complete: it explains purpose, usage guidance, behavioral traits, return value summary, and differentiation from siblings. No 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?

No parameters exist (schema coverage 100% trivially). Baseline 4 per rules; description adds no param info (none needed) but fully explains tool's function.

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 checks the LIVE operational status of the provider, distinguishing it from the sibling tool 'openfinance_get_item_status' by explicitly saying it's the provider's health separate from the user's connection.

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 when-to-use context: whenever data looks incomplete/stale despite a connection showing UPDATED. Explains it reveals upstream outages and known incidents, helping differentiate provider-side problems from connection issues.

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

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

Annotations already mark it read-only, idempotent, non-destructive. The description adds details about returned data, caveat warnings, and plan-based filtering, going well 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?

The description is a single long paragraph but front-loads the purpose and adds value with every sentence. Could be slightly more structured but is not wasteful.

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 fully explains all return fields (connector id, access, audience, linked connections, connect_url) and caveats. It covers plan behavior and usage context, making it 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?

With 0% schema description coverage, the description explains both parameters: keywords with example and required behavior, include_accounts with its effect. It doesn't specify constraints like item types but is sufficient.

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

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

The description clearly states the tool searches bank connectors by name and returns specific fields including a connect_url. It distinguishes from siblings by explicitly calling it a pre-connect step.

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 advises calling this before connecting and explains when to surface caveat warnings. It lacks explicit when-not-to-use or alternative tools, but provides clear usage 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?

The description discloses behavioral traits beyond annotations: it overrides automatic categorization, teaches Pluggy by creating a Category Rule, and details batch error handling ('per-item errors do not fail the whole batch'). 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 dense and well-structured, starting with the main action, then parameters, side effect, and response shape. Slightly lengthy but every sentence provides 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?

The description provides a complete picture despite no output schema: sample response shape, side effects, and error handling. The agent has enough information to use the tool 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?

With 0% schema description coverage, the description fully compensates by explaining the items array contains objects with transaction_id and category_id, including their sources. This adds meaning beyond the raw 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 corrects transaction categories, specifies the HTTP method (PATCH /transactions/:id), and distinguishes itself from sibling tools by referencing specific IDs from openfinance_list_transactions and openfinance_list_categories.

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 ('fix miscategorized transactions'), explains the side effect of creating a Category Rule for future similar transactions, and instructs where to obtain required IDs. It does not mention when not to use or list alternatives, but context from sibling tools 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?

Annotations already indicate idempotentHint=true and destructiveHint=false, so the tool is safe and non-destructive. The description adds the behavioral hint of including conversation for reproduction, but does not disclose any additional traits like rate limits or data handling.

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 with two sentences, no redundant information. It efficiently communicates purpose and a key usage guideline.

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 bug reporting tool without an output schema, the description is reasonably complete. It covers the purpose and a key input requirement. It could mention the expected response or effect, but given the straightforward nature, this is adequate.

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 0% schema description coverage, the description must compensate but only mentions the 'conversation' parameter, partially explaining its purpose. The 'context' and 'message' parameters are not described, leaving ambiguity.

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 reports bugs, missing features, or feedback, which distinguishes it from sibling tools that focus on authentication, API connections, or financial operations. However, it lacks specificity on the reporting mechanism or resulting actions.

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

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

The description provides a guideline to include the conversation array for reproduction, which helps the agent provide useful context. It does not explicitly state when not to use it, but the clear purpose implies appropriate usage given no similar 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 readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds that it shows version information, but no further behavioral traits (e.g., output format) are disclosed.

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 front-loading the purpose. No wasted words; every part earns its place.

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

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

For a simple version tool with no parameters and no output schema, the description is sufficiently complete. It could optionally mention output format or structure, but the core purpose is clear.

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, and schema description coverage is 100% (vacuously). The description does not need to add parameter details, so baseline score 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?

Clearly states the tool shows current MCP platform and adapter versions. It uses a specific verb and resource, distinguishing it from sibling tools like authenticate or connect which serve different purposes.

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 versus alternatives. It is a simple info tool, but the description does not provide context about preferred usage scenarios or any 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds detail about the returned state (MCPs, connection status, catalog counts) but does not disclose additional behavioral traits beyond what annotations provide. 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?

A single sentence that is front-loaded with the action 'Returns' and precisely describes the output. No filler or redundant content.

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 explains the return value completely for a simple informational tool: installed MCPs, connection status, catalog counts. No output schema exists, so description bears the full burden and succeeds.

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 tool has zero parameters and schema coverage is 100%. Baseline for 0 parameters is 4. Description does not need to add parameter information.

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 'current toolkit state: installed MCPs, their connection status, and how many catalog tools each exposes.' This is a specific verb+resource with distinct scope, differentiating it from siblings which are about authentication, data retrieval, or bug reporting.

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 suggests use when needing an overview of MCP installations and connectivity. No explicit when-not or alternatives are provided, but the context (sibling tools like authenticate, connect) makes it clear this is a diagnostic/informational tool.

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