Banco Sofisa MCP

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

Annotations show idempotentHint=true and destructiveHint=false. The description adds detail about the authentication flow (browser login, token paste) and session permanence, which goes beyond annotations. 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 a single, well-structured sentence that efficiently conveys all necessary information without redundancy. Every phrase 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?

For a simple authentication tool with one optional parameter and no output schema, the description covers the most important aspects: login methods, token usage, and configuration hint. Minor improvement could be mentioning any side effects (e.g., session expiration).

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 optional token parameter with 0% description coverage. The description explains its purpose ('paste token for session login') and provides context on when to omit (to get a login link). This adds significant meaning 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?

The description explicitly states the tool is for authentication, targeting IDE agents, and explains the two authentication methods. This clearly distinguishes it from siblings like 'connect' or 'toolkit_info'.

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 when-to-use guidance: permanent config vs session-based login. Also suggests an alternative (adding to config header) for permanent setup, which is explicit context for the agent.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, indicating a safe, read-only operation. The description adds valuable context about return content (authenticated, pending, URLs) 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?

Two short sentences that are front-loaded, stating the tool's purpose first then elaborating with specific scenarios. Every word adds value; 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?

For a tool with no parameters and no output schema, the description covers key aspects: what it returns and under what conditions. It could be improved by specifying the exact structure of the response, but is adequate for a simple status check.

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 are defined, and the schema coverage is 100% (empty schema). Baseline for 0 parameters is 4. The description does not add parameter-level meaning but instead clarifies the output.

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 output details for different states (all providers connected vs missing credentials). It effectively distinguishes from sibling 'authenticate' which handles authentication initiation.

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

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

The description provides context about when to use (checking connection status) but does not explicitly state when not to use or mention alternative tools. It lacks explicit usage guidance beyond describing behavior.

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

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

The description discloses many behavioral traits beyond annotations: invoke works even when MCP is not installed, returns connect link if credentials needed, returns checkout link if wallet empty, and contrasts one-off invoke with permanent install. It explains that install/uninstall/subscribe/cancel and the behind-the-scenes install in invoke require owner/admin. This adds significant context beyond the basic annotations.

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

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

The description is well-structured with logical flow but is verbose, repeating the invoke vs install distinction multiple times. It could be more concise while preserving clarity. Front-loaded key message.

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 (15 params, multiple actions, no output schema), the description covers the main use cases, core flow, and edge cases (connect/checkout links). It is complete enough for an agent to use correctly, though it lacks detail on error responses and parameter validation.

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 15 parameters and 0% schema description coverage, the description compensates by explaining the roles of key parameters (action, query, mcp_id, tool_id, arguments) and the flow between them. However, it does not detail each parameter's format or constraints, leaving some burden on the schema. Still, it adds substantial meaning beyond the enum names.

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 identifies the tool as the official mcp.ai marketplace, the in-platform catalog and execution engine. It specifies the core flow (search → describe → invoke) and distinguishes this tool from external registries with explicit instruction to 'use THIS tool FIRST'. The purpose is specific and unambiguous.

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

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

The description provides extensive usage guidance: it instructs when to use this tool vs external registries, distinguishes between invoke (one-off) and install (permanent) with clear criteria, explains when to use list_tools, subscribe/cancel, report_bug, and request_mcp. It also notes that write actions require workspace owner/admin privileges.

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 show destructiveHint=true, and description adds context: data becomes unavailable and returns an add_connection_url for reconnection. This goes beyond annotations.

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

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

Description is short and front-loaded with main action, but lacks structure (e.g., bullet points). Every sentence is useful.

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 being a destructive tool with one parameter, the description omits parameter details, error handling, and prerequisites. Context is insufficient for an agent to confidently invoke.

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 required parameter 'item' with 0% description coverage. The description does not explain what 'item' refers to, leaving the agent without guidance.

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 revokes consent and deletes connection data, with specific verb and resource. It distinguishes from sibling openfinance tools by explicitly mentioning disconnection.

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

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

