Conta Bemol MCP

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

Discloses behavioral traits beyond annotations: explains that the tool can establish a permanent or session-based connection, and describes the token flow. No contradiction with annotations (idempotentHint=true is consistent with setting a token).

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 redundancy, front-loaded with context, and efficiently conveys all necessary information without excess.

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 authentication tool with good annotations, the description covers purpose, usage modes, parameter semantics, and context completely. No output schema needed; the tool's behavior is fully described.

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?

Though schema coverage is 0%, the description adds meaning to the single optional 'token' parameter by explaining it as a JWT and that omitting it returns a login link. This compensates well, but lacks format details like token 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's purpose: authenticating users via browser login and token. It specifies the context (MCP.AI for IDE agents) and distinguishes itself from sibling tools like connect by focusing on token-based authentication.

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 two methods: adding the token to config for permanent access or pasting it for session-only login. It also explains how to call the tool with or without arguments, giving clear when-to-use instructions.

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 what happens in different scenarios (all connected vs missing credentials), adding value beyond annotations which only indicate read-only and idempotent behavior. 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?

Two sentences, front-loaded with purpose, and each sentence adds unique value. No unnecessary 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, the description completely explains the return values for both cases (connected and missing credentials). Suitable for an agent to understand the tool's output without additional context.

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

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

No parameters, so schema coverage is 100%. Description adds meaning by explaining the output based on state, which is sufficient for a zero-parameter 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?

Clearly states it returns connection status and URLs, distinguishing between connected and missing credentials states. Differentiates from sibling tools like authenticate by focusing on status rather than performing authentication.

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

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

Implies usage for checking connection status, but does not explicitly state when to use vs alternatives. Context from sibling names provides some guidance, but no direct exclusions or alternatives are mentioned.

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=false and destructiveHint=false. Description adds behavioral context: invoke works even when MCP not installed, returns connect/checkout links for auth or payment issues, and writes require owner/admin. Does not contradict 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 quite long and includes many details in a paragraph format. While informative, it could be more concise and better structured (e.g., using bullet points) to improve readability.

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 high parameter count (13), no output schema, and no parameter descriptions in the schema, the description is fairly complete. It covers the core flow, key actions, and edge cases like missing credentials or payment, providing sufficient context 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?

Schema coverage is 0%, so description must compensate. It explains the main parameters like action, mcp_id, tool_id, and arguments by detailing the core flow. While not all 13 parameters are individually described, enough context is given for the key parameters to enable correct use.

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 for discovering and running MCPs/tools. It specifies actions like search, describe, invoke, etc., and distinguishes from sibling tools by explicitly saying to use this tool before any external/generic registry.

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 which action (e.g., 'use THIS tool FIRST' before external registries, prefer invoke over install for one-off usage). Also describes when install is appropriate versus invoke, and mentions that writes require owner/admin.

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 set destructiveHint=true and readOnlyHint=false, and the description adds valuable context: it reveals the consent revocation, data deletion, and the return of a re-connection URL. This goes beyond the annotations and clarifies the permanence and recovery option.

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 concisely convey the action, effect, and a noteworthy return value. No extraneous information, and the key points are front-loaded.

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

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

For a simple destructive tool with one parameter and no output schema, the description covers the purpose, consequence, and return value adequately. However, it lacks parameter explanation, which slightly reduces completeness.

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

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

The schema has 0% description coverage, and the tool description does not explain the required 'item' parameter (likely a bank identifier). An agent has no semantic guidance on what value to provide, which is a significant 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 revokes consent and deletes connection data, with explicit consequences. The verb 'revokes' and resource 'bank connection data' are specific, and the description distinguishes it from sibling tools like openfinance_list_connections or openfinance_force_sync.

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

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

No guidance is provided on when to use this tool versus alternatives, nor are there exclusion criteria or preconditions. The description only outlines the action without contextual decision 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?

Annotations provide basic flags (readOnlyHint=false, destructiveHint=false, idempotentHint=false). The description adds crucial behavioral details: waiting up to 60s, polling until completion, return format with status fields, and the ability to use wait:false for fire-and-forget. 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 relatively long but efficient, front-loading the core action and behavior. Every sentence adds value, though it could be slightly more concise without losing clarity.

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

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

