Banco do Nordeste do Brasil MCP

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

Beyond annotations (idempotentHint=true, destructiveHint=false), the description adds that calling with no args returns a link and that passing a token sets it for the session. This discloses behavioral modes but doesn't detail error handling.

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

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

The description is front-loaded with the purpose and then details the two usage methods. It is moderately concise; every sentence adds value but could be slightly more streamlined.

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

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

For a simple tool with one optional parameter and no output schema, the description covers main usage scenarios well. It lacks error handling details but otherwise provides sufficient context for invocation.

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

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

The input schema has 0% description coverage with one undocumented string parameter. The description fully compensates by explaining the token is a JWT and that omitting it returns a login link, adding complete meaning.

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

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

The description clearly states the tool authenticates for MCP.AI in IDE agents, specifying the action (log in via browser token) and the resource (MCP.AI). It distinguishes from siblings like 'connect' by focusing on token-based authentication.

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

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

The description provides clear context on when to use the tool: for initial login, with two methods (permanent config or session-only token). It does not explicitly state when not to use, but the context is sufficient.

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

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

Annotations already indicate readOnlyHint and idempotentHint. The description adds valuable behavioral context by detailing return conditions (authenticated:true vs connect_url), which helps the agent understand the tool's behavior 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 two sentences, front-loaded with the core purpose, and every sentence adds useful information. No wasted words.

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

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

While the description covers two common scenarios, it omits edge cases like partial connection status (some providers connected, some not). Without an output schema, this gap may leave the agent uncertain about all possible return 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?

No parameters exist, so schema coverage is 100%. The description does not need to add parameter information, earning a baseline of 4 as per guidelines.

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

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

The description clearly states the tool returns connection status and URLs, with specific scenarios for all-connected and missing-credentials cases. It distinguishes from siblings like authenticate which handles 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?

The description implies use for checking connection status but does not provide explicit guidance on when to use this tool vs alternatives like authenticate or openfinance_list_connections. No when-not-to-use or comparative context.

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

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

Annotations only provide readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false. The description adds critical behavioral context: invoke runs tools even if not installed, returns connect/checkout links, and writes require owner/admin. No contradictions with annotations.

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

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

The description is long but well-structured, starting with core purpose and then detailing the flow. Every sentence contributes, though some redundancy exists (e.g., repeated mention of connect/checkout links). It is front-loaded and efficient for its length.

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

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

Given 15 parameters, no output schema, and no detailed schema descriptions, the description covers the tool's purpose, workflow, auth requirements, error handling (connect/checkout links), and ownership requirements. It is substantial but could still elaborate on return formats 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 high-level semantics for the 'action' enum (e.g., search discovers MCPs, describe returns profile, invoke runs tool) and mentions some parameters like 'query', 'mcp_id', 'tool_id', 'arguments'. However, for many parameters like 'limit', 'immediate', 'tier_slug', 'conversation', no explanation is provided. The description adds meaning but is incomplete for all 15 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 is the official mcp.ai marketplace, with a specific verb-resource pair ('search, describe, invoke, etc.'). It distinguishes from siblings by instructing to use this tool first before external registries. The core flow is explained upfront.

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 and when-not-to-use guidance, e.g., 'use THIS tool FIRST', 'prefer invoke for a single/occasional use', and 'use install only to make an MCP PERMANENT'. It also explains the flow and alternatives.

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

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

Annotations already indicate destructiveHint=true, but the description adds valuable context: revocation of consent, deletion of data, unavailability of data, and a return of a reconnection URL. No contradiction with annotations.

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

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

Two concise sentences front-load the action and outcome, with no unnecessary words. Every sentence adds information.

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

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

For a destructive tool with one parameter and no output schema, the description adequately covers the outcome and return value. However, it lacks guidance on the parameter meaning and does not mention irreversibility or user confirmation needs.

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 one parameter 'item' with no description and 0% coverage. The tool description does not clarify what 'item' represents (likely a bank identifier), leaving the agent to guess.

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 specific verbs ('revokes', 'deletes') and clearly identifies the resource ('Open Finance consent for a specific bank'). It distinguishes from sibling tools by focusing on removal, which is unique among list/sync 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 implies this tool is for disconnecting a bank, but it does not explicitly state when to use it versus other tools (e.g., openfinance_force_sync) or provide conditions for when not to use it.

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

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