No explicit guidance on when to use this tool versus alternatives. Does not mention prerequisites, when not to use, or compare to similar tools like openfinance_force_sync.

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 fields (status, executionStatus, lastUpdatedAt, synced, needs_action, timed_out), and condition for re-checking with another tool. Does not contradict any annotation; annotations are minimal so description carries full burden and fulfills it well.

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

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

Front-loaded with purpose 'Forces the bank to re-sync...', then usage, parameters, and return details. Every sentence adds value; no redundancy. Dense but 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?

No output schema, yet description details return structure { results, errors } with fields. Covers edge cases like needs_action and timed_out. For a tool with 2 params and no output schema, it is fully complete.

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

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

Schema coverage is 0%, yet description explains items as array of selectors (item_id, connector_id, connector_name) with option to omit for all, and wait boolean with effect. Adds meaning beyond type-only 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 explicitly states the tool forces a re-sync and waits for completion, with specific verb and resource. It distinguishes from sibling tools like openfinance_get_item_status (mentioned as fallback) and explains use case for stale data.

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?

Clearly says 'Use this when a balance or transaction list looks stale' and explains difference from reconnecting. Also provides guidance on wait parameter (fire-and-forget vs wait). No exclusions but sufficient 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 declare readOnlyHint, idempotentHint, and destructiveHint. Description adds critical details: potential BALANCE_FETCH_ERROR for credit accounts with warning, graceful degradation to last-synced balance with `realtime: false` and warning. 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 3-4 sentences, front-loaded with purpose, no filler. Every sentence adds value: endpoint, parameter, edge cases, response shape.

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, description includes response shape. Covers input constraints, error handling, degradation behavior. Complete for a balance retrieval tool with moderate complexity.

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

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

Only parameter is `account_ids`. Schema has no description (0% coverage). Description adds that it must be an array of strings, 1–50 items. This fully compensates for the schema gap.

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

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

The description clearly states the tool returns 'real-time balance payload per account id' with the specific endpoint. It distinguishes itself from sibling tools by focusing on balance retrieval.

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

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

Explicitly instructs to pass `account_ids` as an array with limit 1-50. Covers edge cases: CREDIT accounts may return a warning, and upstream failures degrade gracefully. Provides clear when-to-use context without needing 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 mark the tool as readOnly, idempotent, and non-destructive. The description adds valuable behavioral context: the provider_incident block and unreliability of credit limits during provider outages. This goes beyond annotations.

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

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

Three sentences, each earning its place: first announces the action and endpoint, second describes parameter and batch shape, third warns about special cases. No fluff, front-loaded with core 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 explains the return shape (results/errors) and the provider_incident block. It mentions extended creditData but does not detail its structure. Given no output schema, this is fairly complete for a single-parameter tool.

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

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

The schema has only one parameter (account_ids) with no descriptions (0% coverage). The description adds meaning by stating 'Pass account_ids as an array (1–50)', imposing a size constraint and implying the array contains account IDs. This compensates well 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 'Returns full account objects including extended creditData per id (GET /accounts/:id)', specifying the action (returns), resource (account objects), and distinguishing detail (full objects with creditData). It implies this is the detailed version compared to list 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 provides usage context by specifying the account_ids parameter as an array (1–50) and the batch shape. It warns about provider incidents affecting reliability, but does not explicitly state when to use this tool versus sibling tools like openfinance_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?

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds critical context: payments[] reflects payments registered during the bill's billing cycle (typically previous bill), Pluggy does not return a paid/status field, and the tool does not return individual transactions. 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 fairly long but each sentence serves a purpose: first states what it does, then what it does not do, then usage instructions, then caveats. It is well-structured and front-loaded with the main purpose. Could be slightly trimmed, but justified by the complexity of the domain.

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 is provided, but the description explains the batch shape ({ results, errors }) and the key fields in each bill detail. It also notes the caveat about payments[] and the lack of paid/status field. Given the tool's domain complexity (Brazilian Open Finance, credit card bills), this provides sufficient context for an agent to use it 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 compensate. It explains that bill_ids is an array and should be populated after a call to openfinance_list_credit_card_bills. It does not specify the exact format of the IDs (e.g., string UUIDs), but the purpose and usage are clear. This adds significant value beyond the raw schema.

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

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

