Uber Conta by Digio MCP

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

Annotations indicate idempotency and non-destructive behavior. The description adds value by detailing the two authentication modes (permanent vs. session) and explaining the flow (log in browser, copy token). It also notes the permanence of the config header method, providing behavioral context beyond what annotations offer.

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: two sentences that immediately convey the tool's purpose and usage. Every sentence adds necessary value, and the structure is front-loaded with the most critical information.

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

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

For an authentication tool with one optional parameter and no output schema, the description is fully complete. It explains both usage modes, how to obtain the token, and the implications of each method. No additional context 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?

The schema has no description for the 'token' parameter (0% coverage). The description compensates by explaining that the token is a JWT obtained from browser login, and how to use it for session authentication. This adds significant meaning, though it could be more explicit about the token format.

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

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

The description clearly specifies the tool's purpose: authenticating the user by either configuring a permanent token in the server config or providing a session token. It delineates distinct usage scenarios (permanent vs. session) and differentiates from sibling tools like 'connect' by focusing on 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 guidance on when to use the tool: for session login with a token, or for permanent setup via config header. It also implies calling with no arguments to get the login link. However, it does not explicitly state when not to use this tool or list alternatives 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 and destructiveHint=false. The description adds behavioral details: return values for connected vs missing credentials, including authenticated field and URLs. Does not contradict annotations.

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

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

Two sentences, zero waste. Front-loaded with purpose. Every sentence adds value explaining two scenarios.

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

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

Fully complete for a parameterless read tool with no output schema. Explains return values in two clear scenarios. No gaps.

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

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

No parameters, baseline 4. Description adds no parameter info as none exist.

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

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

Clearly states 'Returns connection status and URLs' and explains two distinct states (all connected vs missing credentials), providing specific fields and URLs. Distinguishes from siblings like openfinance_list_connections which lists 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?

Implies usage for checking overall connection status but does not explicitly state when to use versus alternatives like authenticate or openfinance_list_connections. No exclusions or prerequisites mentioned.

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

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

The description discloses key behavioral traits beyond annotations: it explains that invoke works even without installation, that it may return connect/checkout links, and that writes require owner/admin. It also describes the core flow and its actions. There is 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 lengthy. It is well-structured, starting with the purpose and core flow, then key behaviors. While every sentence adds value, it could be more concise by grouping related details. The front-loading of the primary purpose 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?

Given the tool's complexity (13 parameters, multiple actions, no output schema), the description covers the main flow, permissions, and key behaviors. It explains what invoke returns but does not detail output for other actions like search or describe. Overall, it is quite complete but not exhaustive.

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, so the description must compensate. It explains the action parameter and its enum values, and elaborates on invoke-related parameters (tool_id, arguments, mcp_id, immediate). However, many parameters like limit, query, message, tier_slug, conversation, request_name, report_context, request_details are not explained, leaving significant 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 this is 'THE official mcp.ai marketplace' and details its primary functions: discovering, describing, installing, and invoking MCP tools. It specifies that it should be used first before any external registry, and distinguishes itself from sibling tools by being the central catalog and runner.

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 this tool: 'When the user wants a capability... use THIS tool FIRST'. It also explains when to prefer invoke over install, and mentions that certain actions require workspace owner/admin. It differentiates from other tools like report_bug and 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?

The description adds context beyond the destructiveHint annotation by stating that bank data becomes unavailable and that a re-connection URL is returned. It does not contradict annotations and provides useful behavioral details.

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 concise sentences, front-loaded with the core action. No wasted words. The structure efficiently conveys purpose, effect, and return 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 annotations, the description covers purpose, effect, and return. However, the missing parameter explanation and lack of prerequisites (e.g., authentication needed) make it slightly incomplete.

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

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

The description does not explain the required 'item' parameter (e.g., what it represents, how to find its value). With 0% schema coverage, the agent must guess what 'item' refers to, despite the description mentioning 'a specific bank'.

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', 'deletes') and clearly identifies the resource ('Open Finance consent for a specific bank'). It distinguishes itself from sibling tools like connect or list_connections by focusing on disconnection and data deletion.

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

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

The description implies the tool is for disconnecting a bank but lacks explicit when-to-use or when-not-to-use guidance. It does not mention alternative tools or contexts where other tools (e.g., openfinance_force_sync) might be more appropriate.

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 that the tool waits up to ~60s, polls until completion, and returns results with status fields like timed_out, needs_action, and synced. It also explains what needs_action means (user must reconnect). Annotations are consistent (readOnlyHint=false). The description adds valuable behavioral context beyond annotations, though it could mention auth requirements or rate limits.

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

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

