Banco Master MCP

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

Annotations indicate idempotent and non-destructive behavior. The description adds behavioral details: calling with token logs in, calling without returns a login link. This goes beyond annotations and provides useful operational 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 three sentences, front-loaded with the tool's purpose. Every sentence adds value, and there is no redundancy or 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?

For a simple authentication tool, the description covers both modes of operation. However, it lacks details on error handling or return values (no output schema). Given the complexity, it is mostly 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 sole parameter 'token' lacks schema description (0% coverage). The description compensates by explaining it is a JWT and optional, but does not specify constraints or validation. More details on expected format or failure cases would improve.

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 for authentication via browser login and token pasting. It specifies the verb (authenticate) and resource (access token). However, it does not explicitly differentiate from siblings like 'connect', which may also relate to authentication.

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

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

The description provides clear instructions on when to use each mode: for permanent connection add token to config, for session login call with token or no args. It does not mention alternatives or when not to use this tool, but the context is well-established.

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 and idempotent behavior. Description adds contextual details about two response cases, but does not disclose additional 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?

Two sentences: first states purpose, second explains behavior in two cases. Concise, front-loaded, no wasted words.

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

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

Given no output schema and no parameters, description sufficiently explains return values in both success and missing credentials scenarios. Complete for a simple status-check 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 exist, and schema coverage is 100% (trivially). Description adds no parameter info, but baseline for 0 parameters is 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?

Description clearly states it returns connection status and URLs, specifying verb and resource. Distinguishes from sibling tools like 'authenticate' by focusing on status check rather than authentication flow.

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 versus alternatives (e.g., authenticate). Usage context is implied from the description, but no when-not or comparison provided.

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

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

