Banco Mercantil MCP

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

The description explains the outcome of calling with or without a token, and the difference between permanent config-based and session-based login. However, it does not mention idempotency (though annotated) or security implications of handling tokens. Overall, it adds useful behavioral context 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 somewhat verbose but well-structured: it starts with the tool's purpose, then explains the two usage methods. Every sentence adds value, though it could be slightly more concise.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description covers all necessary context: the two authentication methods, the parameter usage, and the fallback to getting a link. No additional information is needed 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?

The input schema has 0% description coverage, but the tool description compensates fully by explaining the token parameter: it should be a JWT pasted by the user for session login, and that calling without the parameter returns a login link. This adds essential meaning to the parameter.

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

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

The description clearly states the tool's purpose: authenticating a user via browser login and token. It specifies both a permanent configuration-based method and a session-based method with a token parameter. The purpose is specific and distinct from siblings which cover different functionalities.

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

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

The description provides explicit usage guidance: using the config header for a permanent connection, or passing a token for session-only login, or calling with no arguments to get the login link. This helps the agent decide between parameter values and modes of 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 already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds specific behavioral context (e.g., authenticated, pending, connect_url) beyond these hints.

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

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

Two concise sentences that front-load the main purpose and provide necessary conditional details. No wasted words.

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

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

For a parameterless tool with such annotations, the description covers all needed information, including return values under different states.

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

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

The input schema has no parameters, so baseline is 4. The description adequately explains the tool's behavior without needing param details.

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 connection status and URLs, and specifies different outputs for connected vs. missing credentials. This distinguishes it from sibling tools like authenticate or provider_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 when to use (to check connection status) but does not explicitly state when not to use or list alternative tools. However, the context of sibling tools provides clarity.

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

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

The description adds rich behavioral context beyond annotations: invoke works even without installing MCP, returns connect/checkout links for missing credentials or payment, and one-off install behind invoke. It explains write operations require owner/admin. No contradiction with annotations (readOnlyHint=false is consistent with writes).

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 with information but runs long (multiple sentences). It front-loads the primary purpose but then lists many action details in a paragraph. Could be restructured with bullet points or clearer separation of concepts, but every sentence does add 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 (13 parameters, no output schema, multiple actions), the description covers the core workflow, key distinctions (invoke vs install), permission requirements, and expected behavior for missing credentials/payment. It lacks explicit return format details but otherwise feels comprehensive for agent 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?

Despite 0% schema description coverage and 13 parameters, the description only indirectly explains the 'action' parameter via the core flow (search → describe → invoke). Other parameters like limit, query, mcp_id, tool_id, arguments, etc., are not explained. While the action enum is clarified, individual parameter semantics are largely absent, failing to compensate for the schema 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 explicitly states the tool as the official marketplace catalog and execution platform, and distinguishes it from external registries and sibling tools like authenticate or report_bug. It provides a specific verb-resource mapping for multiple actions (search, describe, invoke, etc.) and clearly differentiates from other tools via context.

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

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

The description provides explicit when-to-use guidance: 'When the user wants a capability... use THIS tool FIRST'. It also explains when to prefer invoke over install, when writes require workspace owner/admin, and distinguishes between one-off and permanent usage. This fully enables correct tool selection.

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 destructiveHint=true. The description adds context about data deletion and return of add_connection_url, which is transparent beyond the baseline. 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?

Two concise sentences, front-loaded with the primary action and consequence, then additional return value. 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?

For a simple destructive tool with one parameter and no output schema, the description covers the action, outcome, and return value. However, the missing parameter description is a notable gap, preventing full completeness.

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

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

The description does not explain what the 'item' parameter represents (e.g., bank ID or connection ID). Schema coverage is 0%, so the description fails to add meaning to the parameter, despite being the only required field.

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 consent, deletes connection data, and returns a reconnection URL. It distinguishes from siblings like 'connect' and other openfinance tools by explicitly mentioning disconnection.

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 disconnecting a bank but does not provide explicit when-to-use or when-not-to-use guidance, nor mention alternatives beyond the existence of a connect 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?

The description discloses key behavioral traits: it does a PATCH, polls until completion (up to 60s), returns final status and error states (needs_action, timed_out). It also explains the effect of setting wait:false. This goes well beyond the annotations and provides full transparency.

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

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

