Banco Bmg MCP

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

Description adds context beyond annotations: explains idempotent behavior (no args returns link), session-only vs permanent, and no destructive effects. No contradiction with annotations.

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

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

Two sentences, efficient but the second is dense with instructions. Could be slightly clearer with bullet points, 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?

For a simple 1-param optional tool, description covers all usage scenarios (permanent config, session token, no-arg link). No output schema needed; return value implied.

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, description fully compensates by explaining the token parameter: its source (JWT from browser), optionality, and effect when provided or omitted.

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 handles authentication for IDE agents, explaining two login methods (permanent via config, session via token) and a no-arg call to get a link. Verb 'authenticate' is specific and distinct 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?

Explicitly explains when to use each method: permanent vs session-only login, and mentions adding token to config as an alternative. Provides clear context for use.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false, so bar is lower. Description adds value by explaining return states (authenticated:true vs connect_urls) and that pending[] is empty when connected. 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 efficient sentences: first gives the main purpose, second adds critical behavioral details. No wasted words.

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

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

For a zero-parameter read-only tool, the description fully explains return values in both main scenarios. No output schema needed as description covers it.

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

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

No parameters exist, so schema coverage is 100%. Description doesn't need to explain parameters; it focuses on the tool's behavior, which is sufficient.

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 behavioral details for two scenarios: all providers connected vs missing credentials. This distinguishes it from siblings like 'authenticate' which handles auth flows.

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 implicitly indicates when to use (e.g., to check connection status before other operations) but does not explicitly state when not to use or compare to alternatives. The context is clear enough given sibling names.

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 key behaviors: invoke works even without installation, returns connect/checkout links for auth/payment, and the permanent install requires owner/admin. While annotations are sparse (readOnlyHint=false, destructiveHint=false), the description adds valuable context about mutation behavior and conditional requirements. No contradiction with annotations.

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

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

The description is comprehensive but somewhat verbose, with some redundant phrases (e.g., 'THE official'). It front-loads the main purpose and flow, but could be tightened without losing clarity. Still, every sentence adds value for a complex tool with 15 parameters and multiple actions.

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 and lack of output schema, the description covers the core functionality, flow, and comparisons to sibling tools well. It explains when to use invoke vs install, and how auth/payment are handled. However, it omits details on the return format of search/describe, which would be helpful. Overall, sufficiently complete for the context.

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

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

The description explains the 'action' parameter's values (search, describe, invoke, etc.) and the overall flow, but does not detail other parameters like 'limit', 'query', 'arguments', or 'immediate'. With 0% schema description coverage, more parameter-level guidance would be beneficial. However, the description compensates partially by explaining the high-level usage context.

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 as the official marketplace for discovering and running MCPs, contrasting it with external registries and sibling tools. It provides a specific verb ('search', 'describe', 'invoke') and resource ('MCPs/tools'), making the purpose unmistakable.

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 guides when to use this tool first for any capability, when to prefer invoke over install, and describes the core flow. It distinguishes from siblings by explaining that install makes MCPs permanent while invoke does one-off runs, and that search/describe discover MCPs before calling other tools.

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?

Description adds value beyond annotations by specifying that data becomes unavailable and hints at reconnection via returned URL. Annotations already declare destructiveHint=true, so the description reinforces the behavior 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?

Extremely concise at 24 words, front-loaded with the core action, and includes essential return value information. No superfluous content.

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?

Adequate for a simple destructive tool with annotations covering the safety profile. However, lacks explanation of the parameter and any conditions or error handling, leaving gaps for effective use.

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

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

The sole parameter 'item' is not explained in the description; schema coverage is 0%. The description vaguely mentions 'a specific bank' but does not map to what 'item' represents (e.g., bank connection ID). This is a significant gap for a 1-parameter tool.

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

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

Description clearly states the tool revokes consent and deletes connection data for a specific bank, with an explicit return value. However, it does not differentiate from sibling tools or clarify the ambiguous 'item' parameter.

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

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

No guidance on when to use this tool versus alternatives (e.g., other openfinance tools). The description implies it's for disconnecting a bank but lacks when-not-to-use or prerequisite conditions.

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 the underlying mechanism (PATCH then polls up to ~60s), the effect on lastUpdatedAt and synced, and edge cases like needs_action (LOGIN_ERROR) and timed_out. Although annotations set readOnlyHint=false, the description adds crucial behavioral context (polling, error states, return format). No contradiction.

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

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