Given no output schema, the description fully explains the return structure ({ results, errors }) and key fields (status, executionStatus, lastUpdatedAt, synced, needs_action, timed_out). It also covers edge cases (timed_out, needs_action) and provides guidance for re-checking. Complete for a sync 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?

Input schema has 2 parameters with 0% schema description coverage. The description fully compensates: explains 'items' as selectors (item_id, connector_id, connector_name), notes omission syncs all, and clarifies 'wait' defaults to true (implied by 'Set wait: false for fire-and-forget'). Adds meaning beyond schema.

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

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

The description clearly states the action: forces a re-sync of bank connections and waits for completion. It specifies the HTTP method (PATCH) and behavior (polls up to ~60s). It distinguishes from siblings like openfinance_get_item_status and openfinance_list_connections by detailing unique functionality.

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: when balance/transaction list looks stale, connection reads UPDATED but is hours old. It states what it does NOT do (no disconnecting/reconnecting) and offers an alternative (openfinance_get_item_status for timed-out cases). While it doesn't explicitly list exclusions, 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?

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds important behavioral details: non-throwing warnings for CREDIT account errors, response shape with results and errors arrays, and real-time nature. This provides significant transparency that the annotations alone do not convey.

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 exceptionally concise: two sentences covering purpose, input array, error handling, and response shape. Front-loaded with the core action and endpoint, every sentence serves a distinct purpose with no redundancy.

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

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

Given the tool has only one parameter and no output schema, the description covers the essential aspects: real-time balance fetch, array input with size limit, error behavior for CREDIT accounts, and response structure. It is nearly complete, though could explicitly confirm batch processing for multiple account IDs.

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 0% description coverage for the account_ids parameter. The description compensates by specifying it is an array (1–50), clarifying the required format and size constraint. This adds meaningful semantic value beyond the raw schema, though it does not explain how to obtain account IDs.

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 real-time balance payload per account id' with a specific endpoint (GET /accounts/:id/balance). It distinguishes effectively from sibling tools like openfinance_list_accounts or openfinance_get_accounts_detail by focusing on balance retrieval and specifying the unique array parameter input.

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 usage context such as passing an array of account IDs (1–50) and handling CREDIT account errors with a structured warning. However, it lacks explicit guidance on when to use this tool over alternatives (e.g., when to use openfinance_list_accounts instead) and does not mention when not to use it.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds context beyond annotations, such as the batch shape `{ results, errors }` and the parameter cardinality constraint (1–50). 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?

Three concise sentences, each adding distinct information: the return type and endpoint, parameter usage with constraints, and response shape. 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 a single parameter and no output schema, the description covers the purpose, parameter details, and response structure. It could further clarify the level of detail compared to list endpoints, but is largely sufficient.

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

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

The schema has 0% description coverage, so the description must compensate. It adds meaning by explaining the `account_ids` array size constraint (1–50) and that it is used per ID. This goes 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 it returns full account objects including extended creditData per ID, using the HTTP verb 'GET'. It distinguishes from sibling tools like openfinance_list_accounts by implying detail-level, but does not explicitly name alternatives.

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

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

The description specifies that the tool requires an array of account_ids and a size limit (1–50), implying usage when specific account details are needed. However, it does not provide explicit guidance on when not to use it or mention alternative tools like openfinance_list_accounts for summary data.

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, and openWorldHint=false. Description adds behavioral context: batch operation returning {results, errors}, notes absence of paid/status field, explains payments[] nuance (payment of previous bill). 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?

Front-loaded with main purpose, then provides necessary caveats and references. Slightly verbose but every sentence adds value. Could be trimmed slightly without losing clarity, 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 no output schema and complexity of batch operation plus nuance about payments and paid status, description is thorough. It covers return shape, limitations, behavioral quirks, and links to related tools for discovery and transactions. No gaps remain.

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

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

Schema has only one required parameter 'bill_ids' with no description in schema (0% coverage). Description fully compensates: explains it's an array of strings, tells how to obtain valid IDs via openfinance_list_credit_card_bills, and mentions batch result shape. Provides complete semantic context beyond schema.

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

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

Clearly states it returns bill-level detail for credit card bills by id, lists specific fields included, and explicitly distinguishes what it does NOT return (individual transactions). References sibling tools for transactions and bill discovery, making purpose unambiguous.

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: for bill-level detail. Gives when-not-to-use: for itemized transactions, use openfinance_list_transactions. Also advises prerequisite step: use openfinance_list_credit_card_bills to discover bill IDs. Includes caveats about payments[] meaning and paid status interpretation.

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 behavioral context like return fields (status, executionStatus, connector metadata) and dual behavior, 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?