Annotations provide readOnlyHint=false, destructiveHint=false. The description adds critical behavioral context: writes (install, uninstall, subscribe, cancel, invoke's one-off install) require workspace owner/admin; invoke returns connect or checkout links when needed; search/describe flag installed status. This goes well 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 front-loaded with the main purpose and flows into details. It is a single paragraph but covers many aspects without fluff. Could be slightly more structured (e.g., bullet points for actions) 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?

With 13 parameters, no output schema, and complex multi-action behavior, the description covers the overall workflow, auth requirements, billing, and when to use each action. It is comprehensive for the tool's complexity.

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

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

Schema coverage is 0% (no parameter descriptions). The description mentions some parameters indirectly (e.g., action, tool_id, arguments) but does not define their formats, defaults, or constraints. For a 13-parameter tool, the description should provide more parameter-level guidance.

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

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

The description explicitly states it is 'THE official mcp.ai marketplace' and 'the in-platform catalog of every MCP/tool, AND the way to run them.' It clearly differentiates from siblings by listing actions like list_tools (lists callable tools) and invoke (runs tools even if not installed), providing a comprehensive purpose definition.

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

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

The description gives explicit when-to-use guidance: 'use THIS tool FIRST, before any external/generic registry.' It distinguishes between actions: invoke for one-off use vs install for permanent addition, and explains when to use subscribe/cancel, report_bug, request_mcp. It also mentions prerequisites like workspace owner/admin for writes.

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 destructiveHint=true; description confirms destructive nature and adds context about returning add_connection_url for reconnection. No contradiction, but could mention more side effects.

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 action, no fluff. Earning every sentence.

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, but missing explicit parameter definition. Lacks output schema, so description should clarify what add_connection_url looks like. Not fully self-contained.

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 'item' with no schema description. Context implies it identifies a bank, but format or examples are absent. With 0% schema coverage, description should clarify the parameter 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?

Description clearly states the tool revokes consent and deletes connection data, with specific verbs and resource. It distinguishes from sibling tools like openfinance_list_connections which only 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 vs alternatives like openfinance_force_sync or openfinance_list_connections. No context on prerequisites or cases where it 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?

The description adds significant behavioral context beyond annotations: it explains the polling mechanism (up to ~60s), return fields (status, executionStatus, lastUpdatedAt, synced, needs_action, timed_out), and clarifies it is not destructive. Annotations only indicate readOnlyHint=false and destructiveHint=false, so the description fully carries the transparency burden.

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

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

The description is relatively long but well-structured with front-loaded purpose and detailed but necessary explanation. Every sentence adds value, though it could be slightly more concise without losing clarity.

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

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

Given no output schema, the description compensates by detailing the return structure ({ results, errors } with specific fields). It covers input, behavior, error states, and optional parameters, making it complete for a complex syncing tool.

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

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

Schema coverage is 0%, but the description fully explains both parameters: 'items' is an array of selectors (item_id, connector_id, connector_name) and omitting it syncs all; 'wait' controls synchronous vs fire-and-forget. This adds complete meaning beyond the raw schema.

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

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

The description clearly states the tool forces a re-sync of connections and waits for completion. It specifies the verb 're-sync' and the resource 'connections', distinguishing it from sibling tools like openfinance_get_item_status which is for re-checking after timeout.

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

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

It explicitly says to use when 'a balance or transaction list looks stale'. It explains the behavior without disconnecting, and mentions the alternative openfinance_get_item_status for re-checking. It also provides guidance on the wait parameter ('Set wait: false for fire-and-forget') and error conditions like needs_action.

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 (readOnly, idempotent), the description adds real-time behavior, error handling with structured warnings instead of exceptions, and response shape. This provides 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?

Three sentences: what it does, how to call, edge case handling, response format. No wasted words; every sentence adds value.

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

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

Despite no output schema, the description fully explains input constraints, error handling, and response structure. For a simple balance fetch tool, this is 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 has 0% description coverage, but the description explains the sole parameter (account_ids array with size constraint). This compensates well for the missing schema docs.

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 real-time balance per account id, referencing the endpoint. It implicitly distinguishes from siblings by focusing on balance, but does not explicitly name alternatives.

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 usage constraints (array of 1-50 account_ids) and error handling for credit accounts, but no explicit guidance on when to use or when to prefer sibling 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?

Annotations already declare readOnly, idempotent, non-destructive. Description adds value by specifying the batch response shape and array constraints, 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?

Three sentences: purpose, parameter usage, response shape. No wasted words, front-loaded with key 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?

Covers purpose, parameter, and response shape adequately for a simple read operation. Could mention authentication requirement, but implied by sibling tools.

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

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

Single parameter with 0% schema description coverage; description compensates by stating 'as an array (1–50)', adding size constraint and type 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 returns full account objects with extended creditData for given ids, and distinguishes from siblings like list_accounts by specifying 'per id' and batch shape.

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

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

Description implies usage when needing detailed account data for specific ids, but lacks explicit when-not or alternatives. Given many sibling listing tools, some guidance would help.

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 significant context: it is a GET endpoint, returns a batch shape { results, errors }, does NOT return individual transactions, and explains that Pluggy does not return a paid/status field. It also clarifies the meaning of payments[] in Brazilian Open Finance, which is non-obvious behavioral information.

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 and well-structured, but somewhat lengthy. Each sentence adds value, covering purpose, exclusions, usage guidance, parameter explanation, and a critical note about payments interpretation. It is front-loaded with the core purpose, making it efficient for an agent to parse.

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

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

Given no output schema, the description adequately explains the return shape ({ results, errors }) and lists fields in payments[]. It covers complex contextual details about Brazilian Open Finance interpretation and cross-reference with other tools, ensuring the agent has sufficient information to use the tool correctly.

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

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

Schema coverage is 0%, so description carries full burden. It explains the parameter 'bill_ids' is an array, instructs to use openfinance_list_credit_card_bills to discover ids, and mentions the batch return shape. This provides essential context beyond the schema's type definition.

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

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

The description clearly states it returns bill-level detail for credit card bills by id, listing specific fields (financeCharges, payments[]). It explicitly distinguishes itself from sibling tools like openfinance_list_transactions (for individual transactions) and openfinance_list_credit_card_bills (for discovery). The verb 'returns' matches the resource 'bill-level detail' and the id 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?

The description gives explicit guidance: use this tool for bill-level detail, not for individual transactions; recommends using openfinance_list_credit_card_bills first to discover ids; and provides a critical note about interpreting payments[] in Brazilian Open Finance, preventing incorrect assumptions about payment status.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows it's a safe read. The description adds value by detailing the return shape (status, executionStatus, connector metadata) and the two output formats (`{count, items}` for all, single object for specific item), which is 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 exceptionally concise—two sentences that cover purpose, usage modes, and expected output. Every sentence is informative with no wasted words.

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

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

For a read-only tool with strong annotations, the description is largely complete. It explains the two output formats and key fields. However, it does not specify the exact structure for a single item's response (e.g., is it just the status object?) or mention error handling, but these are minor gaps given the tool's simplicity.

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 provides no description for the `item` parameter (0% coverage). The description compensates fully by explaining that omitting it returns all linked banks and passing it returns a single bank, making the parameter's semantics completely clear.

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

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

The description clearly states the tool returns the current status of a bank connection, listing possible values (UPDATED, UPDATING, LOGIN_ERROR, etc.), and specifies output fields (executionStatus, connector metadata). It distinguishes two modes (all banks vs. single bank), which differentiates 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?

The description explicitly explains when to omit or pass the `item` parameter, covering both aggregate and single-entity use cases. It does not explicitly contrast with sibling tools, but the usage is clear and actionable.

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

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

Annotations already note readOnlyHint=true and destructiveHint=false. The description adds critical context: CREDIT balance is connector-dependent and cannot be treated as monthly bill, and clarifies that 'name' is the legal entity not the brand.

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 each sentence adds value. It is front-loaded with the main purpose, though some details could be more structured. Still effective and concise enough for the 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 lacking an output schema, the description thoroughly explains returned fields (balance, type, bank, creditData, etc.), behavioral caveats, and relationships with other tools. Complete 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?

Description adds meaning for 'item' parameter (omit vs pass), but does not explain the 'type' parameter's filtering behavior. With 0% schema coverage, the description partially compensates but leaves the type parameter underdocumented.

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

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

The description clearly states it returns accounts for bank connections, listing both BANK and CREDIT types with specific fields. It distinguishes itself from siblings like openfinance_get_accounts_detail and openfinance_list_credit_card_bills by focusing on account listing.

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

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

Explicitly explains when to omit 'item' (to list across all banks) vs pass 'item' (to target a single bank), and directs to openfinance_list_credit_card_bills for standardized open-bill amounts, providing 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?

Annotations already declare readOnlyHint and idempotentHint. The description adds that the response is cached for the adapter session, which is 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 concise, front-loading the purpose, then listing key fields and their usage. Every sentence adds value; no redundancy.

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

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

Given no input parameters and no output schema, the description fully explains what the tool returns and how the data is structured, making it complete for an agent to understand.

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

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

Input schema has no parameters; baseline is 4. Description adds meaning by detailing the response fields (id, description, descriptionTranslated, parentId, parentDescription), which is not in 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 specifies the exact purpose: returns Pluggy's transaction category taxonomy (GET /categories). It identifies the tool as listing categories, distinct from sibling tools like list_accounts or list_transactions.

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

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

The description mentions the id is used by openfinance_update_transaction_category, providing a usage hint. It states it's a single aggregated response with no batch ids, but could be more explicit about when to use vs. 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description adds value by listing returned fields and the add_connection_url. However, it does not disclose additional 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 with no wasted words. It is front-loaded with the main purpose and efficiently conveys essential 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 zero parameters and no output schema, the description fully covers the tool's behavior and return values. It mentions the specific data returned and the add_connection_url, providing complete context for an 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?

No parameters are defined; schema coverage is 100% (empty object). Per rubric, 0 parameters baseline is 4. Description adds no parameter info but none is needed.

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 saved bank connections and lists specific fields (connector_id, item_id, bank name, add_connection_url). It uses a specific verb ('returns') and resource, distinguishing it from sibling tools that deal with accounts or transactions.

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

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

The description implies usage for retrieving existing connections but does not explicitly state when to use this tool versus alternatives like openfinance_list_accounts. No exclusions or prerequisites are provided.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and destructiveHint. The description adds significant context beyond annotations: it explains derived payment_status logic, payment cycle semantics, connector asymmetry (some banks don't expose open bills), and that the tool returns a warning if CREDIT_CARDS product is not enabled. 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 long but well-structured into paragraphs covering different aspects (payment status, open bill, connector asymmetry). Every sentence provides value, but some sentences are complex. It is appropriately sized for the 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?

Without an output schema, the description lists all key returned fields (dueDate, totalAmount, payments[] structure, payment_status, open_bill fields). It covers edge cases (most recent bill PAST_DUE_UNCONFIRMED), connector asymmetry, and references sibling tools for transactions. Highly complete for the domain.

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

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

With schema description coverage at 0%, the description compensates well for most parameters. It thoroughly explains include_open_bill (default false, opt-in, and structure of returned data). It mentions account_ids for batch but does not detail page and page_size. The description adds value for key parameters but misses pagination.

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 closed credit card bills for a CREDIT-type account, listing specific fields like dueDate, totalAmount, etc. It distinguishes from siblings such as openfinance_get_credit_card_bill (single bill) and openfinance_list_transactions (itemized purchases), using 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?

Extensive guidance is provided on when to use this tool versus alternatives. For example, it advises using openfinance_list_transactions for itemized purchases, explains the payment cycle semantics, warns against assuming payment status from payments[] alone, and clarifies the opt-in nature of include_open_bill due to extra scanning. Explicit when-to-use and when-not-to-use guidance is present.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds context about error handling—returning a structured warning on 403 or other upstream errors—which goes beyond annotation information.

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 that leads with the main purpose, then details the asset types and fields. Every sentence adds value, and there is no unnecessary 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?

The description covers return fields and error behavior comprehensively, but lacks parameter explanations. Given no output schema, the description does well for the tool's complexity, though parameter details would improve completeness.

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

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

Schema description coverage is 0%. The description does not explain any of the four parameters (item, page, type, page_size). Despite the enum hint from the type parameter, the agent receives no guidance on how to use these parameters, leaving a significant gap.

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

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

The description clearly states the tool returns the investment portfolio for a connection, listing multiple asset types (FIIs, stocks, ETFs, etc.) and the fields included. It distinguishes from sibling tools like openfinance_list_investment_transactions by focusing on the portfolio snapshot rather than transactions.

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

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

The description implicitly indicates usage for fetching the portfolio, and the error handling note explains behavior when INVESTMENTS is not enabled. It does not explicitly contrast with alternatives, but the context and sibling tool names provide sufficient 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 indicate readOnlyHint, idempotentHint, destructiveHint. The description adds behavioral details: the types of transactions returned, the fields (including itemized expenses), and bulk execution support. 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?

The description is concise with two short paragraphs. It front-loads the purpose and output details, followed by a usage note. Every sentence adds value without redundancy.

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

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

Given no output schema, the description explains the return data well (transaction types, fields). It mentions prerequisite. However, it does not explain pagination behavior via page/page_size, which is a minor gap.

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 mentions investment_ids for bulk support but does not explain the page, page_size, or investment_id parameters explicitly. While parameter names are somewhat self-explanatory, the description should add more value for the missing schema coverage.

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

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

The description clearly states it returns movement history for a specific investment position, listing transaction types (BUY/SELL/TAX/etc.) and data fields. It distinguishes itself from sibling tools like openfinance_list_investments by focusing on transactions of a specific position.

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 mentions using this tool after openfinance_list_investments to get the investment_id, providing a clear prerequisite. Also notes bulk support with investment_ids. Does not explicitly state when not to use or alternatives, but the context is clear enough.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds important behavioral details: sequential execution with rate-limit spacing, and the return format `{ results, errors }` per connection. 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 highly concise with three well-structured sentences. The first sentence gives the primary purpose and endpoint, the second details parameter usage, and the third covers the omission case. 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?

For a read-only list tool with one optional parameter and no output schema, the description provides all necessary context: parameter semantics, invocation patterns, and return structure. It is self-contained and does not rely on external documentation.

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 the input schema having 0% description coverage, the description thoroughly explains the `items` parameter: it accepts an array of connection selectors (item_id uuid, connector_id, or connector_name), and clarifies the behavior when omitted. This fully compensates for the lack of schema descriptions.

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

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

The description clearly states the tool's purpose: listing loan contracts per bank connection, with the endpoint provided (GET /loans). It distinguishes from sibling tools by focusing solely on loans, as other list tools cover accounts, credit cards, etc.

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

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

The description explicitly explains when to use the `items` parameter (for specific connections) and when to omit it (for all linked banks), and mentions sequential querying with rate-limit spacing. However, it does not explicitly state when not to use this tool or provide direct 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=true and idempotentHint=true, so the bar is lower. Description adds substantial behavioral context: CREDIT PENDING/POSTED variability by bank, pagination ceiling of 5000 with truncated warning, error handling (returns {total:0, results:[], warning, error} on upstream errors), detail level behaviors (compact/rich/raw with coverage notes), and bulk support via account_ids. 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?

Description is long (multiple paragraphs) but well-structured: first sentence states core purpose, then credit card specifics, pagination, detail options, error handling, and related tools. Every sentence earns its place, but could be slightly streamlined. Front-loads key information. Given the complexity, it's appropriately sized, though not maximally 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?

For a tool with 8 parameters, no output schema, and 0% param descriptions, the description is exceptionally complete. Covers behavior, pagination limits, error handling, detail variations, credit card specifics, bulk support, and cross-references to sibling tools (list_credit_card_bills, list_accounts, get_item_status, force_sync). Only minor omission is exact output fields for compact detail, but the description covers what rich/raw add. Overall, fully equips an agent to use the tool correctly.

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

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

Schema coverage is 0% (no param descriptions), so description must carry full burden. It thoroughly explains all 8 parameters: required account_id, date format (ISO YYYY-MM-DD), pagination logic for page and page_size (max 500), detail enum meanings (compact/rich/raw with what each includes), search_queries as case- and accent-insensitive substring match with OR semantics, and account_ids for batch. Also explains interactions like search_queries and truncation.

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

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

Description clearly states it returns transactions for bank accounts (BANK or CREDIT), and distinguishes from siblings: for CREDIT accounts it notes it's the only way to get itemized transactions, and directs to openfinance_list_credit_card_bills for standardized bill totals. It also references openfinance_list_accounts for statement dates. The verb 'Returns transactions' and resource 'bank account' 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?

Explicitly states when to use (listing transactions) and when not (use list_credit_card_bills for open-bill total, use list_accounts for statement dates). Provides detailed pagination guidance: omit page for auto-paginate, use explicit page for manual walk. Also explains search_queries usage and date filtering. Clear context and alternatives.

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

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

Annotations already indicate read-only, idempotent, non-destructive. The description adds behavioral details: it resolves connections internally, fans out transactions, caps at 5000 transactions per account and flags truncated:true, returns compact summary by default, and explains granularity/detail behavior. 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 at about 250 words, front-loading the main purpose. It uses clear sentence breaks but no bullet points. Every sentence adds value, but it could be slightly more structured for faster parsing.

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 return values: compact summary includes totals, monthly evolution, top expenses/incomes, per-account breakdown; raw mode returns consolidated transactions with optional enrichment (merchantInfo, creditCardMetadata). It also mentions truncation flag.

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

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

Schema coverage is 0%, so description must explain parameters. It does so thoroughly: item (connector_id/name/item_id or omit for all), from/to (ISO dates), granularity (monthly default, raw), detail (compact default, rich, raw), type (BANK/CREDIT), and implicitly top_n (largest N in top despesas/recebimentos). Each parameter's effect is clear.

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

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

The description clearly states the tool's purpose: 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call.' It distinguishes from siblings by noting it resolves accounts internally, eliminating the need to call openfinance_list_accounts first. Specific use cases like 'análise anual/mensal' and 'fluxo de caixa' are 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?

It explicitly tells when to use this tool (for whole-bank consolidated analysis) and when to omit parameters (omit item for all banks). It explains when to set granularity to 'raw' for itemized rows and when to use detail levels. It warns about truncation at 5000 transactions per account.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description details what the tool returns: global indicator, degraded components, open incidents, and flags incidents affecting the user's connected banks. 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 concise yet thorough, with every sentence contributing meaningful guidance. It front-loads the core purpose, then provides context and use-case example, then lists return 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?

Given zero parameters and no output schema, the description is fully complete. It explains the tool's value, distinguishes it from siblings, and describes all return information needed for an agent to interpret results.

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

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

The tool has zero parameters, so the input schema is fully documented (100% coverage). The description doesn't need to add parameter details; baseline for 0 params is 4. The description adds no extra parameter info, which is appropriate.

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

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

The description clearly states the tool checks the 'LIVE operational status of the Open Finance provider', specifying the resource (provider status) and the action (checks). It distinguishes itself from the sibling 'openfinance_get_item_status' by clarifying it checks provider-side health, not the user's 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?

Explicitly states when to use: 'whenever data looks incomplete or stale even though a connection shows UPDATED'. It explains the tool helps differentiate provider-side problems from connection issues, and even mentions what to use instead (openfinance_get_item_status) for connection status.

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

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

Annotations declare readOnlyHint=true and idempotentHint=true. Description adds behavioral context: non-Open-Finance connectors have auto-update caveats, plan-based filtering, and the effect of omitting keywords. 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 every sentence adds essential information. It is well-structured with the main action first, then details on return values and caveats.

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

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

Without an output schema, the description thoroughly explains return fields (id, access, audience, linked connections, accounts, connect_url) and important caveats. It covers all necessary information for an agent to use the tool effectively.

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

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

Schema has no descriptions (0% coverage). Description adds examples for keywords, explains the effect of include_accounts=true, and notes the hint behavior when keywords is absent.

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 and returns specific fields. It distinguishes from siblings by specifying it's a pre-connect search tool, and explicitly says to call it before connecting.

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

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

Provides explicit guidance: call before connecting, keywords[] required, without it returns a hint. Implicitly differentiates from list tools by focusing on available connectors rather than existing connections.

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

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

The description discloses a significant side effect: recategorizing a transaction automatically creates a Category Rule for future similar transactions, which goes beyond the annotations (readOnlyHint=false, destructiveHint=false). It also mentions that per-item errors do not fail the entire batch, providing important 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 dense but every sentence adds value: purpose, endpoint, parameter shape, side effects, and error handling. It is well-structured 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?

Despite lacking an output schema, the description includes the response shape (updated, results, errors) and explains the automatic creation of Category Rules. It covers all necessary context for a developer to use the tool effectively, including batch behavior.

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

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

Schema coverage is 0%, so the description must compensate. It clearly explains the `items` parameter structure (array of { transaction_id, category_id }) and provides context on the origin of these IDs. While it does not enumerate all properties in detail, the explanation is sufficient 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?

Description begins with a clear verb ('Corrects the category of one or more transactions') and specifies the HTTP method and endpoint. It distinguishes itself from siblings like openfinance_list_transactions and openfinance_list_categories by explicitly referencing them as data sources for IDs.

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

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

The description explains that the tool is used to fix miscategorized transactions and improve future categorization by teaching Pluggy. It provides guidance on where to obtain transaction_id and category_id from sibling tools. However, it does not explicitly state when not to use it or contrast with alternatives like a hypothetical direct category update.

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 idempotentHint: true and destructiveHint: false, ensuring the tool is safe. The description adds minimal behavioral context beyond the input hint, so it meets the baseline but offers little extra value.

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

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

The description is concise with two sentences, front-loads the purpose, and includes essential usage guidance without unnecessary verbiage.

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 and incomplete parameter documentation, the description partially compensates by explaining the purpose and key input. However, it lacks details on expected behavior after submission and omits the 'context' parameter, leaving 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 must explain all parameters. It only describes the 'conversation' parameter ('include the conversation array'), leaving 'context' and 'message' undefined. This is insufficient for a 3-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?

The description clearly states the tool is for reporting bugs, missing features, or sending feedback. It uses a specific verb-resource combination ('report a bug') and is distinct from sibling tools, which are primarily financial 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 to include the conversation array with recent messages, which is helpful for reproduction. However, it does not explicitly state when to use this tool over alternatives, though no direct alternatives exist among siblings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds that it shows 'platform and adapter versions,' which gives slightly more context about the return value. However, it does not add substantial behavioral detail 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 that fully conveys the tool's purpose without any unnecessary words. It is front-loaded and efficient.

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

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

Given that there are no parameters and the tool's purpose is simple version retrieval, the description is complete. It tells the agent exactly what the tool does. The absence of an output schema is acceptable for such a straightforward 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?

There are no parameters, so the description does not need to add parameter semantics. The schema coverage is 100% (trivially). The baseline for zero parameters is 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 shows current MCP platform and adapter versions. The verb 'Show' and resource 'versions' are specific, and this tool is distinct from its siblings which are authentication, connection, and financial data 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?

While the description does not explicitly state when to use it versus alternatives, the purpose is self-explanatory. It is a simple version retrieval tool with no parameters, so usage context is implied. Missing explicit 'when-to-use' guidance is offset by the tool's simplicity.

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 it read-only and idempotent. The description adds specific behavioral details about the return content (MCPs, status, catalog counts), which goes 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?

Single sentence that is direct and informative. No unnecessary words or redundancy. Front-loaded with the action 'Returns'.

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 communicates what the tool returns. Could optionally mention that it's a snapshot, but not required for 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?

No parameters exist, and schema coverage is 100%, so the description doesn't need to add parameter info. Baseline of 4 for zero-parameter tools 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?

Clearly states it returns current toolkit state with specific components: installed MCPs, connection status, and catalog tool count. Distinct from sibling tools which focus on authentication, data retrieval, or actions.

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?

Usage is implied by the name and description, but no explicit guidance on when to use versus alternatives. It serves as an introspection tool, but the description doesn't provide contextual cues like 'use this to see installed MCPs'.

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