Annotations only indicate readOnlyHint=false, destructiveHint=false, idempotentHint=false. The description adds rich behavioral details: polling up to ~60s, return format with results/errors, fields like synced, needs_action, timed_out, and the effect of wait parameter. 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 the core action, then usage context, then parameter details, then return format. Every sentence provides essential information; no wasted words. Despite length, it is efficiently structured.

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

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

Despite no output schema, the description thoroughly explains return fields (results, errors, status, executionStatus, lastUpdatedAt, synced, needs_action, timed_out). Covers all edge cases (timeout, user action needed, fire-and-forget). Complete for a complex tool.

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

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

Schema has 0% description coverage, but the description fully explains both parameters: items as an array of selectors (item_id, connector_id, or connector_name) with option to omit for all, and wait as boolean for synchronous vs fire-and-forget. This adds complete meaning beyond the bare schema.

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

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

The description clearly states the tool's purpose: force a re-sync of one or more connections and wait for it to finish. It distinguishes from other tools like openfinance_get_item_status by specifying that this triggers a sync and waits, while the sibling is for re-checking after timeout.

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 (stale balance/transactions) and what it does (fresh data without disconnecting). Provides alternatives: use openfinance_get_item_status after timeout, and different behavior when items is omitted (sync all) or wait is false (fire-and-forget).

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 specific error/fallback behaviors (BALANCE_FETCH_ERROR, degradation to last-synced balance with warnings), enhancing transparency without contradiction.

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

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

Description is dense but well-structured: purpose, parameter, error cases, response shape. Efficiently uses parentheses and lists. 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 simple parameter, no output schema, and annotations covering safety, the description fully explains behavior, error handling, and response format, leaving no obvious 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?

Schema coverage is 0%, so description must compensate. It adds the array length constraint (1–50) and clarifies the parameter is a list of account IDs, providing meaningful context beyond the 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 the tool returns real-time balance per account id, specifies the API endpoint, and distinguishes from sibling tools like openfinance_get_accounts_detail or openfinance_list_accounts by focusing on balance.

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

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

Explicitly instructs to pass account_ids as an array (1–50) and describes edge cases (CREDIT accounts error, upstream unavailability). Lacks explicit 'when not to use', 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=true, idempotentHint=true, destructiveHint=false. The description adds critical behavioral context: the tool may return a `provider_incident` block when the Open Finance provider has an OPEN incident, making credit limits and balances unreliable. It explicitly warns not to present those values as real, which is beyond annotation scope.

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

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

The description is somewhat long but every sentence adds value. It is front-loaded with the core purpose and includes essential warnings. Could be slightly more concise, but overall well-structured.

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

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

Given no output schema, the description explains the response shape (`{ results, errors }` batch shape) and warns about provider incidents. It does not detail the account object structure, but 'full account objects including extended creditData' provides enough context for an agent. Slightly more detail on the results array would improve completeness.

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

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

Schema coverage is 0%, so the description must compensate. It adds meaning to the single parameter `account_ids`: specifies it as an array, limits 1–50, and implies it carries account IDs. This fully supplements the lacking 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 'Returns full account objects including extended creditData per id'. It specifies the verb (Returns), resource (full account objects), and distinguishes from sibling tools like openfinance_list_accounts by highlighting the extended data. The batch shape is also mentioned.

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 instructs to 'Pass `account_ids` as an array (1–50)', which is clear guidance for usage. It implicitly differentiates from list tools by requiring specific IDs. However, it does not explicitly state when not to use or name alternatives beyond the batch limit.

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 readOnly, idempotent, non-destructive. Description adds critical details: does NOT return individual transactions, batch shape, Pluggy missing paid/status, and meaning of payments array in Brazilian Open Finance. No contradiction with annotations.

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

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

Description is relatively long but every sentence adds essential information. Well-structured with clear sections. Slightly verbose but justified given the complexity and need for nuance.

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

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

Given one parameter, no output schema, and complex domain (credit card bills with regional quirks), the description is comprehensive. Covers functionality, usage, pitfalls, and relationships to sibling tools.

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 parameter bill_ids with 0% description coverage. Description fully compensates: explains what bill_ids is, how to obtain them (via list bills), that it's an array, and mentions batch response shape {results, errors}.

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

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

The description clearly states the tool returns bill-level detail for credit card bills by ID, listing specific fields like financeCharges and payments. It distinguishes from openfinance_list_transactions which retrieves 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?