The description is fairly long but well-structured, front-loading the primary action and then covering details. Every sentence adds value, though slightly tighter wording could improve conciseness.

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

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

Given two parameters, no output schema, and the tool's async nature, the description covers all necessary aspects: what it does, parameters, return values, error states (needs_action, timed_out), and usage variations. It is fully complete.

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

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

With 0% schema coverage, the description fully explains both parameters: 'items' is described as an array of selectors (item_id, connector_id, or connector_name) and that omitting it syncs all; 'wait' is explained as fire-and-forget mode. This adds critical meaning beyond the schema 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 that it forces a re-sync of one or more connections and waits for completion. It specifies the verb 'forces sync', resource 'connections', and distinguishes from siblings by focusing on syncing rather than listing or getting 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 explicitly says when to use ('when a balance or transaction list looks stale') and contrasts with alternatives (not needing to disconnect/reconnect). It also explains how to use parameters and the fire-and-forget mode. It does not explicitly state when not to use, but the guidance is clear.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds the real-time nature of the response, specifies that credit account errors produce a structured warning instead of throwing an exception, and outlines the response shape. This adds value beyond annotations and provides full transparency for the tool's behavior.

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

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

The description is extremely concise: two sentences plus a brief response shape example. Every sentence adds value—no fluff, no repetition of schema fields. The structure front-loads the main action and then provides constraints and error handling, making it efficient for an AI agent to parse.

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

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

The description covers the core behavior (real-time retrieval), constraints (array size), error handling (credit accounts), and response shape. It does not mention authentication prerequisites or performance characteristics, but given the lack of output schema and simple parameter set, it is fairly complete. A small gap: it could note that the account IDs must come from a prior list operation.

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 the description must compensate. It explains that account_ids is an array with a length constraint of 1-50, which adds meaning beyond the raw schema. However, it does not specify the format of each ID (e.g., string length, origin), which would further improve semantics. Still, given the constraint, it's a useful addition.

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

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

The description clearly specifies the tool returns real-time balance for account IDs, names the exact HTTP endpoint, and distinguishes from sibling tools like openfinance_list_accounts or openfinance_get_accounts_detail by its specific focus on balance retrieval. This provides strong purpose clarity.

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 practical usage guidance: pass account_ids as an array with a size limit of 1-50, and warns about CREDIT accounts potentially returning a warning error. It does not explicitly compare to alternatives, but the domain is narrow enough that the guidance is sufficient for correct invocation. However, it could mention when to prefer this over other account-related 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 indicate read-only, idempotent, non-destructive behavior. The description adds valuable context about the response shape (batch with results and errors) and the inclusion of extended creditData, going beyond what annotations provide.

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

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

Two sentences: first states purpose and key data, second gives usage instructions and response format. No redundant information, every sentence is essential.

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 parameter, no output schema), the description adequately covers what it returns and how to use it. Missing examples or clarification on ID format, but sufficient for most agents.

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 the constraint of 1–50 items to the account_ids array, but does not explain the format or origin of the strings. This adds some meaning but could be more comprehensive.

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 full account objects with extended creditData for specific account ids. It distinguishes from sibling tools like openfinance_list_accounts by focusing on detail retrieval for individual accounts.

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 passing account_ids as an array with a size limit of 1–50, providing clear usage context. However, it does not explicitly mention when not to use this tool or suggest alternatives like list_accounts for broader 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?

Annotations already declare readOnlyHint=true and idempotentHint=true. Description goes beyond by explaining the batch shape ({ results, errors }), noting the absence of a paid/status field, and clarifying the meaning of the payments array. 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 thorough but somewhat lengthy. Key information is front-loaded, and every sentence adds value. Minor redundancy could be trimmed, but overall well-structured.

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

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

Despite no output schema, the description details return fields (financeCharges, payments with subfields) and limitations (no paid status, payments meaning). It also explains relationships with other tools, making it complete for a 1-parameter 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?

Only one parameter (bill_ids) with 0% schema coverage. Description explains that it's an array, how to obtain IDs from the list endpoint, and mentions the batch result shape. Could add more details about ID format but is sufficient for correct usage.

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

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

