Méliuz MCP

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

Annotations indicate idempotentHint=true and destructiveHint=false. The description adds context: with no args returns a link, with token sets session. It doesn't disclose response details but does not contradict annotations. Good behavioral context beyond annotations.

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

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

The description is two sentences with front-loaded key info. The second sentence is somewhat lengthy with multiple clauses, but remains clear. Could be slightly more concise without losing meaning.

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

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

No output schema, so description must cover outcomes. It explains the two scenarios (with/without token) and what to expect (link or authentication). Lacks explicit response format, but sufficient for a simple authentication tool given the annotations.

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

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

Schema coverage is 0%, so description carries full burden. It explains the single optional parameter 'token' as a JWT to paste for session login, and that omitting it yields a login link. This adds complete meaning to the parameter.

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, specifying two methods (config vs session) and the target audience (IDE agents). It distinguishes itself from sibling tools like 'connect' and 'marketplace' which are unrelated.

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: for logging in via browser and copying token. It contrasts the permanent config method with the session-only token paste method, effectively guiding the agent. However, it doesn't explicitly state when not to use (e.g., if already authenticated).

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds meaningful behavioral context about the return values in different scenarios (all connected vs missing credentials), going beyond annotations.

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

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

Very concise two sentences that front-load the main purpose. No unnecessary words, every sentence adds value.

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

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

Given no parameters and no output schema, the description covers the essential behavior with two scenarios. Could be slightly more detailed on output structure, but adequate for a simple status 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 the schema (100% coverage). Description does not need to add param info. 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?

Clearly states it returns connection status and URLs, with specific conditions for different states. Distinguishes from siblings like authenticate, which likely initiates 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?

Implies usage for checking status, but does not explicitly state when to use this tool versus alternatives such as authenticate or other tools. No exclusions or alternative names 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?

Discloses key behaviors beyond annotations: invoke works even if MCP is not installed, runs one-off without adding to toolkit, returns connect link for credentials, checkout link for payment. Mentions write operations require workspace owner/admin. 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 thorough but verbose, consisting of a long paragraph without clear structure. While it front-loads the purpose, the density of information makes it harder to parse quickly. Could be more concise or bulleted.

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 complex tool with 13 parameters and no output schema, the description covers the core workflow, major actions, and important edge cases (credentials, payment). It could detail more parameters, but overall it provides a solid understanding of how to use the 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 schema coverage at 0%, the description adds significant meaning by explaining the action enum values (search, describe, install, etc.) and how parameters like mcp_id, tool_id, arguments are used in the flow. However, not every parameter (e.g., limit, immediate, tier_slug) is individually described, leaving some gaps.

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

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

The description clearly states that the tool is the official MCP marketplace, serving as the in-platform catalog and execution engine. It distinguishes from sibling tools by instructing to use this first before external registries, and outlines the core flow (search, describe, invoke).

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 when-to-use guidance: 'use THIS tool FIRST, before any external/generic registry'. Details the decision flow (search→describe→invoke) and explains when to use invoke vs install, and mentions install for permanent use. Also covers use cases for list_tools, subscribe, cancel, report_bug, request_mcp.

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: true), the description adds that connection data is deleted and no longer available, and it returns an add_connection_url for reconnection. 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?

Three sentences, each carrying distinct information: action, consequence, and return value. Front-loaded with the verb. 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?

Adequate for a simple destructive operation, but lacks parameter explanation and error handling context. No output schema, but the description mentions the return URL. Missing prerequisites like authentication or existing connection.

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

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

The sole parameter 'item' is undocumented in the schema (0% coverage). The description only hints that it identifies a bank, but does not specify format, expected values, or whether it's an ID or name. This leaves the agent guessing.

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

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

The description uses specific verbs 'Revokes' and 'deletes' with a clear resource 'Open Finance consent for a specific bank'. It distinguishes from sibling tools like openfinance_list_connections or openfinance_force_sync, which have different 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?

No explicit when-to-use or alternatives guidance. The purpose is evident from the description, but there is no mention of preconditions (e.g., bank must be connected) or when not to use it.

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

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

Beyond annotations (readOnlyHint=false, destructiveHint=false), the description details the HTTP method (PATCH), polling behavior, timeout (~60s), and returns including status fields, error states (needs_action, timed_out), and alternative tool for re-checking.

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

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