Two sentences are concise and well-structured. The first sentence states the return value, the second explains parameter usage. No unnecessary words.

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

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

Given the tool's simplicity (one optional param, read-only, idempotent), the description covers the core behavior and return format adequately. Minor missing details like pagination or defaults are not critical.

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 'item' is fully explained: omitting it returns all banks, passing it returns a single bank. This adds essential meaning beyond the bare schema, compensating for 0% schema coverage.

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

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

The description clearly states it returns the status of a bank connection, lists possible statuses, and specifies the dual behavior for single vs all banks, effectively distinguishing it from sibling tools 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 use the 'item' parameter versus omitting it, providing clear usage context. However, it does not explicitly mention when not to use this tool compared to alternatives, but the purpose 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral context: explains that 'name' is the legal entity, not the brand, and advises using 'bank' for user-facing text; clarifies that CREDIT balance is connector-dependent and should not be treated as 'this month's bill'; and describes the meaning of creditData fields (balanceCloseDate, balanceDueDate). 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 well-structured, starting with the core functionality, then parameter usage, then field clarifications. While every sentence adds value, it is slightly verbose (around 150 words). A more concise version could be equally clear, but the current version is 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 the tool has 2 optional parameters, no output schema, and moderate complexity, the description covers all essential aspects: returned fields, parameter semantics, field meanings and limitations, and cross-references to a sibling tool for credit card billing. It leaves no important gaps for an AI 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?

Schema has 0% description coverage, so the description carries the full burden. It thoroughly explains the 'item' parameter (omit for all banks, pass for a single bank) and the 'type' parameter (BANK or CREDIT with subtypes). It adds critical context not in the schema, like the structure of the response when 'item' is omitted vs passed, and the inclusion of 'bank', 'connector_id', and 'item_id' in each result.

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 bank connections, enumerates the fields (balance, number, type, subtype, bankData, creditData, bank, connector_id), and distinguishes between BANK and CREDIT types. It also explains the 'name' field vs 'bank' field, and how to use the 'item' parameter to target a single bank or omit it for all banks, making purpose unambiguous.

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

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

Explicitly states when to omit 'item' (to list accounts across all linked banks) and when to pass it (to target a single bank). Provides a concrete example: 'use this when the user asks for my accounts/cards without naming a bank'. Also warns about the connector-dependent meaning of CREDIT balance and directs to a sibling tool for standardized billing info, offering clear 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 provide readOnly and idempotent hints. The description adds behavioral details: caching per session, single aggregated response with no pagination, and language options (Portuguese). 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?

Three concise sentences, front-loaded with the main purpose. Every sentence adds value: what it returns, details of output, and note on single response. 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?

Without an output schema, the description fully explains the return structure (fields, language, no batch ids). It also connects to a sibling tool, making it contextually complete for an agent.

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

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

No parameters exist, so baseline is 4. The description adds no parameter info because none are needed, but it explains the output structure well, which is useful for an agent.

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, cached, and details the output fields. It distinguishes itself from sibling tools by linking to openfinance_update_transaction_category and noting no batch ids.

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

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

The description implies usage by stating the categoryId is used by another tool, and mentions caching for fast lookup. However, it does not explicitly state when not to use it or compare to alternatives, but the 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows it is safe. The description adds the specific returned fields (connector_id, etc.) and mentions the add_connection_url, but does not disclose potential edge cases (e.g., empty list) or any side effects 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 two sentences long, front-loaded with the main purpose, and contains no redundant information. Every word is necessary and adds value.

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

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

Given no parameters, no output schema, and a simple list operation, the description is largely complete. It lists the return fields and the role of add_connection_url. However, it could explicitly mention that the list may be empty, and it does not describe the authentication or installation context, which might be inferred from the sibling tools context.

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

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

There are no parameters, so schema coverage is 100%. The description adds context about the returned fields, but since there are no parameters to document, the baseline of 4 is appropriate. The description does not need to compensate for missing schema documentation.

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 saved bank connections and enumerates the specific fields included (connector_id, item_id, bank name, add_connection_url). It uses a specific verb 'Returns' and resource 'saved bank connections', which distinguishes it from sibling tools like openfinance_list_accounts or openfinance_disconnect_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?

