Banco Master MCP

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

Annotations indicate idempotentHint=true, no destructive/read-only. Description adds behavioral context: calling with no args returns a link, with token performs login. It explains the two distinct behaviors (config vs session) and implies no side effects beyond authentication state. 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 front-loaded with purpose and usage, then details the two modes. While slightly long, every sentence adds value—no redundancy. Structure is logical and efficient for the tool's complexity.

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 (1 optional param, no output schema), the description covers all key aspects: purpose, two usage modes, best practice. It could mention expected response format, but this is minor. Overall sufficient for an agent to use correctly.

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

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

Schema coverage is 0%, so description must explain the single parameter 'token'. It does so clearly: optional, when provided logs in, when omitted returns login link. This adds essential meaning beyond the schema's type definition.

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: authentication via an access token, with two modes (permanent config vs session token). It distinguishes between calling with no args (get link) and with token (login). The verb 'authenticate' and resource 'access token' are explicit, and the description differentiates this tool from siblings by focusing on login/token management.

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: for initial login, either by adding token to config (recommended permanent) or pasting token for session. It mentions the alternative of config-based approach as 'best'. However, it does not contrast with sibling tools like 'connect' or explicitly state when not to use this tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds value by specifying the exact response formats under different credential scenarios, 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, front-loaded with purpose, no wasted words. Each sentence conveys essential behavior.

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 zero-parameter status tool without output schema, the description covers the two main response states. It could mention error handling or URL details, but is adequate.

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

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

There are 0 parameters and schema description coverage is 100%. Baseline for 0 parameters is 4, and the description does not need to add parameter info. No missing 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 it returns connection status and URLs, and distinguishes between two scenarios: all providers connected vs. missing credentials. This provides specific verb+resource scope and differentiates from siblings.

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 checking connection status but does not explicitly compare with siblings like 'authenticate' or provide when-not-to-use guidance. Context is clear but lacks 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?

Discloses crucial behavior beyond minimal annotations: invoke runs MCPs without installing them, returns connect links for auth and checkout/top-up links for payment, writes require workspace owner/admin, and search/describe flag installation status. It also explains prompt library behavior (variables filled, shareable link without login). 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 a dense single paragraph that covers a lot, but every sentence is informative and earns its place. It is not formatted with bullets or sections, which would improve scannability, yet the length is justified by tool complexity.

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 complex tool with 23 params and no output schema, the description covers the main flows, edge cases (auth, payment, admin requirements), and the prompt library. Some actions like 'resume' are not explained, and less common parameters lack semantics, but overall it is highly 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?

The input schema has 23 parameters with 0% description coverage, so the description carries the burden. It does explain key parameters: action values (search/describe/invoke/install/prompt actions), tool_id for invoke, and prompt variables. However, many parameters (limit, immediate, tier_slug, cancel_reason, conversation, prompt_targets) remain unexplained, creating gaps 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 is the official mcp.ai marketplace catalog and runner, with a defined core flow (search → describe → invoke). It distinguishes itself from sibling tools like openfinance_* and authenticate by positioning itself as the in-platform catalog and execution layer.

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 provides decision guidance: 'Use install only to make an MCP PERMANENT in the active toolkit' vs 'prefer invoke for a single/occasional use'. It also states when to use list_tools, subscribe/cancel, report_bug, request_mcp, and the prompt library actions, giving the agent clear when-to/ when-not-to 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?

Annotations already set destructiveHint=true, but the description adds value by specifying that data 'will no longer be available' and that it returns an 'add_connection_url' for reconnection. This provides context beyond the annotation.

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 cover the action, effect, and result. No extraneous information; every sentence 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?

Despite the single parameter, the description fails to explain 'item', and there is no output schema. For a destructive action, more context about reversibility or how to obtain the parameter would be beneficial.

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 sole parameter 'item' is a string with no schema description or enum. The tool description does not clarify what 'item' represents (e.g., bank ID, name, connection ID), leaving the agent uncertain how to populate it.

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 makes bank data unavailable. It distinguishes itself from sibling tools like 'connect' or 'authenticate' by specifying the disconnect action.

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

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

No explicit guidance on when to use this tool vs alternatives. The description does not mention prerequisites, when disconnection is appropriate, or contrast with other openfinance tools like 'openfinance_get_item_status' or 'openfinance_list_connections'.

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 polling up to ~60s, return structure with status/needs_action/reconnect_url, and timed_out handling. Annotations provide no behavioral details, so description carries full burden and succeeds.

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 detailed but every sentence adds value. Front-loaded with key action. Could be slightly more concise but still 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?