The description clearly states it returns bill-level detail for credit card bills by ID, enumerates included fields (financeCharges, payments[] with subfields), and explicitly distinguishes from openfinance_list_transactions by stating what it does NOT return. The verb 'get' and resource 'bill detail' are 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?

Explicit guidance provided: use openfinance_list_credit_card_bills first to discover IDs, pass bill_ids as an array, and when to use openfinance_list_transactions instead. Includes warnings about not reconstructing totals from transactions and interpreting payments[] correctly in Brazilian Open Finance 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?

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds details about the return structure: status, executionStatus, connector metadata, and the response format for all vs. single bank. 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?

Two concise sentences that front-load the core purpose, with zero wasted words and clear structure.

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 read-only tool with annotations, the description covers main usage and return structure. Minor gaps: no mention of error handling or authentication requirements, but these are partially covered by annotations.

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

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

With 0% schema description coverage, the description explains the two usage modes (omit vs. pass 'item'), but does not specify the expected format or allowed values for the 'item' parameter (e.g., bank connection ID), leaving ambiguity.

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 that the tool returns the status of bank connections, listing possible values (UPDATED, UPDATING, LOGIN_ERROR, etc.) and distinguishing between behavior when 'item' is omitted vs. provided.

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

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

Provides clear guidance on when to omit or pass the 'item' parameter to get all banks vs. a single bank. However, it does not explicitly compare with sibling tools like 'openfinance_list_connections' to advise when to use this tool over 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, idempotentHint=true, and destructiveHint=false. The description adds significant behavioral detail beyond annotations, such as the exact fields returned (e.g., interestRates[], balloonPayments[], installments schedule) and the batch response shape `{ results, errors }`. This gives the agent a clear picture of what the tool does and returns, 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 a single paragraph but efficiently front-loads the key action and lists important return fields. It includes usage guidance and parameter constraints. While a more structured format (e.g., bullet points) could improve readability, it is reasonably concise and contains 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 (many return fields) and no output schema, the description enumerates the key fields and mentions the batch shape. It does not explain error handling or edge cases for invalid IDs, but for a read-only tool with good annotations, it provides sufficient context for an agent to use it effectively after listing loans.

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% (no descriptions in the schema). The description compensates by explaining that `loan_ids` is an array of loan IDs with a range of 1-50 items, which is not present in the schema. It adds meaning beyond the raw schema, though it could further clarify that these IDs come from openfinance_list_loans.

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

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

The description clearly specifies that the tool returns full loan contract detail by ID, listing many specific fields (interestRates, contractedFinanceCharges, etc.) and the HTTP endpoint. It also distinguishes itself from the sibling tool openfinance_list_loans by stating 'Use after openfinance_list_loans to deep-dive on a specific contract.' This provides a specific verb+resource with sibling differentiation.

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

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

The description explicitly says to use this tool after openfinance_list_loans, providing clear context. It also specifies the parameter constraints: 'Pass `loan_ids` as an array (1-50).' However, it does not explicitly state when not to use it or offer alternative tools beyond the one mentioned. Still, the guidance is clear and helpful.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds significant context: explains that 'name' is the legal entity not the brand, that CREDIT balance is connector-dependent, and that a provider_incident block may indicate unreliable data.

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, front-loading key info then adding necessary details. Each sentence adds value, though some could be tightened. Slightly verbose but justified by 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 no output schema, the description explains return fields (balance, number, type, etc.) and covers edge cases like provider_incident. Missing pagination or response format details, but sufficient for the tool's purpose.

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

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