The description does not provide guidance on when to use this tool vs alternatives. With 25 sibling tools, including many list tools, there is no context on when to prefer this over openfinance_list_accounts or others. No exclusions or prerequisites are mentioned.

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

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

Annotations indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds substantial behavioral context, detailing the complex payment cycle semantics, the derivation of payment_status, connector asymmetry affecting open_bill availability, and the fact that results are bill-level summaries. 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 comprehensive but verbose (multiple paragraphs). It is well-structured, starting with the main output, then important semantics, opt-in details, connector notes, and sibling comparisons. Every sentence adds value, but conciseness could be improved without losing essential 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 output schema, the description thoroughly explains return fields (dueDate, totalAmount, payments array, payment_status derived logic, open_bill structure). It also covers edge cases like unavailable open_bill, connector asymmetry, and includes a warning for disabled product. The description is 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 description adds meaningful context for include_open_bill (opt-in, effect described) and account_ids (bulk support). However, page and page_size parameters are not mentioned, leaving the user to infer pagination from schema types. With 0% schema coverage, the description partially compensates but could be more thorough.

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 closed credit card bills for CREDIT-type accounts, listing specific fields and derived values. It distinguishes itself from sibling tools like openfinance_list_transactions by explicitly directing users to that tool for itemized purchases, and it mentions the open_bill opt-in as an additionally derived feature.

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 and how to use the tool, including important semantics about payment cycles and the derived payment_status. It warns against misinterpreting the payments array as payment status, advises not to call a bill 'vencida' prematurely, and refers users to openfinance_list_transactions for detailed transactions. It also notes that include_open_bill is opt-in and explains default behavior.

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

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

Annotations already mark it as read-only and idempotent. The description adds behavioral details: it returns a warning object instead of throwing errors when investments are not enabled. 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 two sentences long and front-loads the core function. The first sentence is somewhat lengthy due to listing all asset types, but it is still efficient and avoids unnecessary detail.

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 output schema and moderate complexity (4 parameters), the description covers purpose and error handling but fails to explain parameter usage (pagination, filtering). This leaves gaps for an AI agent trying to invoke 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?

Schema description coverage is 0%, and the description does not explain any of the four parameters (item, page, type, page_size). The description only lists output fields, leaving the agent without guidance on how inputs affect the results.

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

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

The description clearly states the tool returns investment portfolio data for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.) and fields. It uses a specific verb ('returns') and resource ('investment portfolio'), and distinguishes from sibling tools like openfinance_list_accounts 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 context on when to use this tool (for investment data) and includes error handling behavior (returns a specific format instead of throwing on 403). However, it does not explicitly mention when not to use it or suggest alternatives among siblings.

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

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

Annotations indicate read-only, idempotent, non-destructive. Description adds detail on return fields (quantity, value, expenses) and bulk capability. No contradictions, but pagination behavior not explained.

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 front-loaded with purpose and usage. No extraneous text, though could be slightly more structured with bullet points.

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?

Describes return fields in detail, compensating for missing output schema. Mentions usage sequence and bulk support, but omits error handling and pagination specifics.

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% description coverage. Description explains investment_id and investment_ids, but page and page_size are not described, leaving ambiguity despite common 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 it returns movement history for a specific investment position, listing transaction types and fields. It distinguishes from sibling tools like openfinance_list_transactions by specifying investment focus.

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 advises using after openfinance_list_investments to get investment_id, and mentions bulk support via investment_ids. Lacks explicit alternatives or when-not-to-use, but provides clear context.

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 (readOnlyHint, idempotentHint, destructiveHint) already cover safety. Description adds behavioral details: sequential query with rate-limit spacing, returns per-connection results/errors. 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 sentences, no waste. Front-loaded with purpose, then parameter usage, then behavior. Every sentence provides 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?

No output schema, but description explains return structure ({ results, errors } per connection). Covers parameters, usage modes, and behavioral traits. Complete for a simple list tool 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?

Schema has 0% coverage for items, which is just an array of strings. Description clarifies items are connection selectors (item_id, connector_id, or connector_name) and explains omission behavior. Adds critical meaning beyond schema.

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

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