The description is thorough but slightly verbose (e.g., 'NOW and WAITS' capitalized for emphasis). However, it is well-structured with usage, parameters, and return details 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 no output schema, the description fully explains the return structure, error conditions, and provides guidance for re-checking with another tool. Covers all necessary aspects for effective use.

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

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

With 0% schema description coverage, the description fully explains both parameters: wait (boolean, implicit default) and items (array of selectors or omit for all). It adds meaningful context beyond schema types.

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 bank to re-sync connections and waits for completion, using a PATCH and polling. It distinguishes itself from sibling tools like openfinance_get_item_status by specifying its 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?

Explicit guidance on when to use (stale balances/transactions) and when not to (instead of disconnecting). Also explains how to target specific items or all banks, and the wait flag for fire-and-forget.

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

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

Annotations confirm read-only, idempotent, non-destructive. Description adds significant behavioral details: real-time aspect, array limits, CREDIT account error handling with structured warning instead of throwing, and response shape with results/errors. No contradictions.

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

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

Three sentences: first states purpose and endpoint, second covers parameter constraint and edge case, third describes response shape. No fluff, every sentence provides 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 single parameter and no output schema, description adequately covers response shape and key behavior. Missing minor details like authentication context (likely covered by sibling tools) but sufficient for agent to invoke correctly.

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

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

Schema has 0% description coverage but description specifies that account_ids is an array of strings with 1-50 items, adding meaning beyond the bare schema. Partially compensates for missing 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?

Clearly states it returns real-time balance per account id with endpoint (GET /accounts/:id/balance). Distinct from sibling tools like openfinance_get_accounts_detail or openfinance_list_accounts by focusing specifically on balance retrieval.

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

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

Specifies parameter constraints (array of 1-50 account_ids) and edge case for CREDIT accounts with BALANCE_FETCH_ERROR. However, does not explicitly state when to use this tool versus alternatives, lacking explicit contextual 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=true, destructiveHint=false, and idempotentHint=true. The description adds context about the batch output shape ({ results, errors }) and mentions extended creditData, 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 two sentences, front-loaded with the core purpose, and contains no redundant information. Every sentence contributes value.

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

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

For a simple tool with one parameter and no output schema, the description adequately covers input constraints and output shape. It mentions batch behavior, which is helpful 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?

With 0% schema coverage, the description compensates by specifying the array size limit (1–50) and explaining the purpose of the parameter (to get details by ID). This adds meaningful guidance 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 it returns full account objects with extended creditData per ID, using the GET /accounts/:id endpoint. It distinguishes from sibling openfinance_list_accounts by specifying the detailed retrieval.

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

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

The description provides a clear constraint for the account_ids array (1-50 items) and implies batch usage. However, it does not explicitly state when to use this tool versus openfinance_list_accounts or other 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 annotations (readOnlyHint, idempotentHint, destructiveHint), the description reveals batch shape, clarifies no individual transactions, notes Pluggy does not return paid/status field, and explains the billing cycle semantics of payments[]. 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 well-structured and front-loaded with the main purpose. It uses clear formatting with colons and a note. Slightly verbose but still efficient for the complexity of the tool.

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

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

Given no output schema, the description fully explains return fields (financeCharges, payments[] with subfields), what is not returned (individual transactions), how to get transactions, and critical payment semantics. Complete for this 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 description coverage is 0%, but the description compensates by explaining 'Pass bill_ids as an array' and directing users to discover ids via sibling tool. This adds meaningful context beyond the schema 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 'Returns bill-level detail for one or more credit card bills by id', specifying the resource and action. It distinguishes from sibling tools like openfinance_list_credit_card_bills (discovery) and openfinance_list_transactions (itemized transactions).

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

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

Explicitly states when to use (get bill-level detail) and when not to use (for transactions, use openfinance_list_transactions). Provides prerequisites: first discover ids with openfinance_list_credit_card_bills. Includes critical nuance about payments[] and recommends a sibling tool for paid 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 readOnly, idempotent, and non-destructive. The description adds behavioral context: the output structure varies (single object vs {count, items}), lists possible status values, and explains the conditional behavior based on the `item` parameter. 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 two sentences, front-loaded with the main purpose and quickly covers the parameter behavior without verbose or redundant statements. Every sentence adds clear value.

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

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