Covers all aspects: sync mechanism, wait behavior, result fields, error handling (needs_action with reconnect_url), and timed_out fallback. No output schema but description adequately replaces it.

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 both parameters: items (array of selectors, omit for all) and wait (boolean for fire-and-forget). Compensates completely.

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 forces a re-sync and waits, with specific verb 'force sync' and resource 'connections'. It distinguishes from sibling tools like openfinance_get_item_status and mentions avoiding disconnect/reconnect.

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 (stale balance/transactions), how to select items or sync all, and options for wait behavior. Also advises to re-check with openfinance_get_item_status if timed out.

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 value beyond annotations (readOnlyHint, idempotentHint). It details error handling (BALANCE_FETCH_ERROR, degradation to last-synced balance with realtime: false), warning structures, and response shape. This is comprehensive behavioral disclosure.

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

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

The description is concise yet comprehensive, front-loading the core purpose and endpoint. Every sentence adds value, covering parameter constraints, edge cases, and response structure without redundancy.

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

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

Given the single parameter, no output schema, and the tool's specific function, the description is complete. It covers the response shape, error and degradation scenarios, and provides enough context for an AI agent to handle various 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?

Schema has 0% coverage, but the description explains that account_ids is an array of strings with a 1-50 length constraint. It also implies each element is an account ID. While it could provide examples or format details, it effectively compensates for the lack of schema descriptions.

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

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

The description clearly states the tool returns real-time balance per account ID, specifying the endpoint and required parameter. It distinguishes itself from sibling tools like openfinance_get_accounts_detail or openfinance_list_accounts by focusing specifically on balance retrieval.

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

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

The description provides clear usage context: pass account_ids as array (1-50). It explains expected behavior for CREDIT accounts and when the institution is unavailable. While it doesn't explicitly state when not to use or list alternatives, the purpose is well-defined and sufficient for an AI agent to select this tool for balance 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?

Adds important behavioral details beyond annotations: batch {results, errors} shape, provider_incident block, and caution about unreliable values. 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?

Single paragraph with necessary info, front-loaded with purpose. Could be more structured but 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?

Covers return shape, error handling, and special case of provider incidents. Without output schema, description provides sufficient context for correct use.

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

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

Schema coverage is 0%, but description compensates by stating parameter should be an array (1-50) of strings, implying account IDs. Adds constraint and type info.

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?

States it returns full account objects including extended creditData per ID, specifies HTTP method and endpoint pattern, and mentions batch shape. Clearly distinguishes from list tools like openfinance_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?

Provides specific usage instructions: pass account_ids array (1-50) and explains batch shape. Does not explicitly mention when to avoid or prefer siblings, but 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 already mark as readOnly, idempotent, non-destructive. The description adds detailed behavioral context: batch shape, that Pluggy lacks paid status, and the nuanced meaning of payments[] (previous bill payment). 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?

The description is comprehensive but slightly verbose; every sentence adds value. It is well-structured: action, what it does not do, then usage guidance. Could be tightened slightly.

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 tool with a simple schema and no output schema, the description covers output fields, return shape, prerequisites, edge cases (Nubank inconsistency, Pluggy missing status), and cross-tool coordination. Fully 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?

Only one parameter (bill_ids) with 0% schema description coverage. The description explains it is an array, how to discover IDs via list_bills, and the batch shape. Could add constraints like maximum items, but sufficiently clarifies 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, specifies included fields (financeCharges, payments) and explicitly distinguishes it from openfinance_list_transactions, which returns individual 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 gives explicit when-to-use and when-not-to-use guidance: use it for bill details, use openfinance_list_transactions for itemized transactions. It also directs to first use openfinance_list_credit_card_bills to discover IDs, warns against reconstructing bill totals, and explains payment cycle nuances.

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 and idempotentHint, so safety is covered. The description adds useful behavioral context: what the reconnect_url does (reopens widget in UPDATE mode without disconnecting or consuming a slot) and the bulk behavior. 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 moderately sized, front-loaded with the purpose, and uses clear structure. It could be slightly more concise, but every sentence serves a purpose.

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

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