Explicitly advises to first use openfinance_list_credit_card_bills to discover bill IDs, and warns against using this tool for individual transactions or reconstructing bill totals. Provides specific when-not-to-use guidance and names the alternative 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, and destructiveHint=false. The description adds value by specifying the return includes executionStatus and connector metadata, and explains the return shape for the 'all banks' mode (returns { count, items }). 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 consists of two sentences with no redundant information. The first sentence states the purpose and expected return values; the second explains the parameter usage. Information is front-loaded and efficient.

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

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

For a simple tool with one optional parameter and no output schema, the description is complete. It covers both usage modes and the return shape. Minor missing info like error handling or rate limits, but acceptable given the tool's simplicity and read-only nature.

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

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

The input schema has 0% description coverage, but the description fully explains the parameter's role: omitting it returns all banks, passing it returns a single bank. It could specify valid values for 'item' (e.g., connection ID), but the 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 the tool returns the current status of a bank connection, including specific status values like UPDATED, UPDATING, LOGIN_ERROR, executionStatus, and connector metadata. It also distinguishes behavior based on the 'item' parameter, making it distinct from sibling tools like openfinance_list_connections.

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

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

The description provides explicit guidance on when to omit or pass the 'item' parameter: omit for all banks, pass for a single bank. While it does not explicitly state when not to use this tool versus alternatives, the distinction is clear enough for selection.

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

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

Annotations already declare readOnlyHint, destructiveHint, idempotentHint; description adds batch shape ({ results, errors }) and array size constraint (1-50), enhancing transparency without 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?

Single sentence packs purpose, fields, usage guidance, and parameter constraint efficiently; slightly dense but front-loaded with key verb and resource.

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

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

With one parameter and no output schema, the description covers what, when, parameter size limit, and return format, fully meeting the tool's needs.

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 0% but description explains loan_ids as an array of 1-50 strings and notes the batch response shape, adding practical usage details beyond schema.

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

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

Description clearly states 'Returns full loan contract detail by id' and lists all returned fields; distinguishes from sibling openfinance_list_loans with explicit usage hint.

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 says 'Use after openfinance_list_loans to deep-dive on a specific contract', providing clear context; no alternative or when-not-to-use mentioned.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds that the tool may include provider_incident block when provider has open incident, making balances unreliable. 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?

Description is lengthy but every sentence adds value. Front-loaded with core purpose then details. Could be slightly more concise but well-organized for 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?

Without output schema, description explains return fields (bank, connector_id, item_id) and provider_incident block. Covers edge cases and limitations. Complete for a 2-param tool with 0% schema coverage.

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

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

Input schema has 0% coverage. Description compensates fully: explains item filters to single bank, type filters by account type, and omitting item aggregates all connections. Provides meaning beyond schema.

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

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

Description clearly states it returns accounts for bank connections, listing specific fields. It distinguishes between listing all accounts (omit item) versus a single bank (pass item), and differentiates from siblings 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 explains when to omit item for aggregated list vs pass item for single bank. Warns about connector-dependent CREDIT balance and directs to another tool for standardized amounts. Also notes provider_incident block and advises not to present unreliable values.

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 and that the response is a single aggregated entity with no batch ids, which provides useful behavioral context beyond annotations.

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

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

Description is three sentences, each adding value: purpose, field details, and response nature. No fluff, front-loaded with the core action.

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

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

Given no parameters, rich annotations, and clear field description, the description is fully complete for this simple listing tool. No output schema needed as fields are explained.

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

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

There are zero parameters, so the description carries the full burden. It adds meaning beyond the empty schema by detailing each response field (id, description, descriptionTranslated, parentId, parentDescription) and their 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?

Description clearly states it returns Pluggy's transaction category taxonomy (GET /categories), cached for the session. It distinguishes from siblings by specifying that the `id` field is used by `openfinance_update_transaction_category`, making its purpose and relationship explicit.

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 notes it is cached and a single aggregated response, implying it should be called once per session. While it doesn't explicitly state when not to use it, the context of no sibling category tools makes this 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds value by specifying returned fields and the purpose of add_connection_url. 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?

Single sentence with no waste. Front-loaded with purpose and includes key details in a compact form.

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

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

Given no parameters and no output schema, the description covers purpose and return fields sufficiently. However, it lacks details on ordering, pagination, or response size limits, which could be useful.

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

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