Schema description coverage is 0%, so description must compensate. It explains the 'item' parameter well (omit for all, pass for single). However, the 'type' parameter (BANK/CREDIT) is only implicitly covered in the purpose; no explicit guidance on filtering by type is provided.

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 accounts for a bank connection, distinguishing between BANK and CREDIT types with detailed fields. It also differentiates from the sibling tool openfinance_list_credit_card_bills by specifying that the latter provides standardized bill amounts.

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 instructions: omit 'item' to list all accounts, pass 'item' for a single bank. Warns about the connector-dependent meaning of CREDIT balance and note on provider_incident affecting reliability. Also directs to the sibling tool for standardized bill amounts.

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

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

Annotations declare readOnlyHint, idempotentHint, destructiveHint. The description adds caching behavior, response structure, and the note about no batch ids, 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?

Four concise sentences, front-loaded with core function. No wasted words; every sentence adds value.

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

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

Given no parameters and no output schema, the description fully explains the tool's purpose, response structure, and caching behavior, making it complete for this simple 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?

No parameters are defined, and schema coverage is 100%. Baseline for 0 params is 4. The description adds no parameter info but compensates by detailing response fields, which is relevant for understanding the output.

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

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

The description clearly states the tool returns Pluggy's transaction category taxonomy, cached for the session. It specifies the source and that it lists categories, which is distinct from sibling tools that focus on accounts, transactions, etc.

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

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

The description implies the tool is useful before updating transaction categories (by mentioning categoryId used by openfinance_update_transaction_category), but does not explicitly state when to use or alternatives. Minimal guidance.

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, indicating a safe read operation. The description adds value by listing the specific returned fields and the add_connection_url, which provides actionable context beyond the annotations.

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

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

The description is a single concise sentence that front-loads the core purpose and then enumerates the key data elements. Every part is valuable and there is 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?

Despite no output schema, the description clearly communicates what the tool returns (specific fields and the add_connection_url). With no parameters and safe annotations, the description is complete for the tool's purpose.

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

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

The input schema has zero parameters and 100% schema coverage, so the baseline is 4. The description does not need to add parameter semantics and correctly focuses on the output.

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 it 'Returns the saved bank connections' and lists specific fields (connector_id, item_id, bank name, add_connection_url). This clearly distinguishes it from sibling tools like openfinance_list_accounts or openfinance_list_transactions, as it focuses on connections rather than transactions or accounts.

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

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

The description implies usage for listing saved connections but does not provide explicit guidance on when to use this tool versus alternatives (e.g., openfinance_get_item_status or openfinance_list_accounts). No when-not-to-use or alternative suggestions are offered.

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 traits beyond annotations: detailed payment status derivation, connector asymmetry, bill grouping reliability, and the derived open_bill limitations. 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?

Long but well-structured with clear sections (IMPORTANT, OPEN BILL, CONNECTOR ASYMMETRY). Front-loaded with core purpose; every paragraph adds unique value. Appropriate for the complex domain.

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 high domain complexity, 0% schema coverage, and no output schema, the description is extraordinarily complete: it defines return fields, edge cases, connector differences, and even provides scripting guidance for presenting 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?

Despite 0% schema coverage, the description thoroughly explains all parameters: account_id (identifies card/bank), account_ids (batch execution), include_open_bill (opt-in with extensive detail on derived data), and implies pagination via the mention of results 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 returns CLOSED credit card bills for a CREDIT-type account with specific fields. Distinguishes from sibling tools like openfinance_list_transactions by explicitly stating it is not for 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?

Provides explicit usage guidance: when to use this tool vs openfinance_list_transactions for itemized purchases, when to use open_bill vs balance, and explains the opt-in nature of include_open_bill due to extra scan cost.

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

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