The description clearly states the tool returns bill-level detail for credit card bills by ID, specifying included fields (financeCharges, payments) and explicitly distinguishing from sibling tools like openfinance_list_transactions and openfinance_list_credit_card_bills.

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 guidance on when to use this tool: for bill-level detail, not for itemized transactions. Recommends using openfinance_list_credit_card_bills first to discover IDs, and points to openfinance_list_transactions for transactions. Also advises checking paid status via the list endpoint instead of this one.

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, and destructiveHint=false. The description adds useful behavioral context by specifying the return format for both modes (response shape, status types, connector metadata) and the effect of omitting vs passing the parameter. 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 long, front-loaded with the main purpose, and every sentence adds essential information. 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 no output schema, the description adequately explains the return values (statuses, executionStatus, connector metadata, and the wrapping objects). It could be more detailed about the exact response fields, but it is sufficient for usage.

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

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

The input schema provides only the 'item' parameter with no description (0% coverage). The description fully explains its semantics: omitting returns all banks, passing returns a single bank, thus compensating completely for the schema 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 it returns the current status of a bank connection with specific verb 'Returns' and resource 'status of a bank connection', enumerates possible statuses (UPDATED, UPDATING, LOGIN_ERROR), and distinguishes between omitting and passing the 'item' parameter. This differentiates it 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?

The description explicitly guides when to omit or include 'item': 'Omit item to get the status of ALL linked banks... pass item for a single bank.' This provides clear context, though it does not explicitly mention when to use alternatives or when not to use 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 indicate readOnlyHint=true and idempotent. The description adds context about `balance` being connector-dependent, clarifies that `name` is legal entity not brand, and explains return structure per account.

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 but well-structured: purpose first, then field explanations, usage patterns, and warnings. Slightly long but each sentence adds value; could be trimmed slightly but still effective.

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

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

Given no output schema, the description explains the return fields and structure thoroughly (e.g., per-account fields, root-level vs array-level tags). It also covers special cases like credit card balance interpretation.

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 compensates by explaining when to use `item` and its effect on response aggregation. The `type` parameter is self-explanatory from schema, but description implies its filtering role.

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 with specific fields (balance, number, type, etc.) and distinguishes between BANK and CREDIT types. It also differentiates from sibling tool openfinance_list_credit_card_bills by stating what that tool provides.

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

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

The description gives explicit guidance on when to omit `item` (list all banks) vs pass it (target single bank). It also warns that `balance` meaning is connector-dependent and directs to openfinance_list_credit_card_bills for standardized amounts.

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, and destructiveHint=false. The description adds valuable behavioral context: the result is cached for the adapter session, and the response is a single aggregated object. This goes beyond annotations without contradicting 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?

The description is three sentences, front-loaded with the core purpose, and every sentence adds essential information. 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 zero parameters and no output schema, the description fully explains what the tool returns, including caching behavior and how the ids relate to another tool. It is complete for effective use.

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

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

The input schema has no parameters, so schema description coverage is 100%. The description compensates by explaining the output structure in detail (id, description, descriptionTranslated, parentId, parentDescription). Baseline 4 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 that the tool returns Pluggy's transaction category taxonomy, cached for the adapter session. It specifies the structure of entries (id, description, descriptionTranslated, parentId, parentDescription) and connects it to another tool (openfinance_update_transaction_category). This is highly specific and distinguishes it from sibling tools.

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

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

The description implicitly indicates when to use the tool (when needing category taxonomy) and provides a usage note about single aggregated response with no batch ids. It does not explicitly state when not to use it or list alternatives, but given the lack of related sibling tools, the guidance is adequate.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds the return fields but does not mention potential behavioral traits like rate limits, pagination, or authentication requirements.

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-loaded with the verb 'Returns', no unnecessary words. Perfectly concise for a simple tool.

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

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

Given no output schema and no parameters, the description adequately explains what the tool returns. It is complete for the tool's simplicity and aligns with annotations.

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 zero parameters and 100% schema coverage, the baseline is 4. The description adds value by enumerating the returned fields (connector_id, item_id, bank name, add_connection_url), which is crucial for an agent to understand the output structure.

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 saved bank connections and lists specific fields (connector_id, item_id, bank name, add_connection_url). This distinguishes it from sibling tools like openfinance_list_accounts or openfinance_list_transactions.

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. While the context of 'saved bank connections' implies it is a preliminary step, the description does not mention exclusion criteria or alternative tools for related tasks.

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 provide readOnlyHint and idempotentHint. The description adds significant behavioral context: payment mapping logic, derived payment_status, connector asymmetry, and warning behavior on missing CREDIT_CARDS product.

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?