Input schema has zero parameters, so description cannot add parameter meaning. Baseline for 0 params is 4. Description does not need to discuss 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 'Returns the saved bank connections for this install' with specific fields (connector_id, item_id, bank name, add_connection_url). It distinguishes from sibling 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?

Description implies usage for listing bank connections of the current install but does not explicitly state when to use this tool versus alternatives like openfinance_list_accounts or openfinance_list_transactions. No exclusions or when-not guidance is provided.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and the description aligns, focusing on reading bills. It adds significant behavioral details beyond annotations: payment matching logic, derived payment_status, cross-bill checks, connector-specific open bill limitations, and warnings. There is no contradiction; the description enriches the agent's understanding of safe, read-only behavior.

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

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

The description is extremely verbose, spanning multiple paragraphs with detailed explanations that could be condensed. While it front-loads the core purpose ('Returns CLOSED credit card bills for a CREDIT-type account'), the overall length reduces conciseness. Not every sentence earns its place; for example, the detailed payment_status legend could be summarized.

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 its length, the description is comprehensive for the tool's complexity. It covers Brazilian Open Finance semantics, derived payment_status, cross-bill matching, connector asymmetry, open bill opt-in with fallback, bulk support, and warnings. Since there is no output schema, the description thoroughly explains return fields (payments[], payment_status, open_bill, etc.), making it complete for an agent to 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 description coverage is 0%, so the description must compensate. It explains include_open_bill extensively (opt-in, derived fields, connector asymmetry) and mentions account_ids for bulk support. However, page and page_size parameters are not described at all. The description adds meaning beyond the schema for some parameters but not all, resulting in an adequate but incomplete coverage.

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

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

The description clearly states it returns CLOSED credit card bills for a CREDIT-type account, listing specific fields like dueDate, totalAmount, payment_status, etc. It distinguishes itself from siblings such as openfinance_list_transactions (individual transactions) and openfinance_get_credit_card_bill (singular bill), providing a clear, specific verb+resource combination.

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 offers extensive guidance: when to use (retrieving closed bills), when not to (for individual transactions, use openfinance_list_transactions), and explicit caveats (do not assume bill paid based on payments[], use derived payment_status, caution with connector asymmetry for open bills). Alternative tools are mentioned, providing clear context for selection.

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

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

Annotations indicate readOnlyHint, idempotentHint, destructiveHint. Description adds that it returns a specific error-handled response (total, results, warning) and lists data fields. 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?

Single sentence with inline list, front-loads purpose. Not overlong, but could be more structured. Acceptable.

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 what tool returns and response structure, but lacks parameter semantics and usage context. Without output schema, partial coverage of return values.

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% and description does not explain any parameter (item, page, type, page_size). The term 'connection' is used but not linked to 'item'. No added meaning.

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

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

The description clearly states it returns investment portfolio for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.) and response fields. It distinguishes from siblings 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?

No explicit when-to-use or when-not-to-use guidance. It mentions error handling but does not clarify prerequisites (e.g., connection ID needed) or 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 read-only and idempotent behaviors. The description adds value by detailing the output structure (fields like quantity, value, expenses) and bulk support. It does not mention pagination behavior, but overall adds useful behavioral context without contradicting annotations.

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

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

The description is concise with two paragraphs, front-loading the key purpose and output fields. It avoids redundancy but could benefit from structured formatting (e.g., list of fields). No wasted words.

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

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

Given the tool's complexity (multiple transaction types, many fields, bulk, pagination), the description covers main purpose, relationship to list_investments, and bulk support. However, it misses pagination details (page, page_size) and any default ordering or limits. Adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains investment_id (required) and investment_ids (for bulk). However, it does not mention page and page_size parameters, leaving their purpose unclear. Thus partial compensation.

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, lists transaction types (BUY/SELL/TAX/INTEREST/AMORTIZATION/TRANSFER) and response fields. It is distinct 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?

The description explicitly tells to use after openfinance_list_investments to get investment_id, which provides sequential use guidance. It also mentions bulk support. However, it does not explicitly state when not to use or compare with alternatives like openfinance_list_transactions.

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

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

Discloses behavioral details beyond annotations: sequential querying with rate-limit spacing when multiple connections are specified, and the return format (`{ results, errors }` per connection). Annotations already indicate read-only and idempotent, which the description supports.

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 efficient sentences: first states purpose and endpoint, second details parameter usage and behavior. Every sentence adds value, no fluff.

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

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

Despite no output schema, the description specifies the return structure and behavior for single vs. multiple connections, making it fully complete for effective agent usage.

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

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

