InfinitePay MCP

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

Annotations indicate idempotentHint=true, and description confirms calling with no args returns a link (idempotent). Also explains the distinction between permanent and session login, adding 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?

The description is somewhat lengthy but packs essential details (MCP.AI context, two methods, token format). It is front-loaded with the target audience. Could be slightly trimmed 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?

No output schema is provided, and the description does not specify what the tool returns upon success or failure. However, for an authentication tool, the primary action (saving a token) is understood. Additional details on return values would improve completeness.

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

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

Although schema coverage is 0%, the description fully explains the 'token' parameter: it is a JWT string to be pasted, and clarifies that omitting the token yields a login link. This compensates well for the missing schema documentation.

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

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

The description clearly states the tool's purpose: authentication by providing an access token either via config (permanent) or by pasting a JWT (session). It distinguishes from siblings like 'connect' which likely handles other integration 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?

Explicitly describes two usage scenarios: adding token to config for permanent connection, or calling with token argument for session login, or with no args to get a link. Provides clear 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 behavioral context beyond annotations by detailing return values for two states (all connected vs missing credentials). 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?

Two concise sentences, front-loaded with main purpose, no wasted words.

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

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

Given no parameters and no output schema, the description covers the main scenarios adequately. Could mention potential other states but not 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?

No parameters (schema coverage 100%), so description adds value by explaining response meaning, setting 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 tool returns connection status and URLs, distinguishing it from sibling tools like 'authenticate' and 'openfinance_list_connections'.

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

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

The description implies using this tool to check connection status but does not explicitly state when to use it versus alternatives or provide when-not-to-use 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?

Disclosures beyond annotations include write operations requiring owner/admin, invoke running tool one-off without installing, behavior for missing credentials (connect link) or empty wallet (checkout link). No contradiction with annotations (readOnlyHint=false, openWorldHint=true). Adds significant 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?

Description is long (multiple paragraphs) and somewhat repetitive (e.g., emphasizing 'THE official'). While it front-loads purpose, it could be more concise. Structure is logical but wordy.

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?

Considering complexity (13 parameters, no output schema, annotations), the description covers the usage flow, action types, invocation behavior, permissions, and common scenarios. Missing explicit return value documentation, but overall adequate for a multifaceted tool.

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

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

Schema coverage is 0%, so description must compensate. It explains the 'action' enum and the invoke flow, but many parameters (e.g., limit, query, mcp_id, tool_id, arguments) are not individually described. The description adds some meaning but not full coverage for 13 parameters.

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

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

The description clearly states the tool is 'THE official mcp.ai marketplace' and outlines its core capabilities: search, describe, invoke, install, etc. It distinguishes itself from sibling tools by being the primary entry point for marketplace actions, while siblings are specialized (e.g., OpenFinance).

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 this tool FIRST before external registries, and explains the core flow (search -> describe -> invoke). Contrasts invoke vs install, mentions when to use each, and describes credential/payment handling. Clearly tells when not to use 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?

Beyond the destructiveHint annotation, the description explains that the bank's data will no longer be available and provides a reconnection mechanism, adding valuable 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?

Two sentences with no fluff, efficiently conveying the action and outcome. Front-loaded with the main 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?

Adequate coverage of the tool's effect and return value, but missing parameter explanation and any side effects or confirmation steps. For a simple tool, it's minimally complete.

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

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

The only parameter 'item' is a required string with no description in schema or tool description. The tool description does not clarify what 'item' represents, 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?

The description clearly states it revokes consent, deletes connection data, and returns a reconnection URL. This distinguishes it from sibling tools like openfinance_list_connections.

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

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

No explicit guidance on when to use this tool versus alternatives, nor any prerequisites or conditions. The destructive annotation warns but the description lacks 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?

Discloses polling behavior (~60s timeout), fire-and-forget mode (wait: false), return format with fields like status, executionStatus, lastUpdatedAt, synced, and error conditions (needs_action, timed_out). Annotations provide readOnlyHint=false (mutation) and destructiveHint=false (non-destructive), which description aligns with.

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 not excessively lengthy; each sentence adds value. Minor redundancy ('UPDATED' vs 'updating') but overall efficient.

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

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

Given 0% schema coverage, no output schema, and 2 parameters, the description covers behavior, return values, edge cases, and alternatives comprehensively.

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?