Given the tool's simplicity (one optional parameter, no output schema, no nested objects), the description covers the key aspects: purpose, parameter usage, and output format variability. It could be slightly more detailed on the exact return structure for each mode, but it is sufficient for a read-only tool.

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

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

The input schema has only one parameter `item` with no description (0% coverage). The description fully compensates by explaining that omitting it returns all banks and passing it returns a single bank, adding essential semantic meaning that the schema lacks.

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 tool returns the current status of a bank connection with concrete possible values (UPDATED, UPDATING, LOGIN_ERROR, etc.) and clearly distinguishes between two usage modes—omitting `item` for all banks or passing it for a single bank. This clearly separates 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 tells when to omit or include the `item` parameter, and the context of a read-only, idempotent tool implies safe usage. However, it does not mention alternatives among siblings or when not to use this tool, leaving some guidance implicit.

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

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

Annotations declare readOnlyHint, idempotentHint, and destructiveHint, indicating safe read-only behavior. The description adds critical behavioral context beyond annotations: credit card balance is connector-dependent and should not be treated as 'this month's bill', explaining creditData 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 lengthy but dense with essential information. It is front-loaded with the primary purpose and includes important nuances. While every sentence adds value, 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 and only two parameters, the description is remarkably complete. It covers return data, parameter effects, special data interpretation notes, and even cross-references sibling tools. No gaps remain.

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

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

Schema description coverage is 0%, so the description fully compensates. It explains the 'item' parameter (omit for all banks, pass for single bank) and the 'type' parameter implicitly through context of BANK and CREDIT. Adds meaning about how responses differ based on parameter usage.

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

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

The description clearly states the tool returns accounts for bank connections, specifying types (BANK, CREDIT) and data fields (balance, number, type, etc.). It distinguishes itself from siblings like openfinance_list_credit_card_bills by explicitly noting that for standardized bill amounts, the user should use that tool instead.

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

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

Provides explicit guidance on when to omit the 'item' parameter (to list across all banks) vs. pass it (target a single bank). Also warns against misusing 'balance' for credit cards and directs to openfinance_list_credit_card_bills for standardized billing information.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds value by revealing caching behavior (important for understanding freshness), the structure of entries (including Portuguese translation), and the fact that it's a single aggregated response. This goes beyond annotations without contradicting them.

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

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

The description is very concise at four sentences, front-loaded with the primary purpose, and each sentence provides essential information without redundancy. It efficiently covers the output structure and contextual hints.

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 the tool takes no parameters and has no output schema, the description thoroughly explains the return value (fields like id, description, descriptionTranslated, parentId, parentDescription), caching behavior, and relationship to a sibling tool. It is complete for the tool's complexity level.

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

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

The input schema has zero parameters, so schema description coverage is 100%. The description adds no parameter-level details because none exist. Baseline score of 3 is appropriate as the description does not need to compensate for any missing 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 identifies the tool as returning Pluggy's transaction category taxonomy, specifying the resource and action. It distinguishes from sibling tools like openfinance_list_accounts by focusing on category taxonomy, and provides concrete details about the data structure (id, description, parentId, etc.), making the purpose unmistakable.

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

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

The description mentions that the data is cached for the session, that the id is used by openfinance_update_transaction_category, and that it returns a single aggregated response. This gives clear context on when to use the tool (when needing category IDs for updating transactions) but does not explicitly list alternatives or exclusions, which is acceptable given the tool's straightforward nature.

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 the tool as read-only and idempotent. The description adds context about the return content, including add_connection_url for linking more banks. 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?

A single sentence that efficiently conveys purpose and return fields. Slightly long but clear; 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?

Tool is simple with no output schema. The description lists what is returned, which is sufficient for the agent to understand the output. No missing 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?

No parameters exist, so schema coverage is 100%. Per instructions, baseline is 4 for zero params. 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, listing specific fields (connector_id, item_id, bank name) and add_connection_url. It distinguishes from siblings like list_accounts which deal with different 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?

The description implies usage for listing connections but does not explicitly state when to use it vs alternatives or provide exclusions. Siblings are diverse, but no direct guidance is given.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds extensive behavioral context: payment semantics, derived payment_status logic, connector asymmetry, and that results are bill-level summaries. 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 efficiently packed with essential information. It is front-loaded with core functionality and structured with logical sections. 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 comprehensively explains the return structure (payments array, derived fields, open_bill, future_bills) and provides interpretation guidance (payment_status logic, connector asymmetry). It is complete for the tool's purpose.

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

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