While the description is well-structured with paragraphs, it is overly long and verbose. It could be more concise without losing essential information.

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

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

Despite the complexity (no output schema, many parameters), the description is highly complete, covering payment semantics, derived fields, connector issues, and cross-tool references. Missing only explicit param descriptions for pagination.

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

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

Schema description coverage is 0%. The description explains include_open_bill and account_ids but does not describe page, page_size, or the required account_id directly. Some compensation but incomplete.

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 closed credit card bills for a CREDIT-type account, lists key fields, and distinguishes from sibling tools like openfinance_get_credit_card_bill and openfinance_list_transactions.

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 (e.g., for bill summaries) versus alternatives (e.g., use openfinance_list_transactions for itemized purchases). It also explains when to use include_open_bill and warns against using the CREDIT account's balance.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral context by specifying that the tool returns a graceful response ({total:0, results:[], warning}) instead of throwing on 403 or other errors, which 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 concise with two sentences covering purpose and error handling. It is front-loaded with the main purpose and asset types. Could be slightly more structured (e.g., separate parameter details), but overall efficient.

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

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

Given 4 parameters, no output schema, and many siblings, the description is moderately complete. It lists returned fields and error handling but omits parameter details (especially 'item') and a full return structure. Pagination via page/page_size is mentioned in schema but not in 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?

The input schema has 4 parameters (item, page, type, page_size) with 0% schema description coverage. The description does not explain any parameter, leaving 'item' ambiguous and pagination behavior undocumented. Parameters require deduction from names, which is insufficient.

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 an investment portfolio for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.) and key fields. It distinguishes itself from sibling tools like openfinance_list_accounts by focusing solely 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 implies usage for retrieving investment portfolios but does not explicitly state when to use this tool vs. siblings like openfinance_list_accounts or openfinance_list_transactions. It mentions error handling but lacks exclusion criteria.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false, so tool safety is clear. Description adds valuable behavioral context: lists transaction types, fields returned, and batched execution. No contradiction with annotations. Could mention pagination behavior but not a major gap.

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

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

Two concise paragraphs with no wasted words. First paragraph details purpose and return fields, second paragraph adds bulk support. Efficient and front-loaded.

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

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

Without output schema, description adequately describes returned fields and transaction types. However, it does not cover pagination behavior for page/page_size parameters, and no mention of error conditions or limits. For a tool with 4 params and 0% schema coverage, more completeness 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?

Schema has 4 parameters with 0% description coverage. The description explains investment_id and investment_ids usage, but completely omits page and page_size. This is a significant gap, leaving two parameters 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 clearly states it returns movement history for a specific investment position, lists transaction types (BUY, SELL, etc.) and key fields. It distinguishes itself from sibling tools like openfinance_list_investments (which lists investments) and openfinance_list_transactions (general transactions).

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 'Use after openfinance_list_investments to get the investment_id', providing a clear prerequisite. It also mentions bulk support with investment_ids. However, it does not explicitly state when not to use this tool or compare with alternatives.

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

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

Annotations already indicate readOnlyHint=true, destructiveHint=false, idempotentHint=true; description adds behavior about sequential execution and rate-limit spacing, plus return format per connection. No contradictions, and the description provides useful context 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?

Three sentences cover purpose, parameter details, and behavior. Front-loaded with key information, no redundancy, 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 one optional parameter, no output schema, and no nested objects, the description is largely complete: it explains parameter semantics, optionality, multiple connection handling, and return structure. Minor omission is not detailing the exact shape of 'results' and 'errors', but acceptable without 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?

The input schema only defines 'items' as an array of strings with no description (0% coverage). The description clarifies that each element should be an item_id uuid, connector_id, or connector_name, which is essential for correct usage. This compensates for the schema 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?

Description explicitly states it lists loan contracts per bank connection, specifies the endpoint, and distinguishes between fetching for specific connections (using 'items') versus all connections (omitting 'items'). This is specific and differentiates from sibling tools like list_accounts.

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

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