The description is information-dense but well-structured: core action, usage scenario, parameter details, return format, edge cases. It uses bold for emphasis and front-loads the key verb. Slightly long but every sentence adds value.

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

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

Given the tool's complexity (sync with polling, optional parameters, multiple result fields, error states), the description is fully self-contained. It explains return structure (results, errors), each result's fields, and how to handle timed_out and needs_action. No output schema exists, so this completeness is essential.

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 fully explains both parameters: items is an array of selectors (item_id, connector_id, connector_name) and omitting it syncs all; wait is boolean for synchronous or fire-and-forget. This compensates completely for the schema's lack of descriptions.

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

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

The description uses a specific verb ('forces... to re-sync') and clearly identifies the resource ('one or more connections' or 'ALL linked banks'). It distinguishes this tool from siblings like openfinance_disconnect_bank by stating it pulls fresh data 'WITHOUT disconnecting/reconnecting'. The purpose is unmistakable.

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

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

Explicitly states when to use ('when a balance or transaction list looks stale') and what it avoids ('WITHOUT disconnecting/reconnecting'). Provides alternatives: if timed out, 're-check with openfinance_get_item_status'. Also explains behavior when omitting items (sync all) and the wait parameter (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?

Beyond annotations (readOnlyHint, idempotentHint), the description discloses detailed error handling: CREDIT accounts may return a BALANCE_FETCH_ERROR with a warning instead of throwing, and when upstream is unavailable, the row degrades to last-synced with realtime: false and a warning. This provides significant behavioral context.

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 that packs substantial information concisely. It could be slightly more structured with bullet points, but it is efficient and front-loaded with the primary 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 output schema, the description explains the response shape ({ results: [...], errors: [...] }) and covers error scenarios thoroughly. It is complete enough for a tool that retrieves balance data.

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 compensates by adding semantics: the array size constraint (1-50) and the behavioral implications of the parameter values (e.g., CREDIT accounts behavior). This is critical for correct invocation.

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 a real-time balance payload for a given account ID, specifying the API endpoint (GET /accounts/:id/balance). It is distinct from sibling tools like openfinance_get_accounts_detail or openfinance_list_accounts, which serve different purposes.

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

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

The description specifies that account_ids must be passed as an array of 1 to 50 items. It explains behavior for CREDIT accounts and when upstream is unavailable. However, it does not explicitly state when to choose this tool over alternatives, though the specificity implies its purpose.

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 non-destructive nature. The description adds critical behavioral info about a potential provider_incident block that may cause unreliable credit limits/balances, with explicit instruction not to present those values as real. This goes beyond annotations and aids safe tool use.

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 4 sentences, each adding value: purpose, parameter guidance, batch shape, and provider incident warning. It is front-loaded with the main action and concise without unnecessary detail.

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

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

Despite no output schema, the description explains the return shape as '{ results, errors }' and flags the provider_incident block. It covers the key behavioral aspects and return format sufficiently for an agent to understand and 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?

With 0% schema description coverage, the description compensates by specifying 'Pass account_ids as an array (1–50)', providing the array type and size range. This adds meaning beyond the raw schema, meeting the required baseline.

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

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

The description clearly states it returns full account objects including extended creditData per ID, with a batch shape. It distinguishes from siblings like openfinance_list_accounts (likely a summary) and openfinance_get_account_balance (different resource). The verb 'returns' and specific resource make purpose unambiguous.

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

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

The description implies usage when detailed account data is needed, and specifies batch size (1-50), but does not explicitly contrast with sibling tools like list_accounts or provide when-not guidance. The context is clear but lacks explicit 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?

Adds context beyond annotations: batch shape { results, errors }, pluggy not returning paid status, explanation of payments[] behavior 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?

Well-structured with logical sections and front-loaded purpose. Slightly verbose but every sentence adds necessary value 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?

Complete given complexity: covers return format, edge cases, cross-tool dependencies, and nuances of Brazilian Open Finance 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?

Description adds meaning beyond schema: explains bill_ids should be an array, suggests using list bills to discover ids. Schema coverage 0%, but description fully compensates.

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

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

Clearly states it returns bill-level detail for credit card bills by ID, listing specific fields (financeCharges, payments[]). Distinguishes from sibling tools like openfinance_list_transactions and 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?

Explicit when-to-use: use openfinance_list_credit_card_bills first, use openfinance_list_transactions for itemized transactions. Provides clear 'do NOT' instructions about reconstructing totals and interpreting payments[].

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds context on return format (single object vs. {count, items}) and lists possible status values, providing behavioral insights 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, front-loaded sentence with no unnecessary words. Every part adds value, making it highly concise and well-structured.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description fully covers both use cases and the return format. No additional information is needed 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?

The schema has 0% description coverage for the 'item' parameter, but the description fully compensates by explaining that omitting returns all banks and passing returns a single bank, adding critical 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?

The description clearly specifies the tool returns the current status of a bank connection with possible values (UPDATED, UPDATING, LOGIN_ERROR, etc.), along with executionStatus and connector metadata. It distinguishes between querying all banks or a single bank, making the purpose unmistakable.

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 instructs when to omit versus pass the 'item' parameter, with clear return format details. It does not mention when not to use this tool or alternatives like openfinance_list_connections, but the guidance for the two use cases 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 readOnly, idempotent, non-destructive. Description adds batch error handling and data fields 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 sentences including endpoint, data fields, usage advice, and parameter constraints. No wasted words; front-loaded with main 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?

Good coverage considering one parameter and no output schema. Lists many return fields and usage context. Could mention error scenarios or response shape more thoroughly.

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 explains loan_ids as array with size limit (1-50). Does not detail each loan_id format or value, but provides minimal useful 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?

Clearly states it returns full loan contract detail by ID with endpoint and specific fields. Distinguishes from sibling openfinance_list_loans by advising to use after listing.

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

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

Explicitly says 'Use after openfinance_list_loans to deep-dive on a specific contract' and provides array size (1-50) and batch shape format.

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

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

Adds behavioral details beyond annotations: that 'name' is the legal entity not brand, meaning of CREDIT balance, and provider_incident implications. Aligns with readOnlyHint and idempotentHint.

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

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

The description is thorough but not overly verbose; each sentence adds value. It is structured logically, though length could be slightly reduced without losing meaning.

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: return fields, filtering, balance caveats, provider incidents, and cross-references another tool. No output schema, but description is comprehensive enough.

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?

Adds meaning for the 'item' parameter (omit vs pass). However, the 'type' parameter's purpose (filtering by account type) is not explicitly stated, though implied. With 0% schema coverage, the description partially compensates.

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

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

The description clearly states the tool returns accounts for bank connections, specifying account types (BANK, CREDIT) and included fields. It distinguishes from siblings like openfinance_get_accounts_detail by focusing on listing multiple 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?

Explicitly explains when to omit 'item' (list all banks) vs when to pass it (target a single bank). Also warns about CREDIT balance meaning and directs to openfinance_list_credit_card_bills for standardized 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 already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds valuable context: caching per session, single aggregated response. 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 sentences, front-loaded with the main action. Each sentence adds specific value: source, caching, field details, usage hint. 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?

Despite no output schema, the description fully explains the return fields and their purpose. It covers caching, session scope, and ties to a sibling tool. Complete for a simple read-only tool with annotations.

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

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

No parameters exist, so schema coverage is 100%. The description adds no param info but explains the output fields, which is sufficient. Baseline 4 for zero-parameter tools.

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

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

The description clearly states it returns the transaction category taxonomy, specifying the source (GET /categories) and detailing each field. It distinguishes from siblings by explicitly linking to openfinance_update_transaction_category via the id field.

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

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

The description implies usage when needing category taxonomy for update operations, and notes 'no batch ids' to set expectations. However, it does not explicitly state when not to use or provide alternatives, though alternatives are limited.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds context about returned fields and a connection URL, but does not disclose further behavioral traits beyond what annotations provide.

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

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

The description is a single sentence, front-loaded with the purpose, and contains no redundant words. It efficiently conveys the necessary 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 zero-parameter, read-only tool with clear annotations, the description fully covers what an agent needs: what is returned and a noteworthy detail (add_connection_url). No gaps.

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

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

No parameters exist, so the description naturally cannot add parameter semantics. It compensates by listing return fields, which is helpful 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 the verb 'returns' and the resource 'saved bank connections', listing specific fields (connector_id, item_id, bank name, add_connection_url). This distinguishes it from sibling 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?

The description implies usage for listing connections but provides no explicit when-to-use guidance or comparisons to siblings. No exclusions or alternatives are mentioned.

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

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

Annotations declare readOnlyHint=true and idempotentHint=true, which the description supports. Beyond annotations, it explains derived fields (payment_status), the unusual payment booking logic, connector asymmetry, and warnings about bill_grouping_reliability. 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 very long (over 1500 characters) and combines raw output fields, usage guidance, and caveats in a single paragraph. While front-loaded with key info, it could be better structured with sections or bullet points for readability.

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

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

Given no output schema, the description thoroughly explains return values (payments, payment_status, open_bill, future_bills, warnings). It covers all behavioral aspects: payment logic, cross-bill matching, connector asymmetry, and field reliability. Very 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, so the description must compensate. It explains include_open_bill in detail and mentions bulk via account_ids, but page and page_size parameters are not described at all. Partial compensation but incomplete.

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

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

The description clearly states it 'Returns CLOSED credit card bills for a CREDIT-type account' and enumerates the fields returned. It distinguishes from siblings like openfinance_list_transactions and openfinance_get_credit_card_bill by specifying its scope and limitations.

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 comprehensive guidance: when to use include_open_bill, how to interpret payment_status, warnings about connector asymmetry, and explicit cases to use alternatives (e.g., openfinance_list_transactions for transactions). Also includes cross-check instructions for multiple banks.

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

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

Annotations already mark it as read-only and idempotent. The description adds value by detailing error return structure (warning object on 403 or other errors) and listing specific fields returned (balance, amount, rates, etc.), providing context beyond annotations.

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

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

The description is a single, well-structured paragraph. It front-loads the main purpose and lists key details without redundancy. 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?

The description provides good detail on output fields and error behavior, but completely omits parameter documentation. Given the tool has no output schema and 4 parameters, the description should explain parameters to be 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?

With 0% schema description coverage, the description must explain parameters, but it does not mention any of the four parameters (item, page, type, page_size). The agent must infer their meaning from names alone, which is insufficient.

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 investment portfolio for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.). This specificity makes it easy to distinguish from siblings like openfinance_list_investment_transactions, which deals with transactions rather than portfolio overview.

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

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