Schema coverage is 0%, so description must compensate. It explains include_open_bill in detail, mentions account_id, account_ids for bulk, and implies pagination with page and page_size. However, page and page_size are not explicitly described, but their usage is standard. Overall adds significant 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 the tool returns closed credit card bills for CREDIT-type accounts, listing specific fields like due date, payments, and derived payment status. It distinguishes from siblings like openfinance_get_credit_card_bill (single bill) and openfinance_list_transactions (individual transactions).

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

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

Explicitly says when to use (for closed bills) and provides alternatives: use openfinance_list_transactions for itemized purchases, and opt-in include_open_bill for open bills and total debt. Also warns about connector asymmetry and provides guidance on interpreting 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 and destructiveHint=false, so the description adds value by detailing the graceful error handling and the types of investments included. It does not mention pagination behavior or authentication needs, but these are less critical given the annotations.

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

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

The description is a single long sentence that packs many details but lacks paragraph breaks. It is not overly verbose, but could be more concise and structured for readability.

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

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

The description explains the return structure (fields like balance, amount, etc.) and error behavior, which is helpful given no output schema. However, it does not cover pagination or parameter semantics, leaving gaps for a comprehensive 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?

The input schema has four parameters (item, page, type, page_size) with no descriptions. The tool description does not explain any of them, leaving the agent to infer meaning from names alone. With 0% schema description coverage, the description fails to compensate.

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 portfolios for connections with INVESTMENTS product, listing specific asset types. It uses a specific verb ('Returns') and resource ('investment portfolio'), but does not explicitly differentiate from sibling tools like openfinance_list_accounts or openfinance_list_transactions.

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

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

The description provides guidance on error handling (returns a structured response instead of throwing), but does not indicate when to use this tool versus alternatives or any prerequisites for using it.

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

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

The description adds meaningful behavioral context beyond the annotations: it details the types of transactions returned (BUY, SELL, TAX, etc.) and itemized fields (expenses, agreedRate, brokerageNumber). Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and the description aligns with these. 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 concise, with two short paragraphs that front-load the core purpose and usage. Every sentence adds value, and there is no unnecessary repetition or verbosity.

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

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

Given the tool's complexity (4 parameters, no output schema), the description covers major aspects: purpose, usage sequence, bulk support, and return field details. However, page/page_size parameters are not explained, and the response format is omitted. A more complete description would briefly describe pagination or output structure, but it remains sufficient for most use cases.

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

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

The input schema has 0% description coverage. The description explains investment_id and investment_ids ('Bulk support: accepts investment_ids for batched execution'), but does not describe page and page_size parameters. Since the description must compensate for the schema's lack of parameter documentation, partial coverage warrants a score of 3.

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 movement history for a specific investment position, listing transaction types (BUY, SELL, etc.) and fields. It distinguishes itself from sibling tools like openfinance_list_investments by focusing on transactions for a given investment.

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 to use it after openfinance_list_investments to obtain the investment_id, and mentions bulk support via investment_ids. This provides clear context for when to use the tool, though it does not specify when not to use it or list alternatives.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description adds value by disclosing sequential queries with rate-limit spacing and per-connection error handling. 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 (two sentences) and effectively front-loaded with the core purpose. Every sentence adds necessary detail about parameters, behavior, and return format 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 the tool has no output schema, the description supplies the return format ({results, errors} per connection). It covers all behavioral aspects: input parameter explanation, two usage modes, rate-limiting, and per-connection results. No gaps.

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

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

The input schema has one undocumented parameter (items). The description fully compensates by explaining it can be an array of connection selectors with possible types (item_id, connector_id, connector_name) and that omitting it lists all banks. This adds substantial meaning beyond the schema.

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

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

The description clearly states it lists loan contracts per bank connection with a specific HTTP method and endpoint. It distinguishes from siblings by specifying that it returns loans, not accounts or transactions, and describes two modes: per-connection via 'items' or all banks.

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 use this tool: for listing loans from specific connections or all linked banks. It explains the two usage patterns but does not explicitly contrast with sibling tools, though the purpose is distinct.

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: bank-specific POSTED behavior, upstream error handling (returns warning/error instead of throwing), truncation when using search_queries, and the fact that bulk account_ids are supported. 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?