With no output schema, the description explains the return fields and the structure for bulk responses. It covers input semantics and key behaviors. However, it lacks details on error handling or edge cases.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the usage of 'item' (omitting for all, passing for single) and 'item_ids' for batch. However, 'item_id' is not explained at all, leaving ambiguity. The description adds value but is 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 the tool returns the status of a bank connection with specific fields like executionStatus and reconnect_url. It distinguishes between single bank and all banks. However, it does not explicitly differentiate from sibling tools that might also provide status information, such as 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 provides explicit usage guidance: omit 'item' for all banks, pass 'item' for a single bank, and use 'item_ids' for bulk execution. It also explains the reconnect_url purpose. However, it does not mention when not to use this tool or suggest alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so description is consistent. It adds value by describing the batch processing and error shape 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?

Description is relatively concise and front-loaded with purpose. It lists many fields, which is helpful but slightly dense. Lacks markdown structure but still 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 single parameter, no output schema, and annotations covering safety, the description provides sufficient context: response shape, usage context, and parameter constraints. Could include more on error handling but 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?

Schema has one param (loan_ids array), and description adds constraint 'as an array (1-50)', enhancing semantics beyond the schema. Schema coverage 0% but description compensates with this detail.

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 loan contract detail by ID, listing specific fields like interestRates, installments schedule, CET, etc. It also distinguishes from sibling openfinance_list_loans by saying 'Use after...'.

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 when to use this tool: after openfinance_list_loans to deep-dive on a contract. Also specifies batch usage with loan_ids array (1-50) and return shape `{ results, errors }`.

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

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

Adds significant context beyond annotations: provider_incident may make balances unreliable, identity_notice about duplicate accounts with different owners, and clarifies that `name` is the legal entity, not the brand. Annotations already indicate readOnly, idempotent, non-destructive.

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-organized with clear paragraphs and bullet points (implicitly). Every sentence adds value, though it could be slightly more concise without losing completeness.

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

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

Given the complexity (multiple account types, balance nuances, provider incidents, identity dedup), the description is thorough. No output schema, but return structure is described in detail, and sibling tool for credit card bills is referenced.

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 explains the purpose of `item`, `type`, and `item_ids` (bulk support), adding meaning to the otherwise bare schema. However, `item_id` is not explicitly distinguished from `item`, and schema coverage is 0%, so some precision is lost.

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 including types (BANK/CREDIT), fields (balance, number, type, etc.), and distinguishes from sibling tools like 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?

Explicitly tells when to omit `item` (to list all accounts across banks) and when to include it (target a single bank). Provides warnings about credit card balance interpretation, provider incidents, and identity notice for joint accounts.

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. The description adds caching behavior, the structure of each entry (id, description, descriptionTranslated, parentId, parentDescription), and that the response is a single aggregated list with no batch ids—valuable 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 concise with four sentences, front-loaded with the primary purpose, followed by key details on fields and 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 (no parameters, no output schema), the description provides sufficient information about the returned data structure and caching. It could mention potential staleness of cache or error handling, but overall it is adequate.

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

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

With zero parameters and 100% schema coverage, the description doesn't need to add parameter details. However, it describes the structure of the return data (fields like id, description, descriptionTranslated, parentId, parentDescription), which is helpful given the absence of an output schema.

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

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

Description clearly states it returns Pluggy's transaction category taxonomy via GET /categories. It specifies the exact endpoint and that results are cached per session, distinguishing it from other list tools by its static, read-only nature.

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 that the 'id' field is used by 'openfinance_update_transaction_category' for updating transactions, providing a clear use case. However, it does not explicitly state when not to use this tool or mention alternatives among siblings.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and destructiveHint. The description adds behavioral context: reconnect_url does not consume a connection slot and does not require disconnecting first. This adds value beyond annotations.

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

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

The description is a single, well-structured paragraph. It starts with the main purpose and efficiently includes necessary details about the URLs without redundancy.

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

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

For a read-only list tool with 0 parameters and no output schema, the description is fairly complete. It explains output fields and special URLs. Could mention the return type (list) but is sufficient.

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

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