The description is moderately long but well-structured: primary action first, then usage context, parameter details, and return value 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 the moderate complexity (2 params, no output schema), the description thoroughly explains the return object structure (results/errors, fields like status, executionStatus, lastUpdatedAt, synced, needs_action, timed_out) and provides interpretation guidance. This ensures the agent understands what to expect from 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?

Schema description coverage is 0%, but the description fully explains both parameters: wait (boolean, for fire-and-forget) and items (array of selectors, omit for all linked banks). This compensates well for the lack of schema descriptions, providing clear meaning and usage beyond the 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 re-sync NOW and waits for it to finish. It specifies the verb (force), resource (bank connections), and action (re-sync without disconnecting), distinguishing it from siblings like openfinance_get_item_status and openfinance_disconnect_bank.

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

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

The description explicitly says when to use the tool: 'when a balance or transaction list looks stale'. It clarifies it pulls fresh data without disconnecting/reconnecting, and provides guidance on omitting items to sync all linked banks and setting wait: false for fire-and-forget. It also suggests re-checking with openfinance_get_item_status on timeout.

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, meaning the tool is safe and idempotent. The description adds critical behavioral context: the response is real-time (not cached), the array size limit (1-50), special error handling for credit accounts (structured warning instead of throwing), and the response shape with results and errors.

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 extremely concise: two sentences covering the endpoint, array constraints, error behavior, and response format. Every sentence adds value with 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?

Given the tool has only one parameter and no output schema, the description provides complete guidance: what the tool does, how to use it, special cases (credit account errors), and the response structure. The annotations already cover safety and idempotency, leaving 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 only defines account_ids as an array of strings with 0% description coverage. The description compensates by specifying that it must be an array of 1-50 elements, which is not captured in the schema (no min/max). This adds meaningful constraint 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 the tool returns real-time balance per account ID, includes the exact API endpoint (GET /accounts/:id/balance), and distinguishes from sibling tools like openfinance_list_accounts and openfinance_get_accounts_detail by focusing on balance retrieval.

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

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

The description provides clear usage instructions: pass account_ids as an array of 1-50 IDs, and warns about CREDIT accounts returning BALANCE_FETCH_ERROR with a structured warning. However, it does not explicitly state when to use this tool versus alternatives (e.g., for single vs. bulk, or real-time vs. cached).

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 significant behavioral context beyond annotations: batch shape { results, errors } and array limit. No contradiction with annotations (readOnlyHint, idempotentHint consistent).

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

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

Single efficient sentence with key info: purpose, endpoint, input format, response shape. 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?

Sufficient for a simple one-parameter batch retrieval tool. Lacks mention of error handling details or authentication, but annotations cover destructive/idempotent hints. Missing output schema but description outlines batch shape.

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 description provides usage semantics (array of account IDs, size limit 1-50). Does not explain the source or nature of the IDs (e.g., from list accounts).

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?

Clear verb ('Returns'), specific resource ('full account objects including extended creditData'), and additional detail on batch shape and ID array. Distinguishes from siblings by specifying the level of detail and primary key lookup.

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?

States input format (array of 1-50 IDs) and response shape, but does not explicitly explain when to choose this tool over alternatives like openfinance_list_accounts or openfinance_get_account_balance.

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. Description adds valuable context: Pluggy does not return paid/status field, explains the unusual semantics of payments[] (refers to previous bill), and describes batch shape { results, errors }.

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 slightly long but every sentence serves a purpose. Front-loaded with main purpose and returns, then crucial notes. Could be tightened slightly, but given complexity, it's well-structured.

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

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

Comprehensive for a batch bill fetch tool: covers input (bill_ids array), output shape (results, errors), returned fields, and the non-obvious payment interpretation. Handles the lack of output schema by describing return fields.

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

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

Schema description coverage is 0%, but description fully compensates: explains parameter `bill_ids` is an array, tells how to obtain IDs (use list tool), and implies they are strings. No additional parameters 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?

Description clearly states it returns bill-level detail for credit card bills by ID, explicitly lists returned fields (financeCharges, payments[]), and distinguishes from sibling tools by stating what it does NOT return (individual transactions) and directing to openfinance_list_transactions for itemized data.

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

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