Both parameters (wait, items) are explained in plain language: wait as boolean for sync mode, items as array of selectors with option to omit for all. This compensates fully for 0% schema description coverage.

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

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

The description clearly states the verb 'forces... to re-sync' and the resource 'one or more connections'. It distinguishes from sibling tools like openfinance_get_item_status by mentioning alternative for re-checking.

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

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

Explicitly says when to use: 'when a balance or transaction list looks stale' and clarifies it does not require disconnecting. Lacks explicit exclusions for other scenarios.

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

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

Annotations already indicate readOnly and idempotent hints. The description adds that CREDIT accounts may return a warning instead of throwing, and gives the response shape. 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?

Three sentences: main purpose, parameter detail, error handling. 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?

Covers response shape, error handling, and special case for CREDIT accounts. Without output schema, it provides enough context. Could mention behavior for invalid IDs or excess length.

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 explains that account_ids is an array with length 1–50, adding meaning to the parameter. It does not specify format of IDs but 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 real-time balance per account id, specifies the endpoint, and distinguishes it from sibling tools like openfinance_get_accounts_detail.

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 provides explicit usage guidance for account_ids (array, 1–50) and warns about CREDIT accounts returning errors. However, it does not explicitly mention 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 indicate read-only, idempotent, non-destructive behavior. The description adds valuable context about the provider_incident block and that values may be unreliable during outages, which goes beyond annotations.

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

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

The description is two concise sentences covering purpose, input, output shape, and a warning. It is front-loaded and efficient, though the batch shape notation could be slightly clearer.

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

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

Given one parameter, no output schema, and annotations covering safety, the description is fairly complete. It explains the batch result shape and a critical data reliability warning, satisfying most needs for a detail retrieval 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?

With 0% schema description coverage, the description compensates by specifying the array size constraint (1-50) and the format for account_ids. This adds meaningful usage guidance beyond the raw schema.

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

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