Clearly states it lists loan contracts per bank connection, with specific verb 'lists' and resource 'loan contracts'. Distinguishes between providing items for specific connections vs omitting to list all, which differentiates from sibling list tools (e.g., list_accounts, 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?

Explains when to use items (specific connections) vs omit (all connections). Mentions sequential querying with rate-limit spacing. Could explicitly state when not to use (e.g., use other tools for different resources), but sufficient for a focused 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?

Beyond annotations (readOnlyHint, idempotentHint), the description adds extensive behavioral details: auto-pagination behavior, truncation at 5000 rows, error handling (returns error object instead of throwing), credit card pending/posted variation across banks, and the distinction between detail levels. This provides critical context for safe invocation.

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

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

The description is thorough and well-structured, with clear paragraphs for different aspects (credit cards, pagination, detail levels). It is somewhat verbose but front-loaded with the core purpose. Minor redundancy could be trimmed, but overall it is organized and readable.

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 (8 parameters, no output schema, multiple detail levels, credit card nuances), the description is remarkably complete. It covers error handling, edge cases like truncation and zero total, connection health checks, and cross-references sibling tools. It effectively compensates for the lack of output schema by describing what each detail level returns.

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 all 8 parameters: from/to (ISO format), page (omit for auto-pagination), page_size (max 500, used with page), detail (enum values with trade-offs), account_id (required), account_ids (bulk), search_queries (substring match, OR semantics). It also explains behavior when search_queries is used.

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 transactions for bank accounts, distinguishing it from siblings like openfinance_list_credit_card_bills and openfinance_list_accounts. It specifies the account types and explains the unique role for credit card 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?

Explicit guidance is provided: when to use this tool vs. alternatives (e.g., for credit card itemized transactions, use this; for open bill totals, use openfinance_list_credit_card_bills). It details pagination options, when to check connection health, and the different detail levels. It also advises on narrowing date ranges if truncation occurs.

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

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

The description adds significant behavioral context beyond the annotations. It discloses the 5000/account scan cap and the truncated flag, describes the compact summary output structure (total entradas, saídas, saldo_liquido, por_mes, top_despesas, etc.), and explains the effects of granularity and detail parameters. This aligns with the readOnlyHint and idempotentHint annotations, confirming a safe and idempotent operation.

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-loading the main purpose and key benefit. Each sentence adds value, and the use of bullet-style lists (e.g., `por_mes`, `top_despesas`) improves readability. However, it is somewhat lengthy and could be slightly more concise without losing 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 0% schema coverage, the description thoroughly explains the return format: compact summary fields (total entradas, saídas, etc.), monthly evolution, top expenses, per-account breakdown, and for raw granularity, transaction rows with enrichment options. It also mentions the truncated flag. Although it doesn't detail pagination or top_n limits, it covers the essential aspects for effective tool 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?

With 0% schema description coverage, the description fully compensates by explaining each parameter: item (connector_id/connector_name/item_id or omit), from/to (ISO dates), granularity (monthly/raw), detail (compact/rich/raw), top_n, and type (BANK/CREDIT). It also describes the interaction between granularity and detail, providing meaning far beyond the bare schema.

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

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

The description clearly states the tool's purpose: consolidated cash-flow analysis for a whole bank connection in one call. It specifies that it resolves accounts internally, eliminating the need for separate calls. It lists specific use cases like 'fluxo de caixa' and 'maiores gastos/recebimentos', which effectively distinguish it from sibling tools like 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 explicitly says when to use this tool (for cash-flow analysis, analyzing a whole connection) and when not to (no need to call openfinance_list_accounts first). It explains the difference between granularity modes (monthly vs. raw) and when to use each, including the optional detail parameter for transaction enrichment. It also clarifies that omitting 'item' analyzes all linked banks.

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, and destructiveHint; description adds that it checks a live public status page, returns detailed indicators, and highlights affected banks, without contradicting annotations.

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

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

Single well-structured paragraph, front-loaded with main action and usage advice, though 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 no output schema and no parameters, description fully covers return content (global indicator, degraded components, open incidents, your_banks_affected), 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?

No parameters exist, so baseline is 4; description needs no parameter info, and schema coverage is 100%.

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, distinguishing it from the sibling tool `openfinance_get_item_status` with specific verb and resource.

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

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

Provides explicit when to use (data incomplete/stale despite connection showing UPDATED) and when not to (differentiates from connection issues), and names an alternative (`openfinance_get_item_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?

Beyond annotations (readOnlyHint=true), the description adds that it returns connector details, includes a caveat about non-Open-Finance connectors, and honors user's plan. 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 information-dense but slightly long; it could be more concise without losing important 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 output schema, the description covers return fields, caveats, and plan restrictions. It could mention pagination or error handling, but not essential for this simple search.

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 that 'keywords' is required functionally and how 'include_accounts' works, adding essential 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 searches bank connectors by name and returns detailed information. It distinguishes from siblings like 'connect' and 'marketplace' by specifying it is a search tool for connectors.

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 highlights the need to surface caveat warnings. It does not explicitly mention when not to use or alternatives, but provides clear context.

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 beyond annotations: it overrides Pluggy's automatic categorization, teaches Pluggy by creating a Category Rule, and describes the batch error handling ('per-item errors do not fail the whole batch'). Annotations only give readOnlyHint=false, destructiveHint=false, so description adds significant value.

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

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

The description is fairly long but efficient, covering purpose, usage, side effects, and return format in a well-organized manner. Slightly verbose for a single paragraph but no unnecessary sentences.

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

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

Given no output schema, the description provides a detailed return shape: { updated, results: [...], errors: [...] } with fields explained. It covers input, behavior, side effects, and error handling. 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?

Despite 0% schema coverage, the description fully documents the 'items' parameter: it must be an array of { transaction_id, category_id } and explains the origin of both IDs. This adds complete meaning beyond the schema 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 action: 'Corrects the category of one or more transactions' and provides the HTTP method (PATCH /transactions/:id). It distinguishes from sibling tools by specifying the data sources (openfinance_list_transactions, 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 explains when to use this tool: 'fix miscategorized transactions and improve categorization accuracy going forward'. It also explicitly tells how to get transaction_id and category_id from related tools. It does not explicitly state when not to use it, but 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 indicate the tool is idempotent and non-destructive, but the description adds no behavioral details beyond the action. It does not disclose what happens after reporting (e.g., ticket creation or limitations).

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

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

The description is very short (two sentences) and gets to the point. It could be slightly more structured but is not verbose.

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 minimal annotations, the description lacks completeness. It does not specify return values, required permissions, or how the feedback is processed, leaving the agent uncertain.

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 the 'conversation' parameter is hinted at in the description, while 'message' (required) and 'context' are not explained. Schema descriptions are absent (0% coverage), so the description should compensate but largely does not.

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: reporting bugs, missing features, or sending feedback. This is specific and distinguishes it from sibling tools which are primarily OpenFinance or system 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 advises to include the conversation array for reproduction, providing some usage context. However, it does not explicitly state when to use this tool versus alternatives 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, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds the specific information returned (platform and adapter versions) but does not disclose any additional behavioral traits 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?

Single sentence, no unnecessary words, perfectly front-loaded with the function. Every word 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 is simple with no parameters and no output schema, the description combined with annotations fully covers what the tool does and its safety profile. No additional information 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?

There are zero parameters, so schema coverage is 100%. The description does not need to add parameter information because none exist. Baseline score of 4 is appropriate as the schema handles all param semantics.

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. The verb 'show' combined with specific resource 'platform and adapter versions' makes the purpose unmistakable, and no sibling tool duplicates this function.

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

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

The description implies usage when version information is needed, and given the absence of similar tools among siblings, no explicit when-not-to-use guidance is necessary. The context is clear enough for correct usage.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds specific behavioral context beyond annotations by detailing exactly what state elements are returned (installed MCPs, connection status, catalog tool counts), which helps the agent understand the output format without needing to call the tool.

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

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

The description is a single, well-structured sentence that immediately conveys the tool's purpose and output. No redundant information; every word 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 tool with no input parameters and no output schema, the description fully explains the return value (installed MCPs, connection status, catalog tool counts). No additional context is needed.

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

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

There are no parameters (schema coverage 100% with empty schema). With zero parameters, the baseline is 4, and the description does not need to add parameter meaning. It correctly omits any 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.' It uses a specific verb ('Returns') and resource ('toolkit state'), and distinguishes from siblings like 'show_version' and 'authenticate' by specifying the exact information provided.

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

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

The description does not explicitly state when to use this tool vs alternatives, nor does it include exclusions or mention specific conditions. However, it is implied that this is the go-to tool for checking overall toolkit status, as siblings focus on specific actions.

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