With schema coverage at 0%, the description fully explains that `items` is an array of connection selectors (item_id uuid, connector_id, or connector_name), adding essential meaning absent from the schema.

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

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

The description clearly states it lists loan contracts per bank connection, naming the endpoint and differentiating from sibling tools (e.g., list_accounts, list_transactions) by focusing specifically on loans.

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

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

Provides clear instructions on how to use the optional `items` parameter to specify connections, or omit for all banks. Implicitly distinguishes usage but does not explicitly state when not to use this tool vs. 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 and idempotentHint. Description adds extensive behavioral details: auto-pagination up to 5000 with truncation, per-connector variability in pending/posted, error handling returning warnings instead of throwing, provider incident block, and the need to cross-check account echo. 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?

Description is thorough but lengthy (multiple paragraphs). While every sentence adds value, it could be more concise. Front-loaded with core purpose, but overall structure is dense.

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

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

Without an output schema, description covers response structure (account echo, creditCardMetadata, provider_incident block), error formats, and edge cases like truncation, pending/posted variability, and check of connection health. Complete for a complex tool.

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

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

Schema coverage is 0%, but description compensates by explaining every parameter: from/to date format, page and page_size for manual pagination, detail levels with caveats, search_queries semantics, account_id required, and account_ids for batch. Provides concrete usage notes.

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 'Returns transactions for a bank account' and distinguishes between BANK and CREDIT types. It explicitly differentiates from sibling tools like openfinance_list_credit_card_bills and openfinance_list_accounts, specifying when to use each.

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

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

Provides detailed guidance on when to use this tool versus alternatives, including handling of credit card transactions, pagination strategies, detail levels, and warnings about inconsistent billId. Offers specific advice for troubleshooting empty results.

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 important behaviors beyond annotations: scanning cap at 5000/account with truncation flag, provider incident block affecting data completeness, and differences between granularity levels. Annotations already indicate readOnly and idempotent, which are consistent.

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 dense and front-loaded with the core purpose, but it is somewhat long and could be slightly more structured. Still, every sentence adds value for such a complex tool.

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

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

Covers all aspects: usage scenarios, parameter details, default behavior, edge cases (truncation, provider incidents), and different response formats. No output schema exists, so description must provide completeness, which it does.

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?

Explains most parameters in detail (item, from/to, granularity, detail, type) but does not explicitly describe the top_n parameter (only implied in top_despesas/recebimentos). Schema coverage is 0%, so description bears full burden.

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

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

Clearly states it provides consolidated cash-flow analysis for a bank connection in one call, resolving accounts internally. Distinguishes from sibling tools like openfinance_list_accounts by eliminating the need for prior account_id.

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 says when to use (análise annual/mensal, fluxo de caixa, etc.) and when not to call other tools first (no need to list accounts). Provides guidance on omitting item for all banks, and when to use raw granularity.

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

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

The description discloses the return structure (global indicator, degraded components, open incidents, `your_banks_affected`) and explains its operational behavior (checking a public status page, not your own connection). Annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds value without contradiction. A 5 would require mention of rate limits or data freshness, but it's still strong.

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

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

The description is relatively verbose but every sentence adds distinct value: purpose, distinction from sibling, usage scenario, and return details. It could be slightly tighter (e.g., 'LIVE' vs 'live'), but it is well-structured and front-loaded with the key 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?

The description fully covers what the tool returns (global indicator, components, incidents, `your_banks_affected`) and explains how to interpret the results. Given that there is no output schema, this level of detail is essential and complete for the 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 zero input parameters, and schema description coverage is 100%. The description does not add parameter-level semantics (none exist), but it compensates by detailing the output fields and their meaning, which helps the agent understand what the tool returns without needing to call it first.

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 ('Checks the LIVE operational status') and clearly identifies the resource ('Open Finance provider (its public status page)'). It explicitly distinguishes this tool from the sibling `openfinance_get_item_status`, which checks connection health, not provider health.

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

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

The description provides explicit guidance on when to use this tool ('whenever data looks incomplete or stale even though a connection shows UPDATED') and what problem it solves (distinguishing upstream outage from connection issues). It also names the alternative tool (`openfinance_get_item_status`) for connection-specific status.

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

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

Annotations indicate readOnlyHint=true and idempotentHint=true, and description adds significant context: returns connector details, user's linked connections, connect_url, honors plan, returns hint if no keywords, and discloses the caveat about non-Open-Finance connectors not auto-updating. 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?