Despite length, every sentence adds value. Well-structured: general purpose, credit card specifics, date/pagination/search details, error handling, bulk support. No wasted words; the density of information is justified by the complexity of the tool.

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

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

Covers all aspects: return values (implied from description), error conditions (upstream errors, total 0), search behavior, pagination, and bulk execution. For a tool with 7 parameters and no output schema, the description is complete and leaves no critical 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%, but the description fully compensates: it explains date format (ISO YYYY-MM-DD), page_size max (500), search_queries semantics (case- and accent-insensitive substring match, OR logic), and the aggregation behavior (up to 5000 transactions before filtering). Each parameter's purpose and special behavior are clarified.

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 transactions for BANK or CREDIT accounts. Distinguishes itself from sibling tools like openfinance_list_credit_card_bills by explicitly stating this is the ONLY way for itemized credit card transactions, and mentions the alternative for bill totals.

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 when-to-use (for itemized credit card transactions, generalized for bank accounts), when-not-to-use (for standardized bill totals, use the bill tool), and behavioral nuances (PENDING vs POSTED varies by bank). Also gives pagination hints and error handling strategies.

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 details beyond annotations: it resolves accounts internally, fans out transactions, caps data at 5000 transactions per account with a truncation flag, and describes the default behavior (monthly granularity returns a compact summary without raw rows). Annotations indicate read-only and idempotent, and the description aligns fully 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?

The description is dense but not overly verbose. It front-loads the main purpose and progressively adds details. Each sentence adds value, though it could be slightly more concise by merging some related points. Still, it is well-structured and avoids redundancy.

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

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

Given the tool's complexity (6 parameters, no output schema), the description is remarkably complete. It explains default behavior, output structure for each granularity (compact summary fields like total entradas, saídas, saldo_liquido, monthly evolution, top expenses/revenues, per-account breakdown), and the truncation mechanism. No essential information is missing for an AI agent to select and invoke this 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 the description must compensate for missing parameter descriptions. It explains 'from' and 'to' as ISO dates, 'item' as connector_id/connector_name/item_id, 'granularity' with default 'monthly' and what it returns, and 'type' as BANK or CREDIT filter. The 'top_n' parameter is not explicitly linked but implied by 'largest N each'. Overall, parameters are well-covered despite 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: 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call.' It specifies the verb (analyze/fetch) and resource (connection transactions), and distinguishes from siblings by explaining it resolves accounts internally, eliminating the need for separate calls to list accounts or manage account 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?

Explicit usage guidance is provided: 'Use this for 'análise anual/mensal', 'fluxo de caixa', 'entradas e saídas', 'maiores gastos/recebimentos'. It also explains when to use the 'raw' granularity (when itemized rows are needed) and when to omit the 'item' parameter (to analyze all linked banks). This clearly differentiates when to use this tool versus siblings 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 declare readOnlyHint, idempotentHint, and destructiveHint. The description adds value by specifying the tool returns live data and lists specific outputs (global indicator, degraded components, incidents, your_banks_affected), which clarifies behavioral expectations 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 well-structured: it opens with the core action, then provides usage context, and finally lists return values. While slightly verbose, every sentence adds value. Front-loading is effective.

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

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

Despite lacking an output schema, the description sufficiently explains return values and how they aid troubleshooting. It also contextualizes the tool among sibling tools by emphasizing its role in diagnosing provider-side issues, making it complete for a zero-parameter tool.

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

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

No parameters exist, so parameter semantics are not needed. Schema coverage is 100% (empty object). The description does not need to add param information, earning a baseline score 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 checks the LIVE operational status of the Open Finance provider, distinguishing it from connection-level status tools like openfinance_get_item_status. The verb 'checks' and resource 'provider status' are specific and unambiguous.

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

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

Explicitly describes when to use (when data appears incomplete/stale despite updated connection) and explains how it helps differentiate provider-side issues from connection problems. Could be improved by naming alternative sibling tools, but the context is clear.

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

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

Adds behavioral context beyond annotations: plan filtering (PF plan hides PJ banks), the hint behavior when keywords are empty, and the generation of a pre-selected connect_url. 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?