It implies usage for connections with INVESTMENTS product enabled and mentions graceful error handling (returns warning instead of throwing). However, it does not explicitly state when not to use or direct to alternatives like list_investment_transactions for transaction-level data.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. Description adds details about returned fields and bulk execution. No contradiction. Could mention pagination 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?

Concise with two sentences plus a line about bulk support. Front-loaded with purpose. Could be slightly more structured, but efficient.

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

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

Given no output schema, description details return fields and types. Covers pre-step (list_investments) and bulk capability. Pagination is in schema but not described. Overall fairly 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%, but description explains the key parameter investment_id and the bulk parameter investment_ids. However, it does not explain page and page_size pagination parameters, 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?

The description clearly states it returns movement history for a specific investment position, listing transaction types and fields. It distinguishes from siblings like openfinance_list_investments by specifying use after that call to obtain 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?

Provides clear sequencing guidance ('Use after openfinance_list_investments') and mentions bulk support. However, does not explicitly state when not to use or compare to 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?

Annotations already indicate read-only and idempotent. Description adds that queries are sequential with rate-limit spacing and returns per-connection results/errors, providing rich behavioral detail 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: purpose, detailed usage, omission behavior. Front-loaded and no unnecessary 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?

Covers main aspects: purpose, parameter behavior, return format, and execution detail. No output schema, but description includes return structure. Lacks edge cases like invalid selectors.

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 description for the items parameter (0% coverage). Description explains that items is an array of connection selectors (item_id uuid, connector_id, or connector_name), adding crucial meaning. However, it does not detail the format of these selectors.

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 'Lists loan contracts per bank connection (GET /loans).' This is a specific verb and resource, distinguishing it from sibling list tools like list_accounts and 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?