With 0 parameters and 100% schema coverage, the description does not need to explain parameters. The baseline is 4, and the description appropriately omits parameter 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 explicitly states the tool returns saved bank connections with specific fields. It clearly distinguishes itself from sibling tools like openfinance_list_accounts by specifying its purpose and the special URLs.

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 guidance on when to use the reconnect_url (for re-authentication, MFA, LOGIN_ERROR, stale data). However, it does not explicitly mention when not to use this tool compared to alternatives like openfinance_list_accounts or when listing is inappropriate.

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, destructiveHint: false. Description adds significant behavioral context: payment_status derivation, cycle date logic, connector asymmetry, bill grouping reliability warnings, and open_bill availability reasons. 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 very long and dense, with extensive detail on payment semantics and edge cases. While valuable, it could be restructured to be more concise, though key information is 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?

No output schema exists, but description comprehensively details the response structure: account echo, payments array, derived payment_status, open_bill conditional, future_bills, warnings, connector asymmetry, and limitations. Covers all necessary context.

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

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

Schema description coverage is 0%, so description must explain parameters. It describes account_id (implied), account_ids (bulk), and include_open_bill (detailed), but does not explain page and page_size. Partial coverage only.

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 with specific fields (dueDate, totalAmount, etc.). It distinguishes from sibling tools like openfinance_list_transactions (for itemized purchases) and openfinance_get_credit_card_bill (singular).

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 context for when to use include_open_bill (opt-in for open bill), warns about cross-bank attribution, and suggests alternative for transactions. However, lacks explicit exclusions or when-not-to-use scenarios.

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 the annotations (readOnlyHint=true, destructiveHint=false), the description discloses error handling behaviors (returns structured response on 403), data integrity checks, and warning flags (data_integrity_warning, integrity:'suspect_zeroed'). This 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 well-structured with clear paragraphs and front-loaded purpose. However, it is somewhat lengthy due to detailed data integrity notes, which could be condensed. Still, no wasted sentences.

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

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

Given the tool's complexity (6 parameters, no output schema), the description is remarkably complete. It explains the return format, error handling, data integrity warnings, and bulk support. An AI agent can effectively use this tool with the provided information.

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

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

Schema description coverage is 0%, so the description must compensate. It only briefly mentions item_ids for bulk support. Other parameters (page, page_size, type, item) are not explained. The description does not add meaning beyond the schema, leaving the agent guessing about parameter formats and 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 investment portfolios for a connection, listing specific asset types and fields. It uses a specific verb ('returns') and resource ('investment portfolio'), distinguishing it from sibling tools like openfinance_list_investment_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 specifies that it returns portfolios for a connection and mentions error handling (returns fallback instead of throwing). It also notes bulk support via item_ids. However, it does not explicitly contrast with alternatives or state when not to use this 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 provide read-only, idempotent, non-destructive hints; description adds behavioral details on transaction types and returned fields without contradiction. No additional info on auth or limits needed.

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 plus a bulk support line, front-loaded with purpose and key 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?

Covers purpose, usage order, bulk support, and return fields. Lacks explanation of pagination parameters, but given no output schema and safe annotations, it's mostly adequate.

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

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

With 0% schema coverage, description only implicitly mentions investment_id and investment_ids, but fails to explain page and page_size parameters. As a result, the description does not add sufficient meaning for all parameters.

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

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

The description clearly states the tool returns movement history for a specific investment position, listing transaction types (BUY/SELL/TAX/etc.) and key fields, distinguishing it from siblings like openfinance_list_investments 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?

Explicitly advises using after openfinance_list_investments to obtain investment_id, and mentions bulk support via investment_ids. Lacks explicit when-not guidance, but 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 already declare readOnlyHint, idempotentHint, destructiveHint. Description adds value by detailing sequential querying with rate-limit spacing and return structure {results, errors}, 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?

Three sentences, front-loaded with purpose, no wasted words. Efficient and 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?

Given no output schema, the description mentions return structure and covers both use cases (specific connections vs all). Complete for a 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 has 0% description coverage, but the description fully explains the `items` parameter: it accepts an array of connection selectors (item_id, connector_id, or connector_name) and the effect of omitting it. This compensates completely.

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

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

The description clearly states the tool lists loan contracts per bank connection using the GET /loans endpoint. It distinguishes from siblings like openfinance_get_loan_detail by specifying 'per bank connection' and the batch behavior.

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

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

Provides clear usage context: how to optionally pass `items` for specific connections or omit for all. While it doesn't explicitly list when-not-to-use or alternatives, the guidance is practical and 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?