Provides explicit guidance: use openfinance_list_credit_card_bills first to discover IDs, use openfinance_list_transactions for transactions, and includes a critical caveat about interpreting payments[] and checking paid status via the list tool.

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

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

Description adds details beyond annotations: return values, executionStatus, connector metadata, and return shapes for both cases. No contradictions with annotations (readOnly, idempotent). Could mention error handling, but sufficient.

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

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

Two sentences with no wasted words: first states purpose, second provides usage guidance. Front-loaded with key information, 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?

For a simple read-only tool with one parameter, the description covers main use cases and return structures. No output schema exists, so shape details are helpful. Could include default behavior or error states, but overall adequate.

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

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

Schema coverage is 0%, but description fully explains the `item` parameter's effect: omitting returns all banks as { count, items }, passing returns single. This adds essential meaning beyond the bare schema.

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

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

Description clearly states it returns status of bank connections with specific enum values (UPDATED, UPDATING, LOGIN_ERROR) and metadata. Distinguishes two modes (all vs single) which differentiates from similar 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?

Explicitly explains when to include or omit the `item` parameter and the corresponding return shapes. Does not mention alternatives or when not to use, but the guidance is clear enough for an agent to decide between all vs single.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, etc. The description adds significant behavioral context beyond annotations: explains that credit card `balance` is connector-dependent and not equivalent to a bill, clarifies that `name` is the legal entity not the brand, details aggregation behavior when `item` is omitted, and specifies response structure (root vs. per-row identifiers). 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 longer but every sentence adds value—front-loading the main purpose, then covering nuances, parameters, and caveats. It is well-structured and avoids redundancy, though a trimming of connector-specific examples could make it slightly more 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?

Given the tool's complexity (multiple account types, aggregation, connector-dependence, billing nuances) and the lack of an output schema, the description is remarkably complete. It explains response fields, naming conventions, parameter usage, and important caveats, and even cross-references a sibling tool for complementary functionality. No gaps remain for an agent to misuse 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?

Schema has 0% description coverage, so the description fully compensates. The `item` parameter is thoroughly explained (omit for all banks, pass for specific). The `type` parameter is implicitly covered by mentioning account types (BANK and CREDIT) and their subtypes in the context, but a direct statement that `type` filters by account type would be clearer. Still, the description adds significant meaning beyond the schema.

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

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

The description clearly states the tool returns accounts for bank connections (BANK and CREDIT types) with specific data fields, and distinguishes between listing all linked banks vs. a single bank via the `item` parameter. It uses specific verbs and resources, making the purpose unambiguous.

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

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

Explicit guidance is provided: when to omit `item` (to list across all banks) and when to pass it (to target a single bank). It also warns against misusing `balance` for credit accounts and directs users to a sibling tool (`openfinance_list_credit_card_bills`) for standardized billing data, clearly differentiating from alternatives.

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

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

The description adds value beyond annotations by revealing that the data is cached per adapter session, is a single aggregated response, and details the entry structure. No contradiction with annotations (readOnlyHint, idempotentHint).

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

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

The description is extremely concise: two sentences that front-load the purpose, then provide necessary structural details. Every sentence earns its place with 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 parameters, good annotations, and no output schema, the description fully covers what the tool does, what it returns, caching behavior, and relation to another tool. It is complete for this simple tool.

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

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

The tool has zero parameters, so the description does not need to provide parameter details. According to guidelines, baseline is 4 for 0 parameters.

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

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

The description clearly states it returns 'Pluggy's transaction category taxonomy' and specifies the structure of each entry (id, description, descriptionTranslated, parentId, parentDescription). It also distinguishes itself from siblings by noting it's a single aggregated response with no batch 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 implies when to use (when needing category taxonomy, especially for the id used by openfinance_update_transaction_category) and mentions caching per adapter session, but does not explicitly state when not to use 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 readOnly, idempotent, non-destructive. Description adds value by specifying that an add_connection_url is returned, which is not obvious from annotations. No contradictions.

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

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

Single sentence with no redundancy, front-loaded with the core action 'Returns the saved bank connections for this install'. Every word 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?

Fully adequate for a zero-parameter, read-only list tool. Covers return fields and includes the noteworthy add_connection_url. No output schema needed for a simple list.

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; schema coverage is 100%. Description adds no param info but does not need to. Baseline 4 applies.

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

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