Annotations indicate read-only, idempotent, non-destructive. The description adds valuable context: returns a default object on 403 errors and lists response fields (balance, rates, etc.), enhancing transparency beyond annotations.

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

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

Single paragraph with dense information covering purpose, asset types, and response fields. Could be more structured with bullet points, but 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?

No output schema, but description details many response fields (balance, amounts, rates, dueDate, etc.) and error handling. Sufficient for agent to understand return format.

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

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

Schema has 0% coverage, so description must explain parameters. It does not: 'item', 'page', 'type', 'page_size' are not described. Only hints at 'type' by listing asset types, but not explicitly.

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

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

The description clearly states the tool returns investment portfolio for a connection, listing specific asset types. It distinguishes from sibling tools like openfinance_list_investment_transactions by focusing on portfolio summary.

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 using this tool to get portfolio data and mentions error handling behavior, but does not explicitly state when not to use or compare to 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, idempotentHint=true, destructiveHint=false. Description adds detail about returned data structure (fields like quantity, value, etc.) and bulk support, which reinforces non-destructive behavior. No contradiction, but doesn't add further behavioral traits like authentication or rate limits.

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 plus a brief bulk support note. Front-loaded with purpose and key fields. No redundant information; every sentence adds value.

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

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

Given 4 parameters, no output schema, and annotations present, the description covers the tool's purpose, typical usage flow, and bulk option. Missing pagination parameters slightly reduce completeness, but overall provides sufficient context for an AI agent.

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

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

Schema has 0% description coverage; description mentions investment_id and investment_ids (for bulk) but omits page and page_size parameters. It explains investment_id's role via usage flow, but pagination parameters are not addressed, leaving a gap.

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

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

Clearly states it returns movement history for a specific investment position, listing transaction types (BUY, SELL, etc.) and fields. Distinguishes from sibling tool openfinance_list_investments by specifying it is used after that to get the investment_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 'Use after openfinance_list_investments to get the investment_id,' providing sequential guidance. Mentions bulk support for batched execution. Does not explicitly exclude other cases or compare with other tools like openfinance_list_transactions, 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 indicate readOnlyHint, so description adds value by detailing sequential fetching per connection and the return structure (`{ results, errors }`). No contradictions.

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

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

Three sentences with no wasted words. Front-loaded with purpose, then usage details, then parameter explanation. Efficient and scannable.

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 strong annotations and no output schema, the description covers parameter usage, behavior (sequential), and return shape. Could mention result structure more, 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 no descriptions (0% coverage), but description explains `items` as an array of connection selectors (item_id, connector_id, or connector_name) and their role. Sufficiently compensates for schema gaps.

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 specifies a clear verb ('Lists') and resource ('loan contracts per bank connection') and the HTTP endpoint. It distinguishes from sibling list tools (e.g., accounts, transactions) by targeting loans specifically.

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

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

Provides explicit guidance on when to omit `items` (list all banks) versus provide connections (per connection), and mentions sequential querying with rate-limit spacing. Lacks explicit alternatives or 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 indicate readOnly and idempotent. The description adds extensive behavioral detail: pagination auto vs manual, error handling returns {total:0,...}, detail levels, credit card metadata caveats (sparse/inconsistent billId), connector-specific PENDING/POSTED behavior, upstream incident handling, and bulk support. 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 lengthy but well-structured, front-loaded with purpose and key guidance. Every section adds value, though some repetition (e.g., billId caveat appears twice) could be streamlined. Overall, it is organized logically.

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

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

Given no output schema, the description covers response structure (account echo, truncated flag, provider_incident), error scenarios, and integration with other tools. It addresses edge cases, limitations, and provides actionable advice, making it fully comprehensive.

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

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

Schema coverage is 0%, so description carries full burden. It explains all 8 parameters: account_id required, from/to date format (ISO YYYY-MM-DD), search_queries case-insensitive with OR semantics, page and page_size interaction, detail enum meanings, account_ids for bulk. It also clarifies usage constraints like 5000 ceiling.

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

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