Adds extensive behavioral context beyond annotations: auto vs manual pagination, truncation, error handling (warning vs throw), detail levels with per-row cost, creditCardMetadata hints (sparse/inconsistent billId), provider incident block, and connection health check guidance. No contradiction with annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false).

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 verbose but well-structured with clear sections (pagination, detail, errors, bulk). Could be slightly more concise by grouping behaviors, but the length is justified by the tool's complexity and the valuable edge-case 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 the tool's complexity, 8 parameters, and no output schema, the description is thorough: covers pagination behaviors, error responses, detail levels, relationships with sibling tools, provider incidents, connection health, and credit card metadata caveats. Leaves no obvious gaps for an agent to misuse.

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 all parameters: from/to (ISO format), search_queries (case-insensitive substring, OR), page/page_size defaults and manual mode, detail (compact, rich, raw with coverage caveats), and account_ids for bulk. Each parameter's semantics are clear.

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

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

The description clearly states it returns transactions for a bank account, distinguishes BANK vs CREDIT types, and explicitly positions itself as the only way to get itemized credit card transactions. It differentiates from siblings like openfinance_list_credit_card_bills for bill totals.

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 (itemized transactions), when-not-to-use (bill totals, use openfinance_list_credit_card_bills instead), and alternative tools for closing/due dates (openfinance_list_accounts). Also gives situational guidance for credit pending/posted variability and pagination modes.

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

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

Annotations already mark the tool as read-only and idempotent. The description adds behavioral traits: truncation at 5000/account, provider_incident block for incomplete data, and bulk support. No contradiction with annotations.

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

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

The description is moderately lengthy but well-organized with front-loaded purpose and clear sections. Some minor redundancy exists (e.g., repeating 'granularity' defaults), 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?

No output schema exists, but the description details the return structure: total entradas/saídas/saldo_liquido, monthly evolution, top expenses/revenues, per-account breakdown, truncation flag, and provider_incident block. Bulk support is also documented.

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

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

Schema description coverage is 0%, so the description must fully explain parameters. It does so, covering item (connector_id/name/item_id), from/to (ISO dates), granularity (monthly/raw), detail (compact/rich/raw), type (BANK/CREDIT), top_n, and item_ids for bulk. Defaults and behavior are explained.

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 performs consolidated cash-flow analysis for a bank connection, resolving accounts internally. It distinguishes itself from siblings like openfinance_list_accounts and openfinance_list_transactions by eliminating the need for prior account listing.

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

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

The description explicitly tells when to use this tool versus alternatives (no need to call openfinance_list_accounts). It guides on granularity and detail settings, provides example use cases, and notes the truncation behavior at 5000 transactions per account.

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

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

Annotations already indicate read-only, idempotent, non-destructive. Description adds behavioral details: checks public status page, returns global indicator, degraded components, incidents, and flags affected banks. 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?

One paragraph but well-structured: purpose, usage context, return info. Slightly long but 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?

No output schema; description compensates by detailing return values (global indicator, degraded components, incidents, affected banks). Fully describes what agent can expect.

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

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

No parameters exist in the schema, so baseline is 4. Description does not add parameter info (none needed), but adequately explains what the tool does without 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, distinct from connection status. It uses a specific verb ('Checks') and resource ('provider status'), and explicitly distinguishes from sibling tool 'openfinance_get_item_status'.

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

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

Explicitly states when to use (when data looks incomplete/stale despite updated connection) and what it helps differentiate (provider-side problem vs. connection issue). Also implies alternative sibling for connection health.

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 annotations already provide readOnlyHint and idempotentHint, but the description adds valuable context: it returns a connect_url, never dumps the whole catalog, surfaces caveats for credential connectors, and respects plan restrictions. 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 comprehensive but slightly verbose. It front-loads the main purpose and organizes details well. A bit of trimming could improve conciseness, but it's still 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?

Without an output schema, the description fully describes the return fields (id, access, audience, connections, accounts, connect_url, caveat) and behavior (plan handling, keyword requirement). It is complete for an agent to understand and invoke correctly.

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

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

Schema coverage is 0%, so the description must explain parameters. It does so thoroughly: keywords are passed as an array (e.g., ['nubank','btg']) and are required; include_accounts when true includes accounts. This compensates fully for the lack of schema descriptions.

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

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

The description clearly states that the tool searches bank connectors by name, returns specific fields including a ready connect_url, and is meant to be called before connecting. It distinguishes itself from siblings by explicitly saying 'Call this BEFORE connecting'.

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 it ('before connecting'), that keywords[] is required, and that it honors the user's plan. It does not explicitly exclude scenarios, but the guidance is clear and practical.

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

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