The description clearly states the tool returns full account objects with extended creditData per ID, specifying the HTTP method and path. It implies detail retrieval compared to list tools, though does not explicitly differentiate from similar siblings like 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 provides input constraints (array of 1-50 IDs) and a warning about provider incidents, but does not explicitly state when to use this tool versus alternatives like list_accounts or other detail endpoints.

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 batch result shape ({ results, errors }), notes that Pluggy lacks a paid/status field, and explains nuanced behavior of payments[] (payments registered during this bill's cycle, typically for previous bill, not indicating payment status). Suggests alternative tool for payment status. Annotations already indicate readOnly and idempotent; description adds critical 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 somewhat long but every sentence provides value, covering purpose, exclusions, usage instructions, and behavioral caveats. It's front-loaded with the main action. Slightly verbose for a simple tool but justified by domain 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 fully explains return fields and batch shape. It addresses edge cases (paid status ambiguity) and provides complete guidance for using the tool correctly within the Brazilian Open Finance 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?

Only one parameter (bill_ids) with 0% schema description coverage. The description explains it's an array and instructs to use openfinance_list_credit_card_bills to discover IDs, adding essential meaning beyond the bare schema.

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

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

The description clearly states the tool returns bill-level detail for credit card bills by ID, explicitly lists included fields (financeCharges, payments) and excludes individual transactions, distinguishing it from sibling tools like openfinance_list_transactions.

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

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

Provides explicit guidance on when to use (get bill detail) and when not to (for transactions, use openfinance_list_transactions). Includes detailed instructions for getting itemized transactions with account_id and date range, and advises using openfinance_list_credit_card_bills first to discover bill IDs.

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 safe behavior. The description adds value by detailing the output structure (status, executionStatus, connector metadata) and the two modes of operation. It does not contradict annotations and provides sufficient behavioral context beyond the structured fields.

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

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

The description is concise: two sentences that immediately state the purpose and then explain the two usage modes. No unnecessary words, and the critical information is front-loaded. 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 absence of an output schema, the description does a good job of summarizing the return structure for both modes. It lists example statuses and the nested format for the all-banks case. However, it does not enumerate all possible status values or detail the 'executionStatus' field, but the information is sufficient for an agent to understand the tool's behavior and 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 schema has no description for the 'item' parameter (0% coverage). The description fully compensates by explaining that 'item' is an optional identifier for a single bank, and that omitting it returns status for all linked banks with a specific structure ({count, items}). This adds essential meaning beyond the bare schema.

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

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

The description clearly states that the tool returns the current status of a bank connection, listing specific statuses (UPDATED, UPDATING, LOGIN_ERROR, etc.) and fields (executionStatus, connector metadata). It explicitly distinguishes between querying all banks (omit item) and a single bank (pass item), setting it apart from sibling tools like openfinance_list_connections.

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

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

The description provides clear guidance on when to omit or include the 'item' parameter, along with the expected return format for each case. It does not explicitly mention when not to use this tool or compare it to alternatives, but the context from sibling tool names offers some differentiation.

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 behavioral traits beyond annotations: the difference between account 'name' and 'bank' field, the connector-dependent meaning of credit card balance, the existence of a provider_incident block that may indicate unreliable data, and how results are aggregated. No contradiction with annotations (readOnlyHint, destructiveHint) as the description aligns with these hints.

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

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

The description is verbose but well-structured: it starts with core purpose, then details key fields and usage patterns. Each sentence adds value, though it could be slightly more concise without losing 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?

Given the lack of output schema, the description fully covers return fields and behavior. It explains the aggregated results structure, the provider_incident block, and provides cross-references to sibling tools for related needs. No gaps for an agent to invoke correctly.

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

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

With 0% schema description coverage, the description adds significant meaning: it explains the two parameters 'item' (optional, controls aggregation) and 'type' (enum values BANK/CREDIT). It provides context beyond the schema, though not all edge cases are covered.

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 a bank connection, listing both BANK and CREDIT types, and specifies the fields returned (balance, number, type, subtype, bankData, creditData). It also differentiates from sibling tools like openfinance_list_credit_card_bills by noting it provides account-level details.

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' (to list across all linked banks) vs. pass 'item' (to target a single bank). It also warns against misinterpreting credit card balance and points to a sibling tool for standardized billing amounts, providing clear when-to-use and when-not-to-use 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 mark it read-only and idempotent. Description adds caching behavior and single aggregated response, going beyond annotations 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?

Four sentences, front-loaded with purpose, then efficient field descriptions. No unnecessary words.

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

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

Fully describes output fields, caching, and that there are no batch IDs. No output schema needed; annotations cover safety. 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 in schema, so baseline 4 applies. Description focuses on output details, which is appropriate given zero parameters.

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

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

Clearly states it returns the transaction category taxonomy, differentiating from sibling tools that list transactions, accounts, etc. Provides specific details about the API endpoint and caching.

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?

Indicates the 'id' field is used by 'openfinance_update_transaction_category', suggesting prerequisite usage. Notes preference for 'descriptionTranslated' for pt-BR users. No explicit alternatives needed as it is the sole categories tool.

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

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

Annotations already declare readOnlyHint and idempotentHint true, eliminating safety concerns. The description adds value by detailing the return fields and highlighting the add_connection_url for linking additional banks, which goes beyond basic safety attributes.

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 entire description is a single, concise sentence that conveys all necessary information without any filler. Every part is relevant 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 annotations covering safety, the description is complete. It explains what the tool returns and its purpose. The absence of an output schema is not a problem since the description lists expected fields.

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 schema coverage is trivially 100%. According to the guidelines, zero parameters warrant a baseline score of 4. The description does not need to explain params but could mention that no filters are applied.

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 saved bank connections, listing specific fields (connector_id, item_id, bank name, add_connection_url). The verb 'Returns' is specific, and it distinguishes from sibling tools like openfinance_list_accounts or connect.

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 it does not explicitly state when to use versus alternatives, the context of listing saved connections is clear. Siblings like connect and openfinance_disconnect_bank serve different purposes. The description implies retrieval of existing connections, which is sufficient for a simple list tool.

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

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

Annotations already declare read-only, idempotent, non-destructive. Description adds substantial behavioral context: payment derivation logic, pluggy semantics, open_bill availability conditions, connector asymmetry, and derived fields. 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 long but well-structured, front-loading key results and semantics. Every sentence adds value, though slight verbosity could be trimmed. Overall appropriate for the tool's complexity.

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

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

With no output schema, the description covers all return fields, edge cases (connector asymmetry, open_bill availability), derived payment_status, and error handling (warning if product disabled). Sufficient for agent understanding.

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 compensates by explaining all parameters: account_id (required), page/page_size (pagination), account_ids (bulk), include_open_bill (opt-in for derived totals). Each parameter's purpose and effect are clearly stated.

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 CREDIT-type accounts, listing specific fields like dueDate, totalAmount, payments[], and derived payment_status. It distinguishes from sibling tools by explicitly noting that itemized transactions are obtained via openfinance_list_transactions.

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

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

Provides explicit guidance: use for closed bills, not for individual transactions; explains when to use include_open_bill; warns about connector asymmetry and cross-bill payment semantics; contrasts with siblings by referencing alternative tools for itemized purchases.

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 behavioral details: the tool returns a non-throwing error structure (total, results, warning) on 403 or upstream errors, which augments the 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 paragraph that front-loads the purpose, but it could be more concise. It includes a long list of return fields and an error scenario, which adds length beyond necessary for the primary use case.

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 thoroughly explains the output structure (fields and error format), compensating moderately for the missing output schema. However, it fails to document input parameters (page, page_size, item, type) and their roles, leaving a significant gap for a tool with four parameters.

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% and the description does not explain any of the four parameters (item, page, type, page_size). It only details the output, leaving the agent without guidance on how to use input parameters.

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

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

The description clearly states the tool returns investment portfolio data for connections with INVESTMENTS enabled, enumerating specific asset types and fields. It differentiates implicitly from siblings like openfinance_list_investment_transactions by focusing on portfolio rather than transactions, and from other list tools by the asset types listed.

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

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

The description provides guidance on error handling (returns a safe fallback structure) and implies usage for INVESTMENTS-enabled connections, but does not explicitly state when to avoid this tool or point to alternatives such as openfinance_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=true, idempotentHint=true, destructiveHint=false, so the description adds value by detailing the types of transactions and fields returned. It does not contradict annotations. However, it omits explanation of pagination behavior (page, page_size) which might affect usage.

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

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

The description is two concise paragraphs with no unnecessary words. The first paragraph front-loads the purpose and output details, and the second provides usage guidance. Every sentence contributes 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?

Given the lack of an output schema, the description lists key return fields and transaction types. It also mentions dependencies and bulk support. However, it does not explain pagination behavior or the structure of the response (e.g., array of objects), leaving some 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 the burden. It explains the key parameter 'investment_id' by referencing the prerequisite tool, and introduces investment_ids for bulk. However, it does not describe the 'page' or 'page_size' parameters at all, leaving two parameters undocumented.

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

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

The description clearly states that the tool 'Returns the movement history for a specific investment position' and lists specific transaction types (BUY, SELL, TAX, etc.) and fields. It distinguishes itself from siblings by referencing openfinance_list_investments as a prerequisite and by the specific focus on investment transaction history.

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 'Use after openfinance_list_investments to get the investment_id', providing clear usage context. It also mentions bulk support with investment_ids. However, it does not explicitly state when NOT to use this tool or compare it 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 readOnly, idempotent, and non-destructive. The description adds significant behavioral context: per-connection fetching, rate-limit spacing, and return structure with results/errors. This goes beyond what annotations provide.

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

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

Three sentences, each adds new information: purpose, parameter usage with examples, and alternative usage. No redundant or irrelevant content. Well-structured and very concise.

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 behavior, parameter semantics, and return format. With no output schema, mentioning '{ results, errors }' is helpful. Could briefly mention any pagination or limits, but not critical given the tool's simplicity (1 optional param).

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 fully explain parameters. It does: defines 'items' as an array, specifies acceptable selectors (item_id uuid, connector_id, connector_name), and explains the effect of omission. This adds complete meaning.

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

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

Clearly states the verb 'Lists' and resource 'loan contracts per bank connection', and includes the HTTP endpoint. Distinguishes from sibling tools like openfinance_list_accounts by focusing on 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?

Explains when to pass 'items' (specific connections) and when to omit (all banks). Mentions rate-limit spacing for multiple connections. Does not explicitly state when not to use this tool or mention alternatives, but within the context of sibling tools, there is no other loan-list tool, so no ambiguity.

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, but description adds significant behavioral context: error handling returns structured response instead of throwing, auto-pagination with 5000 ceiling, variable behavior per bank for credit card transactions, and response fields like 'truncated' and 'provider_incident'. 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 lengthy but well-structured with logical sections (basic function, credit card specifics, pagination, error handling, detail, bulk). Every sentence adds value, though slight redundancy exists (e.g., repeated mention of BULK). Efficient given 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?

Despite no output schema, description covers behavior comprehensively: pagination limits, error returns, detail level behavior, credit card nuances, provider incidents, and links to related tools. Complete enough for an agent to use correctly.

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

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

Schema coverage is 0%, but description fully explains all parameters: from/to as ISO date filters, page/page_size for pagination, detail levels (compact/rich/raw) with use cases, search_queries with OR semantics, and account_ids for bulk. Adds substantial meaning beyond schema.

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

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

The description clearly states it returns transactions for bank accounts (BANK or CREDIT) and explicitly distinguishes itself from siblings by noting it's the only way to get itemized transactions for credit cards, linking to bills. It also differentiates from 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?

Provides extensive usage guidance: when to use vs openfinance_list_credit_card_bills for standardized totals, how pagination works (omit page for auto-pagination vs explicit page), when to narrow from/to if truncated, and how to check connection health. Also mentions provider incident handling.

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

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

Discloses behavioral traits beyond annotations: internal account resolution, truncation at 5000/account, provider incident blocks, default compact vs raw output. Consistent with readOnlyHint and idempotentHint annotations.

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

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

Fairly long but front-loaded with main purpose and well-structured. Every sentence serves a purpose, though could be slightly more concise for a rapid scan.

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?

Comprehensive coverage of return values (compact summary fields, raw rows), edge cases (truncation, provider incidents), and parameter combinations. No output schema exists, so description carries full completeness burden.

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 each parameter's meaning and effect (e.g., ISO dates, granularity options, detail levels, type filter, top_n for top expenses). Adds value 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 clearly states the tool performs consolidated cash-flow analysis for a bank connection over a period in one call, distinguishing it from siblings that require separate account listing. It uses specific verbs and resources.

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

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

Explicitly tells when to use (e.g., 'análise anual/mensal', 'fluxo de caixa') and when not to (no need to call openfinance_list_accounts first), including alternatives like omitting 'item' for all 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?

The description adds significant behavioral context beyond annotations: it returns global indicator, degraded components, open incidents, and flags affected banks. It also clarifies that it checks the provider's public status page. Annotations already declare readOnlyHint and idempotentHint, which are consistent with the description.

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

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

The description is two sentences, front-loaded with the core purpose, and every sentence adds essential information. No redundancy or unnecessary words.

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

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

Despite no output schema, the description thoroughly explains the return values: global indicator, degraded components, open incidents, and 'your_banks_affected'. It provides complete information for an agent to understand what the tool returns and how to interpret 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?

The tool has no parameters, and schema coverage is 100%. According to guidelines, 0 parameters baseline is 4. The description does not need to add parameter details, and it doesn't attempt to.

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

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

The description uses a specific verb 'Checks' and resource 'LIVE operational status of the Open Finance provider', clearly distinguishing it from the sibling tool 'openfinance_get_item_status'. It states exactly what the tool does and differentiates it from similar 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?

Explicitly specifies when to use: 'whenever data looks incomplete or stale even though a connection shows UPDATED'. Also explains what it reveals (upstream outage or incident) and how it helps distinguish provider-side problems from connection issues.

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

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

Annotations indicate readOnly, idempotent, non-destructive. Description adds crucial behavior: honors user plan (PF hides PJ banks), returns hint without keywords, and surfaces caveats for credential connectors. No contradiction with annotations.

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

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

Description is a single paragraph but well-structured with front-loaded purpose. Every sentence adds value, though dense. Could benefit from slight structuring but remains 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, the description covers inputs, return fields, behavioral nuances (plan filtering, caveat, hint), and usage flow. No gaps for a tool with two simple params.

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: keywords[] as array of strings (with examples) and include_accounts as boolean. Also clarifies keywords is REQUIRED despite schema not marking it.

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

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

The description clearly states the tool searches bank connectors by name (keywords array), returns specific fields (connector id, access type, audience, links, connect_url), and mentions caveats. It distinguishes from siblings like 'connect' and 'openfinance_list_connections' by focusing on search and pre-connection.

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 states to call BEFORE connecting and that keywords are REQUIRED (though not in schema). It implies context (e.g., prefers Open Finance connectors) but doesn't explicitly exclude other scenarios or list alternatives. Still clear 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?

Beyond annotations (destructiveHint=false, etc.), the description discloses a critical side effect: recategorizing creates a Category Rule affecting future categorization. It also explains batch error handling (per-item errors don't fail whole batch) and response format. 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 front-loaded with the purpose, then covers parameters, side effects, and response format. While somewhat lengthy, each sentence adds value. Could be slightly more concise but remains well-organized.

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 provides complete response shape ({ updated, results, errors }) and error behavior. Combined with annotations, all necessary context for selection and invocation is present.

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?

Although schema coverage is 0%, the description adds full parameter meaning: items is an array with transaction_id and category_id, and specifies where to obtain these IDs from sibling tools. This far exceeds the bare schema.

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

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

The description clearly states the verb 'corrects' (update) and resource 'category of one or more transactions', directly distinguishing it from sibling list tools like openfinance_list_transactions and openfinance_list_categories. Specifying HTTP method PATCH further clarifies the action.

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

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

It explains when to use: 'fix miscategorized transactions and improve categorization accuracy going forward', and provides sourcing guidance for parameters (transaction_id from list tool, category_id from list_categories). However, it lacks explicit when-not-to-use or alternative tool mentions.

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?

With annotations already indicating idempotentHint=true and destructiveHint=false, the description adds some context about reproduction but does not elaborate on side effects like ticket creation or notification. It is adequate but not enriched 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 clear sentence with an imperative instruction. It is concise and front-loaded, conveying purpose and key usage in minimal text.

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 3-parameter tool with no output schema, the description covers basic purpose and one parameter's usage. However, it omits details on parameter formats, return values, and prerequisites, leaving gaps 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?

The schema has 0% description coverage, so the description must compensate. It partially explains the conversation parameter but leaves context and message undefined. Given the void, it provides some meaning but insufficiently for all parameters.

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

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

The description clearly states that the tool is used to report bugs, missing features, or provide feedback. This verb-resource combination is specific and distinguishes it from sibling tools which are primarily about authentication and Open Finance operations.

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

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

The description provides explicit guidance on when to use the tool by instructing to include the conversation array for reproduction. It implies the context for reporting issues but does not explicitly exclude other use cases or mention 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 provide readOnlyHint, idempotentHint, and destructiveHint, so the description adds minimal behavioral info beyond confirming the output type (platform and adapter versions).

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 key action, and contains no unnecessary words.

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

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

Given no parameters, no output schema, and annotations covering safety, the description fully covers what the agent needs to know.

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 no parameters, so the description does not need to add parameter semantics; 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 verb 'Show' and the resource 'current MCP platform and adapter versions', making the purpose 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?

The description implies usage context for checking versions, and no alternatives are needed; it is clear and straightforward, but does not explicitly state when not to 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 indicate readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the agent knows this is a safe, read-only operation. The description adds value by detailing exactly what information is returned, providing context beyond the annotations. No contradictions or additional traits needed.

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

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

The description is a single, well-structured sentence that front-loads the action ('Returns the current toolkit state') and then lists the specific data points. Every phrase earns its place; there is no unnecessary wording.

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 low complexity (no parameters, no output schema), the description fully explains what the tool returns. It covers all key aspects: installed MCPs, connection status, and catalog tool counts. No gaps remain for an agent to 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?

The tool has zero parameters, and the schema coverage is 100% (empty). According to rules, 0 parameters gives a baseline of 4. The description does not need to explain parameters, and it adds no relevant parameter information.

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

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

The description clearly states that the tool returns the current toolkit state, specifying the exact contents: installed MCPs, their connection status, and how many catalog tools each exposes. This is a specific verb+resource combination that distinguishes it from sibling tools like authenticate, connect, or openfinance operations.

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 explicitly state when to use this tool versus alternatives, the read-only nature and clear purpose of checking toolkit state make the usage context obvious. Siblings are all different operations (authentication, Open Finance queries, etc.), so confusion is unlikely. A slight lack of explicit guidance prevents a 5.

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