The description clearly states it returns transactions for bank accounts (BANK or CREDIT). It explicitly distinguishes itself for CREDIT accounts as the only way to get itemized transactions, and differentiates from sibling tools like openfinance_list_credit_card_bills and openfinance_list_transactions_by_item.

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: it's the only way for credit card itemized transactions. It also gives when-not-to-use: do not sum billId to get bill total; instead use openfinance_list_credit_card_bills. It advises checking connection health if total is 0. Alternatives are named clearly.

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

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

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description discloses important behavioral traits: 5000/account scan cap with 'truncated:true' flag, provider_incident block for open incidents, and that 'raw' granularity gives consolidated transactions (heavier). 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 detailed but every sentence adds value. It is front-loaded with the primary purpose and progressive details. Could be slightly more concise, but the complexity of the tool (7 params, multiple modes) justifies the 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?

No output schema exists, yet the description covers return values: default compact summary (total entradas, saídas, etc., monthly evolution, top entries, per-account breakdown) and raw mode with consolidated transactions. Also mentions 'provider_incident' and 'truncated' flags. Complete for the tool's complexity.

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

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

Input schema has 0% description coverage, so the description fully details all 7 parameters: 'item' (connector_id/connector_name/item_id, can be omitted), 'from'/'to' (ISO dates), 'granularity' (monthly vs raw), 'type' (BANK/CREDIT), 'top_n' (implied by top metrics), 'detail' (compact/rich/raw with explanations). Adds meaning beyond schema enums.

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 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call' and distinguishes it from related sibling tools by explaining it resolves accounts internally. It lists specific use cases like 'análise anual/mensal', 'fluxo de caixa', etc.

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

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

Explicit guidance on when to use this tool vs alternatives: 'you do NOT need to call openfinance_list_accounts first nor carry account_id uuids between calls'. Also specifies when to omit 'item' to target all banks, when to use 'raw' granularity, and how detail parameters affect 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds behavioral details such as returning live data from a public status page, listing specific fields, and noting the 'your_banks_affected' feature. Could mention potential rate limits or update frequency but still 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 three sentences long, each conveying essential information. It is front-loaded with the core function and then provides usage context and return details. Slightly verbose but not wasteful; could be condensed slightly but still effective.

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

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

Given no parameters and no output schema, the description fully covers what the tool does, when to use it, and what it returns. No gaps in context for an agent to select and invoke the tool correctly.

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

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

There are no parameters in the input schema, so the description does not need to explain parameter meanings. Baseline for 0 parameters is 4, and the description appropriately focuses on behavior and output rather than 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, distinguishing it from the sibling tool openfinance_get_item_status. It specifies what is returned (global indicator, degraded components, incidents, your_banks_affected), making the purpose very specific and actionable.

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 this tool: when data looks incomplete or stale despite a connection showing UPDATED. Contrasts with connection-level status and explains it helps distinguish provider-side problems from connection issues, providing clear context for usage.

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

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

The description discloses important behaviors beyond annotations: it returns a connect_url, some connectors carry a caveat about non-auto-update, it honors the user's plan (PF hides PJ banks), and it returns a hint when keywords are missing. These details add significant transparency for agent decision-making.

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 every sentence adds value, covering main action, output, caveats, and usage. It is well-structured with important details front-loaded. Minor tightening could improve conciseness, but overall it is 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?

The description is remarkably complete for a search tool without an output schema. It lists all returned fields, handles edge cases (missing keywords, caveats, plan filtering), and provides clear usage instructions. No significant gaps remain.

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

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