The description explains when to pass 'items' (for specific connections) and when to omit it (for all banks). It also notes that multiple connections are queried sequentially with rate-limit spacing, providing context on usage behavior. However, it doesn't explicitly compare to similar tools like openfinance_list_credit_card_bills, which is 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?

The description discloses important behavioral traits: how CREDIT PENDING vs POSTED varies by bank, error handling returning warning/error instead of throwing, truncation behavior when search_queries is set, and bulk support. This goes beyond annotations (readOnlyHint, idempotentHint) by adding context about upstream variation and return format.

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 but packed with valuable information. It is well-structured with distinct sections for credit card specifics, filtering, error handling, and bulk support. Every sentence adds value, though it could be slightly more concise.

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

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

The tool has 7 parameters and no output schema, but the description covers all aspects: return format (total, results, warning, error), edge cases (truncation), error recovery (check connection health, force sync), and cross-references to siblings. It is comprehensive for a complex financial data 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 compensates by explaining the from/to (ISO YYYY-MM-DD), page_size (max 500), search_queries (case- and accent-insensitive substring match, OR semantics, aggregates up to 5000), and bulk account_ids. However, it does not explicitly explain the 'page' parameter beyond implying pagination, and 'account_id' is only inferred as singular.

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 transactions for bank accounts of type BANK or CREDIT, and distinguishes the use case for CREDIT accounts as the only way to get itemized transactions. It also differentiates from sibling tool openfinance_list_credit_card_bills by explaining when to use each.

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 (e.g., for credit card itemized transactions) and when to use alternatives (e.g., openfinance_list_credit_card_bills for standardized open bill total). It also explains how to handle truncation, check connection health, and use bulk support.

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, destructiveHint, idempotentHint), the description discloses behavioral traits: scanning caps at 5000/account with a truncated flag, internal account resolution, and compact vs. raw output. This adds substantial value beyond structured fields.

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 information-dense yet well-structured, front-loading the main purpose. Every sentence adds value, and the use of examples and formatting makes it easy to parse. It is concise for the complexity involved.

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 lack of an output schema, the description thoroughly explains the return structure (e.g., total entradas, saídas, por_mes, top_despesas, by_account, truncated flag) and the effect of granularity and type. This provides a complete picture for a complex 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 coverage, the description explains most parameters (item, from, to, granularity, type) in detail. However, the top_n parameter is only implied through 'largest N each' in the output description, not explicitly named or explained, leaving a minor 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's purpose: 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call.' It distinguishes from siblings by noting that it avoids the need to call openfinance_list_accounts first and resolves accounts internally.

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 (análise anual/mensal, fluxo de caixa, maiores gastos/recebimentos) and when to omit the item parameter for all banks. It also advises setting granularity to raw only when itemized rows are needed, implying a lighter alternative.

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 details: it checks a public status page, returns specific fields (global indicator, degraded components, incidents), and flags incidents affecting the user's connected banks in 'your_banks_affected'. 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 three sentences long, front-loaded with the main purpose and key distinction. It packs significant value (use case, outputs, benefit) without excess. Minor tightening could remove the parenthetical in the first sentence, but overall it earns its length.

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 return values: global indicator, degraded components, open incidents, and 'your_banks_affected'. It also covers the exact scenario for use and the benefit of distinguishing provider vs. connection issues. Complete for a parameterless read tool.

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

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

There are zero parameters, and schema coverage is 100% trivially. Per rules, baseline is 4 when no parameters. The description does not add parameter-level detail, but none is needed. It provides context for the tool's operation without referencing 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 checks the LIVE operational status of the Open Finance provider, using a specific verb and resource. It explicitly distinguishes from sibling tool 'openfinance_get_item_status' by noting it checks provider health vs. own connection, setting it apart definitively.

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

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

The description provides explicit when-to-use guidance: when data looks incomplete/stale despite an updated connection, revealing upstream outages. It names a sibling alternative but could be more explicit about when not to use (e.g., when checking own connection), though the context is clear.

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

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

Annotations declare readOnlyHint, idempotentHint, destructiveHint. Description adds crucial behaviors: honors user's plan (PF hides PJ banks), keywords are required else returns hint, never dumps whole catalog. 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?