Four sentences pack all essential info, front-loaded with purpose then details and usage. No fluff, but could be slightly more structured (e.g., bullet points). Still highly 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?

Covers all key aspects: what it does, what it returns, usage guidance, and notable behaviors. Without output schema, it adequately describes the return values. Missing example response but not necessary.

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

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

Despite 0% schema coverage, the description explains both parameters thoroughly: keywords with examples and requirement, include_accounts with its effect. Adds substantial meaning beyond the schema.

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

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

The description clearly states it searches bank connectors by name, specifies output fields (connector id, access, audience, linked connections, connect_url), and uses a specific verb 'searches'. It implicitly differentiates from siblings by being the only search tool.

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

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

Explicitly advises to call 'BEFORE connecting' and notes that without keywords it returns a hint (never dumps entire catalog). Also mentions plan filtering behavior. Provides clear when-to-use context and warns against misuse.

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 goes well beyond annotations by disclosing that recategorizing overrides Pluggy's automatic categorization and creates a Category Rule for future similar transactions, plus the batch error handling shape. 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 thorough and well-structured, front-loading the core purpose. While some detail could be trimmed without losing value, every sentence is informative and earns its place.

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

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

Given the tool's complexity (batch update with side effects and error handling), the description covers input sources, behavioral implications, and return shape comprehensively. No identified 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?

Despite 0% schema description coverage, the description fully explains the 'items' parameter structure, required fields, and source of IDs from other tools. This adds critical meaning that the raw JSON schema lacks.

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 starts with a clear action: 'Corrects the category of one or more transactions.' It specifies the HTTP method and endpoint, and distinguishes this tool from siblings like openfinance_list_transactions by focusing on mutation and categorization side effects.

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 using this tool 'to fix miscategorized transactions and improve categorization accuracy going forward.' It also tells where to get transaction_id and category_id from sibling tools, providing clear context. However, it does not explicitly state when not to use it.

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

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

Annotations indicate idempotentHint=true and destructiveHint=false, so the description adds value by specifying the reproduction requirement. No contradictions, and the description is consistent with the safe read-like behavior implied by annotations.

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

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

The description is two sentences with no wasted words: the first states purpose, the second gives usage instructions. This is highly efficient 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?

For a simple feedback tool with no output schema, the description covers purpose and a key parameter, but omits details on the 'context' parameter and return behavior, making it adequate but not thorough.

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

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

With 0% schema description coverage, the description only partially explains the conversation parameter but fails to detail the required 'message' or optional 'context', leaving significant ambiguity for an agent.

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 feedback, which is specific and distinct from sibling tools that focus on 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?

It explicitly says to include the conversation array for reproduction, which provides actionable guidance. It does not exclude other scenarios, but no alternatives are needed as this is a unique feedback 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 provide readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds specific context about what versions are shown (platform and adapter), enhancing transparency beyond the annotations.

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

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

The description is a single sentence of 9 words, perfectly concise for a simple info tool with no parameters. Every word is necessary and no waste.

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

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

The tool has no parameters, no output schema, and no nested objects. The description fully covers what the tool does. No additional information is needed.

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

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

There are no parameters (0), so the description does not need to explain parameters. Baseline score of 4 applies as per guidelines.

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

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

The description uses a specific verb 'Show' and clearly identifies the resource: 'current MCP platform and adapter versions.' It distinguishes itself from all sibling tools, none of which relate to version information.

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

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

The description implicitly indicates when to use this tool (to check versions) but does not explicitly state when not to use it or list alternatives. However, given the context, it is obviously the correct tool for version queries.

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 specifying what the state includes (installed MCPs, connection status, catalog tool counts), but does not introduce any behavioral 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 sentence that is clear, front-loaded, 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?

With zero parameters, rich annotations, and no output schema, the description sufficiently explains what the tool returns without missing critical details.

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 baseline is 4. The description adds no parameter information, which is appropriate given no parameters exist.

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

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

The description clearly states the tool returns the current toolkit state with specific details: installed MCPs, connection status, and catalog tool counts. It distinguishes itself from sibling tools like openfinance_* and authenticate, which focus on financial operations or authentication.

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

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

The description implies usage for checking toolkit state, but lacks explicit guidance on when to use it versus alternatives or when not to use it.

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