Description clearly states the tool returns saved bank connections and lists the specific fields (connector_id, item_id, bank name, add_connection_url). Effectively distinguishes from sibling tools like openfinance_list_accounts by focusing on 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?

Implied usage: list connections before operating on specific items. No explicit when-to-use or when-not-use guidance nor mention of alternatives, but the purpose is clear from context.

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

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

Annotations (readOnlyHint, idempotentHint) indicate safe, portable calls. Description adds deep behavioral context: payment cycle semantics, payment_status derivation logic, connector asymmetry, and the fact that open_bill requires an extra scan. No contradictions with annotations.

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

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

The description is very long and front-loads the main purpose but then dives into complex payment logic. While all information is relevant, it could be more structured, perhaps using bullet points or shorter sentences. Still, 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 covers the return fields (payments, payment_status, open_bill, etc.), error scenarios (product not enabled), and edge cases (connector asymmetry, cycle semantics). It is complete for the tool's complexity.

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

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

Schema coverage is 0%, so description bears the burden. It explains account_id, account_ids, and include_open_bill but does not explicitly describe page and page_size parameters. While their purpose is implied, explicit descriptions would improve clarity.

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. It differentiates from sibling tools like openfinance_get_credit_card_bill and openfinance_list_transactions, which are for single bills or 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 tells when to use this tool vs alternatives, e.g., 'To see itemized purchases/charges per bill, use openfinance_list_transactions...'. Also explains when to use open_bill parameter and notes the warning for missing product. Provides clear context on payment status interpretation.

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 valuable context about error handling (returns a warning object on 403 or upstream errors) and the nature of the returned data, 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?

The description is informative and well-structured, front-loading the main purpose. It is efficient with no redundancy, though it could be slightly more 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?

Without an output schema, the description partially describes return fields but omits the overall response structure (the 'results' array shape) and parameter usage. The tool has 4 parameters, and the description does not cover pagination or connection identification, making it incomplete.

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 is expected to explain parameters. It does not describe the meaning of 'item', 'page', 'type', or 'page_size'. The 'type' enum is listed in an overview but not linked to the parameter. Pagination and connection identification are left unexplained.

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

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

The description clearly states the tool returns investment portfolio data for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.) and data fields. It differentiates from sibling tools like list_investment_transactions by focusing on the portfolio summary.

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

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

The description implies usage for obtaining investment portfolio data but does not explicitly state when to use this tool versus alternatives such as list_investment_transactions. No exclusions or prerequisites are mentioned, limiting guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the description adds value by detailing the returned fields (quantity, value, amount, netAmount, etc.) and transaction types. It also mentions bulk support via investment_ids, which is a behavioral trait 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?

Two concise sentences plus a brief mention of bulk support. Front-loaded with purpose and transaction types, then returned fields, then bulk capability. No redundant information; every sentence 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?

Covers prerequisites, transaction types, returned fields, and bulk support. However, missing pagination parameters and ambiguous parameter semantics (single vs bulk investment_id usage) reduce completeness. No output schema exists, so description should be more thorough about the return structure.

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

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

Schema has 0% description coverage, so description must compensate. It explains investment_id and investment_ids for bulk support, but completely omits page and page_size (pagination params). It does not clarify whether investment_id and investment_ids are mutually exclusive or how to combine them with pagination. This leaves significant ambiguity.

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

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

The description clearly states it returns movement history for a specific investment position, lists the transaction types (BUY/SELL/TAX/INTEREST/AMORTIZATION/TRANSFER), and explicitly mentions using it after openfinance_list_investments to get the investment_id, distinguishing it from sibling tools that handle general transactions or investment listings.

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 to use this tool after openfinance_list_investments to obtain the investment_id, implying the sequential workflow. It does not explicitly state when not to use it or compare to siblings like openfinance_list_transactions, but the context is sufficient for typical usage.

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

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

Discloses sequential querying with rate-limit spacing and per-connection result structure. Annotations already declare readOnly and idempotent, and description adds valuable detail beyond them 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?

Two well-structured sentences: first states purpose, second explains usage. Every sentence adds value; 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?

Single parameter fully described, output format summarized (results/errors), behavioral context given. No gaps for intended 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 coverage, description fully explains the `items` parameter: type (array of connection selectors), selector formats (item_id, connector_id, connector_name), and effect of omitting. No ambiguity.

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

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

Clearly states it lists loan contracts per bank connection via GET /loans. Identifies the resource (loans) and action (list), which distinguishes it from sibling tools like openfinance_list_accounts.

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

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