Provides detailed usage for the items parameter (when to pass it vs omit), but does not explicitly compare to alternatives or state when not to use. Usage is implied but lacks exclusion 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?

Discloses many behavioral traits beyond annotations: credit card metadata sparsity, pending/posted behavior varying by connector, auto-pagination up to 5000, error returns instead of throwing, and provider incident handling. All such details add transparency without contradicting the readOnlyHint.

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

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

The description is comprehensive but somewhat verbose; it packs dense information that could be arguably restructured for quicker scanning. However, the front-loaded purpose and clear sections (pagination, details, warnings) make it usable. Every sentence adds value, so it earns a high score despite 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 the tool's complexity (8 parameters, credit card intricacies, pagination, multiple detail levels, error handling, sibling tools), the description is exceptionally complete. It describes the response structure (account echo, truncated, provider_incident) and addresses edge cases like sparse billId and connector discrepancies.

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

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

With 0% schema coverage, the description fully explains all 8 parameters: date format (ISO YYYY-MM-DD), search_queries semantics (case-insensitive substring OR), pagination (omit page for auto), detail levels (compact, rich, raw), and bulk account_ids. Every parameter's meaning and constraints are documented.

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

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

The description clearly states it returns transactions for bank accounts (BANK or CREDIT). It specifies the resource and distinguishes from siblings by noting that for CREDIT accounts it is the only way to get itemized transactions, and explicitly references openfinance_list_credit_card_bills and openfinance_list_accounts for alternative purposes.

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?