The description goes beyond annotations by detailing the behavioral impact: overriding automatic categorization, teaching Pluggy by creating a Category Rule, and batch error handling (per-item errors do not fail the whole batch). Annotations only state non-read-only, non-destructive, etc., but the description adds critical context. 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?

The description is detailed and front-loaded with the main action. It is slightly long but all sentences are necessary. Could be tightened by combining related points, but 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 complexity (batch operation, side effects, error handling) and the lack of output schema, the description provides a complete picture: input requirements, output shape (updated, results with transaction_id/category/categoryId, errors), and references to sibling tools. No gaps.

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

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

With 0% schema description coverage, the description fully compensates by explaining the 'items' parameter structure: it is an array of objects with transaction_id and category_id, and it tells the agent where to obtain these IDs (from openfinance_list_transactions and openfinance_list_categories). This adds meaning beyond the raw schema.

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

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

The description clearly states the verb 'Corrects' and the resource 'category of one or more transactions', referencing the HTTP method PATCH. It distinguishes itself from sibling tools by specifying the source of transaction_id and category_id (list_transactions and 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 provides explicit guidance on when to use the tool: to fix miscategorized transactions and improve future categorization. It explains the side effect of creating a Category Rule, which helps agents decide whether to use this tool vs. other tools. It also implies when not to use it (if you don't want to affect future categorizations).

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 the tool is not destructive and is idempotent. The description adds minimal extra behavioral context, only stating it's for reporting. No contradictions, but little value beyond annotations.

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

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

Description is two sentences: first states purpose, second provides usage guidance. No unnecessary words, well-structured, and easy 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?

With no output schema and 0% parameter description coverage, the description is somewhat incomplete. It covers purpose and one parameter, but not all three parameters. Adequate for a simple tool but could be improved.

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. The description only mentions the 'conversation' parameter, ignoring 'message' (required) and 'context'. Users get no guidance on what these fields should contain.

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 the tool's purpose: report a bug, missing feature, or send feedback. This clearly differentiates it from sibling tools which are mostly related to openfinance or 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?

Description provides specific guidance to include the conversation array with recent messages for reproduction. While it doesn't mention when not to use it or alternative tools, the advice is clear and actionable.

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 that it returns specific version details ('platform and adapter versions'), providing 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?

The description is a single sentence with no extraneous information, perfectly concise 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?

Given the absence of parameters and the comprehensive annotations, the description is complete. It provides all necessary information 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?

There are no parameters, and the schema coverage is 100%. The description does not need to add parameter information. Baseline score of 4 for zero parameters is appropriate.

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

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

The description clearly states the tool's action ('Show') and what it returns (current MCP platform and adapter versions). It distinguishes from sibling tools, none of which appear to provide version information.

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 context is clear for a simple read-only tool, but no explicit guidance on when not to use it or alternatives is provided. However, given its simplicity, the description 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, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds valuable behavioral context by specifying exactly what the returned state includes (installed MCPs, connection status, accounts per MCP, catalog tool counts), going beyond a generic 'returns state' statement. No contradictions with annotations.

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

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

The description is a single, front-loaded sentence beginning with 'Returns' and uses a colon to enumerate the delivered information. Every word earns its place; no fluff or repetition of schema/annotation 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?

For a zero-parameter, no-output-schema tool, the description is complete enough: it fully specifies the nature of the returned toolkit state. It does not explain return format or caching, but these are not critical given the simplicity and the presence of read-only/idempotent annotations. The content covers what an agent needs to know to choose and use this tool.

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

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

The tool has zero parameters, and schema description coverage is trivially 100%. The baseline for 0-parameter tools is 4, and the description does not need to add parameter information since there are none. It correctly focuses on return value 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 uses a specific verb ('Returns') with a clear resource ('current toolkit state') and enumerates the exact contents: installed MCPs, connection status, accounts, and catalog tool counts. This clearly distinguishes it from sibling tools like openfinance_list_connections or show_version, which are provider-specific or version-specific.

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 this is a top-level overview tool for checking toolkit state, but it does not explicitly state when to use it versus alternatives (e.g., 'Use this to get a high-level view before calling specific connector tools'). No exclusions or alternative tool names are mentioned, so usage guidance is implied rather than explicit.

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