Explains how to use the `items` parameter for specific connections or omit for all banks, including rate-limit spacing. Lacks explicit comparison to alternatives, but context is clear.

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

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

Annotations already indicate readOnly/idempotent/destructive hints. Description adds significant behavioral context: error handling (returns {total:0,...} instead of throwing), aggregation up to 5000 transactions, credit card PENDING/POSTED variation per bank, and need for force sync if sync failed. No contradictions.

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

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

Description is comprehensive and well-structured with logical sections, but slightly lengthy. Every sentence adds value; no redundancy. Additional conciseness could be achieved by condensing some details, but overall excellent.

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 7 parameters, no output schema, and complex behavior, the description covers all necessary aspects: input parameters, filtering, pagination, error handling, edge cases (credit card variation), and sibling relationships. Describes return shape {total, results, warning, error} in absence of output schema.

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

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

Schema has 0% coverage, but description compensates fully. Explains all parameters: from/to date formats, pagination (max 500/page), search_queries (case-insensitive substring, OR semantics), and bulk support via account_ids. Also explains behavior when search_queries is set (aggregates up to 5000 before filtering).

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 accounts, distinguishes CREDIT vs BANK, and explicitly says it's the only way to get itemized transactions for credit cards. Distinguishes from openfinance_list_credit_card_bills by noting that for standardized totals use the other 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?

Provides explicit when-to-use guidance: for credit card transactions use this tool, for standardized totals use openfinance_list_credit_card_bills. Advises narrowing date ranges if truncated:true returned, and suggests checking connection health if total is 0 for CREDIT accounts.

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

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

Beyond annotations (readOnly, idempotent, non-destructive), the description adds critical behavioral details: internal fan-out across accounts, compact vs raw granularity, truncation at 5000/account with `truncated:true` flag, and default monthly aggregation. 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 long but every sentence adds value, covering purpose, parameters, behavior, and limitations. It is front-loaded with the main purpose. However, it could be slightly more structured (e.g., bullet points) for easier scanning. 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?

Given 6 parameters, no output schema, and richness of sibling tools, the description is fully complete. It explains the return structure (entradas, saídas, saldo_liquido, por_mes, top_despesas/recebimentos, by_account), the scan limit, and the effect of granularity. An agent can select and invoke correctly without additional 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?

With 0% schema coverage, the description fully explains all 6 parameters: `item` (connector_id/name/item_id, or omit for all), `from`/`to` (ISO dates), `granularity` (monthly vs raw), `type` (BANK/CREDIT), and `top_n` (implied in top expenses/receipts). This compensates entirely for the 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?

The description clearly states the tool performs 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call.' It distinguishes from siblings like openfinance_list_accounts and openfinance_list_transactions by emphasizing internal account resolution and aggregated output. The verb 'analyze' and resource 'connection transactions' are specific and unique.

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 given: use for 'análise anual/mensal, fluxo de caixa, entradas e saídas, maiores gastos/recebimentos'. It states when NOT to need other tools: 'you do NOT need to call openfinance_list_accounts first'. It also explains how to target one bank vs all. This provides clear when-to and when-not-to context.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds behavioral detail beyond annotations by specifying the response content: global indicator, degraded components, open incidents, and flagged affected 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?

The description is comprehensive and well-structured, front-loading the purpose and usage then detailing the output. Every sentence adds value, though slightly verbose for a zero-parameter 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?

For a zero-parameter tool with no output schema, the description fully covers purpose, usage scenarios, and return content. It is complete and leaves no ambiguity.

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 (0 params, 100% schema coverage). Per the guidelines, baseline is 4. The description does not need to add parameter info.

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

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