Extensive guidance on when to use this vs alternatives: it is the primary tool for transactions, while bills should be retrieved via openfinance_list_credit_card_bills. It also advises checking account health and provider incidents, and when to use different detail modes. The description explicitly states when not to sum by billId and how to handle pagination.

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 scan caps at 5000/account with truncated flag, and provider_incident block causing incomplete data. Adds context beyond annotations (readOnlyHint, idempotentHint) by detailing what happens in edge cases.

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 and front-loaded with core purpose, but slightly verbose. Each sentence adds value, though some minor redundancy could be trimmed. Still highly 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 output schema, the description thoroughly explains return structure for both granularities, detail options, truncation, and provider incidents. Leaves no ambiguity 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?

Despite 0% schema description coverage, the description adds full meaning: ISO dates for from/to, item options, granularity default and behavior, detail levels, and type filtering. Compensates completely 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 clearly states it performs consolidated cash-flow analysis for a bank connection in one call, resolving accounts internally. It distinguishes from siblings by explicitly saying no need to call openfinance_list_accounts first and provides specific use cases like 'fluxo de caixa'.

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

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

Provides explicit guidance on when to use (whole connection analysis), when to omit 'item' to analyze all banks, explains all parameters (granularity, detail, type, from/to), and warns about provider_incident. Includes scenarios like 'análise anual/mensal'.

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 behavior beyond annotations: it explains what the tool returns (global indicator, degraded components, open incidents, affected banks). It does not contradict annotations (readOnlyHint, idempotentHint, destructiveHint 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?

The description is a single sentence but well-structured and front-loaded with the main purpose. It is concise, but could be slightly more readable with sentence breaks. However, it earns its place without 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 no output schema, the description thoroughly explains the output: global indicator, degraded components, open incidents, and affected banks. This provides sufficient context for the agent to understand the tool's results.

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

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

The input schema has no parameters, so the description does not need to add parameter meaning. Schema coverage is 100% (no params to cover). The description is still clear about the tool's function.

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 checks the LIVE operational status of the Open Finance provider, distinguishing it from the sibling tool `openfinance_get_item_status`. The verb 'checks' and the resource 'provider status' are 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 explicitly states when to use this tool: when data looks incomplete or stale even though the connection shows UPDATED. It also clarifies it is separate from checking the connection's own status, providing clear 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?

Beyond annotations (readOnlyHint, idempotentHint), the description reveals behavioral details: it honors plan (PF hides PJ), returns a hint if keywords empty, and surfaces caveat warnings for non-Open-Finance connectors. 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 main purpose and includes all necessary details. While slightly lengthy, every sentence adds value and avoids redundancy.

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

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

Given no output schema, the description adequately explains the return structure (fields like connector id, access, audience, etc.) and edge cases (empty keywords, caveat). It could mention pagination or sorting, but is sufficient 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?

With 0% schema description coverage, the description provides full parameter semantics: explains keywords as array of bank names with example, clarifies include_accounts behavior, and emphasizes that keywords is REQUIRED despite schema not marking it required, and describes the fallback hint.

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 searches bank connectors by name, listing returned fields (connector id, access, audience, etc.). It distinguishes from sibling tools by specifying its role as a prerequisite to connecting, and it mandates keywords, preventing misuse as a catalog dump.

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 advises calling this tool before connecting and notes that keywords are required. It provides context on plan filtering and caveat warnings, but does not explicitly list scenarios where the tool should not be used.

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 and destructiveHint=false. The description goes far beyond: it reveals that the tool overrides automatic categorization AND creates a Category Rule (case-insensitive exact match), affecting future similar transactions. It also describes batch error handling ('per-item errors do not fail the whole batch') and the response shape. This is comprehensive behavioral disclosure.

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

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

The description is a single paragraph but dense with information. Every sentence adds value, from the HTTP method to side effects to error handling. It could be slightly better structured (e.g., bullet points for the batch shape), but it is not verbose and is easy to parse for an AI agent.

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 covers all key aspects: input sources, side effects (creating rules), batch behavior, error handling, and response shape (`{ updated, results, errors }`). Given no output schema, this is thorough. The tool complexity is moderate, and the description leaves no major 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 description coverage is 0%, so the description carries full burden. It explains that `items` is an array of objects with `transaction_id` and `category_id`, and crucially, it tells the user where to source these IDs (from other tools). This adds essential meaning beyond the raw schema, which only defines types and requirements.

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 'Corrects the category of one or more transactions (PATCH /transactions/:id).' This provides a specific verb and resource, and the context of 'fix miscategorized transactions' distinguishes it from sibling listing tools (e.g., openfinance_list_transactions, openfinance_list_categories). No ambiguity.

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

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

The description clearly specifies how to format the `items` array and where to obtain the IDs ('transaction_id comes from openfinance_list_transactions, category_id from openfinance_list_categories'). It also states the use case: 'use this to fix miscategorized transactions and improve categorization accuracy going forward.' It lacks an explicit 'when not to use' or alternative, but the guidance is sufficient given there are no sibling update tools.

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?

Description adds no behavioral context beyond annotations. Annotations indicate idempotentHint=true, which contradicts the likely non-idempotent nature of reporting, creating a potential 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?

Two clear sentences, no fluff. Could benefit from more structure or a title, but effective 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 3 parameters with no schema descriptions, no output schema, and sibling context, the description lacks completeness. Does not explain return values or parameter usage beyond a single hint.

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%. The description only mentions 'conversation' but does not explain its format or the other parameters (message, context). Provides marginal help.

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 the verb 'Report' and resources 'bug, missing feature, or send feedback'. Differentiates from sibling tools which are all Open Finance related, so it stands out.

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 a hint to include conversation array for reproduction, but no explicit when-to-use or alternatives. Adequate but not explicit.

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, fully covering the behavioral safety profile. The description adds the specific domain of version info but no further behavioral traits 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 succinct sentence that front-loads the purpose with no extraneous 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 simplicity of the tool (no parameters, clear annotations), the description sufficiently conveys its functionality. No output schema exists, but the output is inherently understood as version strings.

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

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

The tool has zero parameters, so the description does not need to add parameter details. Baseline score of 4 applies per rubric for no-parameter tools.

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

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

The description clearly states the tool shows current MCP platform and adapter versions, using a specific verb and resource. It is distinct from sibling tools which are mostly openfinance 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 guidance on when to use this tool versus alternatives is provided. The description merely states what it does without any context or exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds value by specifying the exact content of the return value (installed MCPs, connection status, catalog counts), providing behavioral context 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?

Single sentence with no wasted words. It is front-loaded with the main action and includes specific details. Every word contributes to 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 zero parameters and no output schema, the description fully covers what the tool returns. No additional details are needed for an agent to correctly invoke and interpret results.

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

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

Tool has no parameters, so schema coverage is 100%. According to guidelines, baseline is 4. The description correctly adds no extraneous parameter info as none exist.

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' with specific details: installed MCPs, connection status, and catalog tool counts. It uses a specific verb 'Returns' and resource 'toolkit state', and distinguishes from siblings which focus on operations like authentication or Open Finance queries.

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 appropriate use for inspecting toolkit state. It lacks explicit exclusions or alternatives, but given the tool's simplicity and zero parameters, the intended context is clear. Siblings cover different functionalities, so no confusion arises.

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