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 substantial behavior beyond annotations: explains that balance is a snapshot anchored to last sync, not a live read; details degradation to last-synced balance with realtime:false and warnings; and clarifies that errors surface as structured warnings rather than exceptions. This richly complements the readOnlyHint and idempotentHint annotations.

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

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

The description is long but every sentence adds necessary operational detail about freshness, error handling, degradation, and response shape. It front-loads the core purpose and then layers caveats in a logical order with no filler.

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

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

With no output schema, the description includes the response envelope { results, errors }. It covers parameter constraints, sync freshness, error modes, degradation behavior, and instructions for remediation. An agent has enough context to invoke the tool correctly and interpret results.

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 only shows account_ids as an array of strings, but the description adds critical meaning: 'Pass account_ids as an array (1–50)' and clarifies the response is per account id. Although the item format is not further detailed, the single parameter is well explained for practical 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 states a specific verb and resource: 'Returns the latest available balance per account id (GET /accounts/:id/balance)' and immediately clarifies the snapshot semantics. It clearly identifies the tool's unique function among many openfinance siblings without ambiguity.

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

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

It gives explicit when-to-use guidance: if the balance is stale or disagrees with openfinance_list_transactions, run openfinance_force_sync then re-read. It also explains CREDIT account error cases and directs the user to reconnect the bank to restore consent, covering both alternatives and recovery paths.

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?

The annotations only state `readOnlyHint`, `idempotentHint`, and `destructiveHint`; the descecription then supplies consequential behavior: `transactions_basis` meanings, the opt-in extra scan cost, the authoritative nature of `totalAmount`, the fact Pluggy/no paid/status middleware, and the critical ‘previous bill payment' semantics of `payments[]`. These are substantial CTB/behavioral disclosures beyond the structured fields.

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

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

The text is heavily front-loaded: one-sentence purpose, then fields, then opt-in semantics, then ordering caveats. Every sentence carries useful information, but it is very long and could be tightened with bullets or a nested structure. The length is justified by the tool’s nuance, but it is not a model of concise editing.

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?

There is no output schema, yet the description explains the `{ results, errors }` batch shape, the fields returned, the `transactions_basis` tri-state, the `transactions_hint` fallback, and the paid/status ambiguity. For a complex Brazilian Open Finance billing tool, this is enough context for an agent to call it correctly and interpret the response.

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 has to compensate. It enriches `bill_ids` (“use `openfinance_list_credit_card_bills` first”), `include_transactions` (triggers an extra opt-in transaction scan), and `account_id` (required only with include_transactions, because the bill has no account reference). It does not explain `transactions_detail`, though that parameter carries an enum that partially self-documents. Overall, the parameter description is strong but not complete.

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 opens with a precise verb and resource: 'Returns bill-level detail for one or more credit card bills by id (GET /bills/:id)'. It names the returned fields (`dueDate`, `billClosingDate`, `totalAmount`, `financeChanges`, `payments[]`) and explicitly distinguishes itself from `openfinance_list_credit_card_bills` and `openfinance_list_transactions`, so an agent can tell them apart.

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

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

It gives explicit guidance: first call `openfinance_list_credit_card_bills` to discover `note`, when checking paid status 'prefer `openfinance_list_credit_card_bills`', and it provides an alternative route for transactions via `openfinance_list_transactions`. It also warns when to expect `transactions_basis=date_window` and when it should be `exact`, so usage context and alternative-rule selection are covered.

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?

Beyond the readOnly/idempotent/destructive annotations, the description reveals important behavioral traits: balance semantics vary by connector, `balance_notice` indicates misleading zero balances, derived fields can lag and be stale, provider incidents make values unreliable, and identity notices require deduplication. These are substantial and non-obvious behavioral disclosures that an agent needs to handle responses correctly.

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

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

The description is long but front-loaded with the core result and then systematically covers critical edge cases. Every paragraph adds meaningful guidance about usage, data reliability, or response interpretation. It is not concise in word count, but it is dense and well-organized for a tool with many caveats; a slightly tighter structure would improve it.

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 carries the full burden of explaining return values and their semantics, and it does so thoroughly: field meanings, bank naming, filtering behavior, credit bill caveats, stale data, incidents, identity notices, and bulk support. It also references related tools for complementary data. An agent has enough context to call the tool and interpret results appropriately.

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

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

The input schema has 0% description coverage, so the description must compensate. It does explain `item` vs `item_ids` well and clarifies the meaning of BANK and CREDIT account categories. However, it does not explicitly explain the singular `item_id` parameter or state that `type` acts as a filter, leaving some parameter semantics partially inferred rather than fully documented.

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 states a specific verb and resource: 'Returns accounts for a bank connection' with account types, fields, and aggregating behavior. It also distinguishes itself from related tools like openfinance_list_credit_card_bills and openfinance_get_account_balance by describing what this tool uniquely provides. The purpose is immediately clear even among many sibling tools.

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

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

The description gives explicit when-to-use guidance: omit `item` to list accounts across all linked banks when the user asks for 'my accounts/cards' without naming a bank, and pass `item` to target a single bank. It also names alternatives such as openfinance_list_credit_card_bills and openfinance_force_sync for specific situations, and warns against misinterpreting balances. This leaves little to inference.

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?

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, but the description adds extensive behavior beyond that: auto-pagination vs manual pagination, 5000 transaction ceiling with truncated/warning behavior, per-connector variance in pending/posted visibility, scheduled transactions ordering, error return shape instead of throwing, sparse/inconsistent creditCardMetadata.billId warnings, and provider incident blocks. Nothing is hidden and no contradictions appear.

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

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

The description is long but appropriate for a complex and pitfall-heavy tool. The first section establishes the primary purpose, then follows with the most safety-critical warning about credit-card bills, then parameter and pagination behavior, then per-row detail options, then troubleshooting. Each sentence adds either a usage constraint, a failure mode, or a pointer to a sibling tool. Despite the length, it is structured and front-loaded, not a verbose tautology.

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

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

Given that there is no output schema, the description compensates fully by describing the response significantly: account echo block, scheduled_count, notice, truncated flag, total:0/error fallback, warning blocks, and provider_incident. It also includes a dedicated troubleshooting path for zero totals on CREDIT accounts. An agent has enough information to make correct invocation and handle results across the majority of real-world 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 carries the full burden for parameter meaning. It explains every meaningful parameter: from/to date filters with ISO format, search_queries substring OR-semantics, detail values 'compact'/'rich'/'raw' with row-level implications, page/page_size pagination behavior, account_id via response echo cross-checking, and account_ids bulk support. This goes far beyond the raw type definitions and compensates fully for the schema's lack of 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 opens with a specific verb-resource pairing: 'Returns transactions for a bank account (BANK or CREDIT type).' It clearly differentiates from siblings by noting that for CREDIT accounts this is the ONLY way to get itemized transactions, and explicitly routes to openfinance_list_credit_card_bills for standardized totals. It also names openfinance_list_accounts for closing/due dates, leaving no ambiguity about scope.

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

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

The description gives explicit guidance on when to use this tool versus alternatives: use openfinance_list_credit_card_bills for standardized open-bill totals, use openfinance_list_accounts for closing and due dates, and check openfinance_get_item_status if a credit account returns zero. It also instructs how to narrow pagination and which detail level to use by default, providing both positive usage and 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 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.