Description is relatively long but every sentence adds value. Front-loaded with main action. Could be slightly more concise, but remains efficient 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?

No output schema, but description thoroughly explains return fields: connector id, access, audience, linked connections/accounts, and connect_url. Also covers plan filtering and hint behavior. Complete for the tool's purpose.

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 description compensates fully: explains keywords is an array of strings (e.g., ['nubank','btg']), states it's required and behavior without it, and clarifies include_accounts controls whether accounts are returned. Provides usage example.

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 searches bank connectors by name, returns connector id, access type, audience, linked connections/accounts, and connect_url. Distinguishes from siblings by specifying 'Call this BEFORE connecting' and emphasizing it provides a one-click link for the right bank.

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 call before connecting. Describes behavior without keywords (returns hint). Does not mention when not to use or alternatives, but context from sibling tools implies its role as a search step.

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 non-read-only and non-destructive. Description adds critical side-effect of creating a Category Rule and batch error handling, elevating 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?

Single dense paragraph, but each sentence adds value. Could be slightly more structured (e.g., separate lines for return shape), but 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?

Despite no output schema, describes return format and error handling. Covers key behavioral side-effects, batch processing, and ID source references, making it comprehensive.

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 description fully explains the items array structure, the meaning of transaction_id and category_id, and their origins, compensating 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?

Clear verb 'corrects' and resource 'transaction category'. Distinguishes from sibling tools like listing transactions and 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?

Explains when to use (fix miscategorized transactions) and the automatic rule creation effect. Lacks explicit alternatives or when-not-to-use, but provides helpful context on ID sources.

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 no destructiveness. The description adds context about including conversation for reproduction but does not disclose further behavioral traits (e.g., error handling, rate limits, or backend processing).

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 only two sentences, front-loaded with the core purpose, and every word contributes. No wasted 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?

For a simple tool with no output schema and three parameters (two with defaults), the description covers the main purpose and the critical 'conversation' parameter. However, it omits what happens upon submission (e.g., confirmation) and does not explain the 'context' 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 description coverage, the description adds meaning for the 'conversation' parameter (explaining it should contain recent messages). However, it does not explain 'context' or 'message' beyond their role, leaving gaps. Baseline is low but partially compensated.

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

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

The description uses a specific verb 'report' and identifies the resource ('bug, missing feature, or send feedback'). It clearly states the tool's scope and is distinct from all sibling tools, which are unrelated (e.g., openfinance, authenticate).

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: include the conversation array for reproduction. While no explicit when-not-to-use or alternatives are given, the purpose is straightforward and no similar sibling exists, so the guidance is adequate.

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 provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds minimal behavioral context beyond stating what is shown. No contradictions are present, and the description does not disclose any further behavioral traits (e.g., caching, latency).

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

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

The description is one sentence of 9 words, front-loaded with the action and resource, and contains no extraneous information. Every word is functional and earns its place.

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

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

Given the tool's simplicity (no parameters, no output schema, a straightforward version display), the description is complete. It adequately informs the agent of the tool's purpose without needing additional detail.

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

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

The tool has no parameters, and the schema description coverage is 100%. According to guidelines, 0 parameters yields a baseline score of 4. The description does not need to add parameter information as there are none.

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 shows current MCP platform and adapter versions, using a specific verb (show) and resource (versions). It uniquely distinguishes itself from sibling tools which are mainly about authentication, connection management, or finance operations.

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 context (checking version information) but does not explicitly state when to use or avoid using this tool. However, given its simplicity and lack of parameters, the purpose is straightforward and no exclusions are needed.

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 read-only, idempotent, non-destructive. The description adds useful specifics on what is returned (MCPs, status, count), going 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?

Single sentence, front-loaded with core action, 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?

For a read-only status tool with zero parameters and rich annotations, the description suffices. It explicitly mentions return content, though lacks output format details. Still 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?

No parameters exist, and schema coverage is 100%. Baseline 4 as per guidelines. Description adds no parameter info, but none 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 toolkit state: installed MCPs, connection status, and catalog tools count. It is specific and uniquely distinguishable from sibling tools like authenticate, connect, etc.

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

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

No explicit when-to-use or alternatives, but the description and sibling context make it obvious this is for checking overall state. No misleading guidance.

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