Despite zero schema description coverage, the description fully explains both parameters: keywords as an array of strings (with examples) and its requirement, and include_accounts as a boolean that triggers returning accounts. This compensates for the schema gap and provides clear 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's purpose: searching bank connectors by name and returning detailed information including a connect_url. It specifies the verb 'searches', the resource 'bank connectors', and the exact output fields, making it easy for an agent to understand what the tool does and how it differs 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 advises to call this tool 'BEFORE connecting to hand the user a one-click link to the right bank,' providing clear context. It also notes that keywords[] is required and without it returns a hint, guiding proper usage. However, it does not explicitly contrast with sibling tools like list_connections or provider_status, but the usage 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?

Goes beyond annotations (readOnlyHint=false) by detailing the teaching side effect (creates Category Rule), batch error handling (per-item errors), and override of automatic categorization. Annotations are not contradicted.

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?

Well-structured: starts with action, then parameter details, side effects, and return format. Somewhat lengthy but all information is necessary; could slightly tighten without losing clarity.

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

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

Given complexity (batch update, side effects, error handling) and no output schema, the description covers all essential aspects: parameters, behavior, return structure, and integration with 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 coverage is 0% but the description fully documents the single parameter `items`, including required fields (transaction_id, category_id), their origins from sibling tools, and the return shape. Adds complete semantic 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?

Explicitly states the tool 'corrects the category of one or more transactions' (PATCH /transactions/:id). Clearly distinguishes from sibling read tools like openfinance_list_transactions and openfinance_list_categories.

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

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

Provides clear context: use to fix miscategorized transactions, with instructions on sourcing transaction_id and category_id from sibling tools. Lacks explicit 'do not use when' but the side effect (teaching) is noted, helping agents decide.

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 does not address the contradiction between the idempotentHint annotation (true) and the typical non-idempotent nature of reporting. No behavioral traits beyond the annotation are disclosed.

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

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

The description is concise with two sentences, front-loading the purpose. However, it could be slightly more structured (e.g., listing parameters).

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

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

The tool is simple, but the description omits details about response behavior, side effects, and expected outcomes beyond reproduction. Without an output schema, more completeness 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?

With 0% schema description coverage, the description only partially explains the 'conversation' parameter, leaving 'message' and 'context' undocumented. This fails to compensate for the schema gap.

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

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

The description clearly states three specific purposes (report bug, missing feature, send feedback) and distinguishes itself from sibling tools which are primarily API-related.

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

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

The description provides context on when to use the tool (for bugs/feedback) and advises to include the conversation array, but lacks explicit guidance on when not to use it or mention of 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?

The description adds specific behavioral context (what versions are shown) beyond the annotations (readOnlyHint, idempotentHint). No contradictions. The tool's behavior is fully transparent.

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 words. Every part is essential 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 zero parameters and no output schema, the description fully captures what the tool does and returns. No additional information is needed.

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

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

There are no parameters, so the description does not need to add meaning to the input schema. According to guidelines, 0 parameters earns a baseline of 4.

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

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

The description clearly states the action ('Show') and the resource ('current MCP platform and adapter versions'). It distinguishes itself from sibling tools, none of which 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?

While the description does not provide explicit when-to-use or alternatives, the tool's simplicity and zero parameters make its usage self-evident. It could mention that it is safe to call anytime, but this is not necessary given the 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 already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable context by specifying exactly what data is returned (installed MCPs, connection status, catalog counts), going beyond annotations.

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

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

The description is a single concise sentence that is front-loaded with the key verb 'Returns' and includes all necessary information without any fluff.

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

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

Given the tool has no parameters, annotations fully cover safety, and the description details the return content, the description is complete. No output schema exists but it is not needed because the description sufficiently explains the output.

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 parameters with 100% schema description coverage. No parameter information is needed, so the description appropriately provides none. Baseline 4 applies.

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

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

The description clearly states the tool returns current toolkit state including installed MCPs, connection status, and catalog counts. It uses a specific verb ('Returns') and distinguishes from siblings which 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?

The description implies usage for inspecting toolkit state, with no parameters or side effects. While it does not explicitly state when not to use or list alternatives, the context makes it clear, and sibling tools are sufficiently different.

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