Description is well-structured, front-loaded with main action, then details return values, caveat, and usage instruction. Every sentence adds value with no wasted words.

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

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

Given no output schema, description adequately describes the full return per match, including the caveat and plan behavior. It covers error handling (hint if no keywords) and usage context, making it complete for a search 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?

Schema has no descriptions (0% coverage), but description fully explains both parameters: keywords[] with examples and requirement, include_accounts with behavior when true. It adds meaning beyond the bare schema.

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

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

Description clearly states it searches bank connectors by name, lists returned fields (id, access, audience, connections, connect_url), and distinguishes from siblings by specifying it should be called before connecting. It also notes that it never dumps the whole catalog, reinforcing its purpose.

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

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

Explicitly states to call 'BEFORE connecting' and that keywords are required, with a hint if omitted. It mentions the caveat for non-Open-Finance connectors and suggests preferring Open Finance for automation, but does not explicitly compare to sibling tools like list_connections or list_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?

Discloses that it overrides automatic categorization and teaches Pluggy by creating a category rule, and details batch behavior (per-item errors do not fail the whole batch). Annotations provide no such detail.

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 packs all essential information but is slightly lengthy; however, every sentence adds value and the main action 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?

Covers all necessary context for a batch mutation tool: parameters, side effects, error handling, and response shape, despite no output schema.

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

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

Despite 0% schema coverage, the description thoroughly explains that items is an array of { transaction_id, category_id } and where to obtain those IDs, adding meaning beyond the schema structure.

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

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

Clearly states it corrects the category of transactions with the specific API endpoint PATCH /transactions/:id, and distinguishes from siblings by referencing where to get transaction and category IDs.

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

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

Explicitly explains when to use (fix miscategorized transactions), notes the side effect of creating a category rule for future similar transactions, and provides context on batch error handling.

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

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

Annotations already indicate non-destructive and idempotent behavior. The description adds the requirement to include the conversation array but does not disclose other behavioral aspects like authentication needs or server response. It provides marginal additional 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?

Two sentences that are front-loaded and concise. The first sentence effectively states the purpose. Could be slightly more structured but is efficient overall.

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

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

For a simple bug-report tool with 3 parameters and no output schema, the description is adequate but lacks details like expected outcome or any confirmation. It is minimally complete but could be more informative.

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 mentions 'conversation array' for reproduction, adding meaning beyond raw schema, but doesn't explain 'context' or 'message' beyond their names. It partially compensates but is insufficient for the low coverage.

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

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

The description clearly states the tool's purpose: 'Report a bug, missing feature, or send feedback.' This is specific and distinguishes it from siblings, which are all about 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?

The description advises to 'Include the conversation array with recent messages for reproduction,' providing clear guidance on what to include. While no explicit when-not-to-use is given, the sibling tools are unrelated, so usage 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, so the description adds the specific output (platform and adapter). No contradictions. It could mention caching or stability but not required for this simple tool.

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

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

Single sentence, perfectly concise, 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?

As a parameterless version tool, the description completely covers what the tool does. No output schema needed.

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

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

No parameters exist, so description adds no parameter info beyond schema. Baseline score of 4 is appropriate given zero parameters.

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

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

The description clearly states it shows MCP platform and adapter versions, which is specific and unambiguous. No sibling tool does this, so it's well-differentiated.

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 it's for checking versions, and given the sibling tools are mostly finance and auth operations, the usage context is clear. However, it lacks explicit guidance on when not to use it.

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

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

Annotations already declare readOnlyHint and destructiveHint, so the description's role is to add behavioral context. It specifies exactly what is returned (installed MCPs, connection status, catalog tool counts), which goes beyond annotations.

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

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

A single, focused sentence that front-loads the purpose and lists specific return contents. 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?

With zero parameters and no output schema, the description and annotations together provide a complete specification of the tool's behavior. No additional information is needed.

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

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

No parameters exist; schema coverage is 100% (empty). Baselines at 4 since no parameter information is needed. Description adds no parameter semantics but that is not required.

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 retrieves toolkit state including installed MCPs, connection status, and catalog tool counts. This is specific and distinguishes it from sibling tools that focus on financial operations 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?

No explicit usage guidelines are provided, but the tool's purpose is self-explanatory given it is the only informational tool among siblings. Implicitly it should be used when toolkit state is needed.

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