The description clearly states the tool checks the LIVE operational status of the Open Finance provider, distinguishing it from the sibling tool 'openfinance_get_item_status' (which checks connection 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?

Explicit usage guidance is provided: 'use it whenever data looks incomplete or stale even though a connection shows UPDATED', with concrete examples like missing accounts/transactions/balances. It explains what the tool reveals (upstream outage, known incident) and how it helps differentiate provider-side problems from connection issues.

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

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

Beyond annotations (readOnly, idempotent), the description discloses plan-based filtering, behavior without keywords, and return fields. This adds significant behavioral context. 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?

Concise at 3-4 sentences, front-loaded with core purpose, and efficiently packs return fields, usage guidance, and special behaviors 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?

Covers return fields, parameter effects, and usage context. Lacks detailed output structure or error handling, but for a search tool without output schema, this is adequate and distinguishes it from 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?

With schema coverage at 0%, the description fully explains both parameters: keywords format and requirement (with example), and include_accounts effect on returning accounts. The discrepancy on required status is minor and adds clarity.

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 what it returns (connector id, access type, audience, linked connections, accounts, connect_url), and includes usage context (call before connecting). It effectively distinguishes from sibling list tools by focusing on search and pre-selection.

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 this before connecting and that keywords are required (without it returns a hint). Mentions plan-based filtering. However, it does not explicitly exclude scenarios where alternatives like openfinance_list_connections might be more appropriate.

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 beyond annotations by disclosing side effects: 'recategorizing a transaction automatically creates a Category Rule for this client,' affecting future transactions. It also describes batch response structure including errors, which annotations do not cover.

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 and front-loaded with the main purpose. It is somewhat dense but every sentence adds value. No wasted words, though slightly longer due to thoroughness.

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 provides the return shape and error structure. It covers input, side effects, batch behavior, and implications for future categorization. The tool's complexity is well-addressed.

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 fully by explaining that `items` is an array of { transaction_id, category_id } and specifying the source of each ID (openfinance_list_transactions and openfinance_list_categories). This adds crucial meaning absent from the schema.

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

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

The description clearly states the action: 'Corrects the category of one or more transactions' and specifies the HTTP method (PATCH /transactions/:id). It distinguishes from sibling tools like openfinance_list_transactions by mentioning where to obtain transaction_id and category_id.

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

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

The description explains when to use this tool: 'use this to fix miscategorized transactions and improve categorization accuracy going forward.' It also provides context about batch behavior and per-item error handling, and implies alternatives by referencing list tools for IDs.

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

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

Annotations already provide idempotentHint=true and destructiveHint=false, covering safety. The description adds no further behavioral context (e.g., backend effects, authentication needs). It adds the reproduction hint but that's a usage guideline, not behavioral.

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 (one sentence, 15 words) and front-loaded with the purpose. It could be slightly more structured but is not verbose.

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

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

For a 3-parameter tool with no output schema and minimal annotations, the description lacks completeness. It omits explanations for 'message' and 'context', which are important for correct invocation.

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

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

Schema has 0% description coverage, so description must compensate. It explains the 'conversation' parameter ('Include the conversation array with recent messages') but does not describe the required 'message' or optional 'context' parameters.

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

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

The description clearly states the tool's purpose with specific verbs and resources: 'Report a bug, missing feature, or send feedback.' This distinguishes it from sibling tools, none of which handle issue reporting.

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 to include the conversation array for reproduction. It implies when to use (reporting issues) but does not explicitly exclude alternatives or state when not to use.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds that it shows specific version information. No additional behavioral traits are disclosed beyond what annotations provide, but the description is consistent and adequate.

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 clearly communicates the 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?

For a simple version-display tool with no parameters and no output schema, the description is fully adequate. It tells the user exactly what the tool does, and no further context 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?

The tool has zero parameters, so schema coverage is 100% by definition. The description does not need to add parameter details. A baseline of 4 is appropriate as there is no loss of information, though the description could mention that no input is required.

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 displays current MCP platform and adapter versions, with a specific verb 'show' and resource 'versions'. It effectively distinguishes itself from sibling tools that deal with authentication, openfinance, 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?

No explicit guidance on when to use or alternatives is provided. However, the tool's simplicity makes usage self-evident, but there is no mention of when it might be useful versus other info tools like 'toolkit_info'.

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

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

Annotations already provide readOnlyHint, idempotentHint, destructiveHint. Description adds valuable context about the returned content, which goes beyond the annotations. No contradictions.

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

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

Single sentence, directly states what the tool does, no wasted words. Information is front-loaded and clear.

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

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

Given no parameters and no output schema, the description fully explains what the tool returns. It is complete for a simple 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?

No parameters exist, so the description does not need to add parameter info. Baseline for 0 params is 4. Description compensates by describing the output.

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

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

Description clearly states the tool returns toolkit state including specific information (installed MCPs, connection status, catalog tools count). It distinguishes from siblings which deal with authentication, connections, and 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?

Description implies usage for getting an overview, but no explicit guidance on when to use versus alternatives or when not to use. It is adequate but lacks explicit context.

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