Nubank MCP

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

Disclosed behavioral traits beyond annotations: describes session vs permanent authentication, token format (JWT), and that calling with no args returns a link. No contradictions with annotations.

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

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

Description is clear and packed with information, but slightly verbose. Could be tightened while retaining all guidance. Still well-structured.

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

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

Given context (single optional param, no output schema, annotations), the description is complete. Covers input, usage scenarios, and best practices.

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 one undocumented optional 'token' parameter. Description adds critical semantics: token is a JWT, and explains the effect of providing it vs omitting it. Compensates fully for 0% schema coverage.

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

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

The description clearly states the tool authenticates users, providing a login link or accepting a token. It distinguishes from siblings by focusing on authentication, which no other tool does.

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

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

Explicitly explains when to use (to get a login link or paste a token) and provides best practice for permanent vs session login. Also mentions alternative setup via config.

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 and idempotentHint=true. The description adds value by explaining the two return scenarios (all connected vs missing credentials), which provides 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, front-loaded with the core purpose, with no wasted words.

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

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

The description explains return values in different states, sufficient for a no-parameter, read-only tool without an 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?

No parameters exist, and schema coverage is 100%. The description does not need to add parameter details, and it effectively omits them.

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

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

The description clearly states the tool returns connection status and URLs, distinguishing it from siblings like authenticate by focusing on status and URLs.

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

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

The description implies usage when connection status is needed, but does not explicitly specify when to use this tool versus alternatives like authenticate or other connection-related 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 provide no readOnly/destructive hints, but description adds critical behavioral details: invoke runs one-off, returns connect/checkout links on failure, install makes permanent. 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 structured logically (core flow, actions, edge cases). Every sentence adds value, though slightly verbose. Could be more concise without losing information.

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

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

Covers main workflows (search, describe, invoke, install) and edge cases (credentials, payments, permissions). Lacks return value format, but no output schema exists to rely on.

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

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

With 0% schema description coverage, the description compensates by explaining the action parameter and its sub-parameters (e.g., query for search, tool_id for invoke). However, not all 15 parameters are individually explained.

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 is the official mcp.ai marketplace for discovering MCPs, running tools, and managing installations. It distinguishes itself from sibling tools by specifying it should be used FIRST for any capability request.

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 instructs to use this tool first before external registries, outlines the core flow (search→describe→invoke), and explains when to use invoke vs install. Also mentions permissions for write operations.

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 destructiveHint=true. The description adds that it revokes consent and returns a reconnection URL, providing additional context beyond the annotation.

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-load the action, effect, and return value with no extraneous 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?

While it describes the effect and return, it fails to specify the 'item' parameter's meaning and could provide more context about how to obtain the item 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?

The single parameter 'item' has no description in schema (0% coverage) and the description does not explain what 'item' is, leaving the agent without necessary context.

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

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

The description clearly states it revokes consent and deletes connection data for a specific bank, distinguishing 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 implies it is used to disconnect a bank and provides a reconnection URL, but does not explicitly state when to use it over alternatives or provide exclusions.

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

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

The description goes well beyond annotations: it explains waiting up to ~60s, polling behavior, return fields (synced, needs_action, timed_out), and effect of wait:false. This provides rich behavioral context beyond readOnlyHint=false and destructiveHint=false.

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 well-structured: starts with core action and wait behavior, then use case, then parameter details, then return explanation. Every sentence adds value; no 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?

With no output schema, the description fully explains the return object { results, errors } and key fields. It covers edge cases (needs_action, timed_out) and gives actionable guidance. Complete for a sync tool with 2 parameters.

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

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

Despite 0% schema description coverage, the description fully explains both parameters: 'wait' (boolean, true=wait up to 60s, false=fire-and-forget) and 'items' (array of selectors with examples, omission syncs all). No ambiguity remains.

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

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

The description clearly states the tool forces a re-sync of connections and waits for completion. It specifies the HTTP method (PATCH), polling behavior, and use case. It distinguishes from sibling tools like openfinance_get_item_status (re-check) and mentions optional wait parameter for fire-and-forget.

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 (stale balance/transaction list), what it does (pulls fresh data without disconnecting), and includes exclusions (omit items for all banks). It also mentions alternative: 're-check with openfinance_get_item_status' for timed_out cases.

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

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

Beyond the readOnlyHint and idempotentHint annotations, the description adds significant behavioral context: structured warnings for CREDIT errors, degradation to last-synced balance with realtime:false, and the response shape. No contradiction with annotations.

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

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

Two succinct sentences cover purpose, endpoint, parameter constraints, and edge cases. Front-loaded with primary function; no wasted words.

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

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

For a read-only tool with one parameter and no output schema, the description is complete: explains response shape, degradation behavior, and error handling. Distinguishes from sibling tools via detailed behavior.

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

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

Schema coverage is 0%, but the description compensates by specifying that account_ids is an array of 1-50 items, adding meaning over the bare schema. Could be improved by specifying the expected format of each ID string.

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

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

The description clearly states the tool returns real-time balance per account id, specifies the endpoint, and distinguishes itself from siblings by detailing array parameter constraints and special case behaviors.

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 context on when to use the tool and what to expect (real-time balance, warnings for CREDIT accounts, degradation), but does not explicitly mention when not to use or name alternative tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds critical context about the provider_incident block and its implications on data reliability, which is beyond annotations. No contradictions.

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

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

The description is concise and front-loaded with the main purpose, then provides batch shape and reliability warning. Every sentence is valuable 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?

For a read operation with rich annotations, the description covers the input, output shape, and edge cases (provider_incident). It is complete enough for correct tool selection and 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?

The schema has one parameter account_ids with 0% description coverage. The description fully compensates by specifying it as an array of strings with bounds 1-50 and its purpose.

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, specifying the endpoint and batch shape. It distinguishes from sibling tools like openfinance_list_accounts which likely returns a list without details.

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

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

It explains that account_ids must be an array of 1-50 items and warns about provider_incident affecting data reliability. However, it does not explicitly state when to use vs alternatives or when not to use.

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

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

Annotations already indicate readOnlyHint and idempotentHint. The description adds important behavioral context: batch shape {results, errors}, Pluggy missing paid/status field, and the nuance that payments[] may refer to the previous bill's payment. 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 than average, but each sentence adds necessary value. It is well-structured: purpose first, then fields, exclusions, usage instructions, and behavioral notes. Slight redundancy could be trimmed, but overall efficient for the complexity.

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

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

For a tool with no output schema, the description adequately covers return fields, batch shape, limitations (no individual transactions, Pluggy behavior), and cross-bill payment interpretation. All relevant aspects for correct invocation and interpretation are 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 coverage is 0%, so the description must compensate. It explains that bill_ids is an array and instructs to use openfinance_list_credit_card_bills to discover IDs, adding meaning beyond the bare schema. A higher score would require more detail on array format constraints.

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

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

The description clearly states the tool returns 'bill-level detail for one or more credit card bills by id', specifying the resource and action. It explicitly distinguishes from siblings by stating what it does NOT return (individual transactions) and directing to openfinance_list_transactions for that purpose.

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: use openfinance_list_credit_card_bills to discover IDs, pass bill_ids as an array, and for itemized transactions use openfinance_list_transactions. It also warns against reconstructing bill totals and explains when to check 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?

The description discloses the returned fields (status, executionStatus, connector metadata) and the two invocation behaviors. Annotations already indicate readOnlyHint, idempotentHint, and non-destructive, which the description is consistent with. It adds value by describing the return shape differences, though it could mention that calling repeatedly is safe (implied by idempotent).

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, efficient sentence that packs the main purpose, possible status values, and the two usage modes. It is front-loaded and every part is necessary.

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 one optional parameter and no output schema, the description covers the essential information: what it returns and how to invoke it. The return format for a single item is described as 'its executionStatus, and connector metadata', which is sufficient but not fully explicit. It does not need to explain return values since there is no output schema, but a slightly more detailed structure for a single item would improve completeness.

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

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

With schema coverage at 0%, the description fully compensates by explaining the semantics of the only parameter `item`: omitting returns all banks, passing returns a single bank. This adds complete 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 verb 'Returns', specifies the resource 'status of a bank connection', and provides examples of statuses (UPDATED, UPDATING, LOGIN_ERROR). It also distinguishes between two modes of invocation, differentiating it from sibling tools like openfinance_list_connections or openfinance_provider_status.

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

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

The description explicitly instructs when to omit vs. pass the `item` parameter, explaining the different return structures. However, it does not provide guidance on when to use this tool versus other sibling tools (e.g., for listing connections without 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, destructiveHint=false, idempotentHint=true. Description adds behavior beyond annotations: it accepts up to 50 IDs, returns batch results with errors, and lists detailed fields. 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?

Description is relatively concise (3 sentences) and front-loaded with purpose and fields. Could be slightly more structured, but no unnecessary content.

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

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

Given no output schema, the description thoroughly explains return shape and lists key fields. Parameter constraints are clear. Complete for a detail retrieval tool with sibling 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?

Schema coverage is 0%, so description must compensate. It specifies loan_ids as an array of strings, limits to 1-50 items, and explains the output shape. Adds meaningful context beyond the bare schema.

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

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

The description clearly states that the tool returns full loan contract detail by ID, listing specific fields such as interestRates, contractedFinanceCharges, balloonPayments, etc. It distinguishes itself from sibling tool openfinance_list_loans by advising to use it after listing for deep-dive.

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: after openfinance_list_loans. Provides input constraints: pass loan_ids as array (1-50). Describes output shape: { results, errors } batch shape, guiding proper invocation.

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

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

Beyond the readOnlyHint annotation, the description warns that CREDIT card balance is connector-dependent and should not be treated as 'this month's bill'. It also explains the provider_incident block that indicates potentially unreliable data, adding critical behavioral context.

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

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

The description is detailed and well-structured, starting with the core purpose then adding important caveats. While every sentence adds value, the length could be trimmed slightly without losing clarity, but it remains efficient for the complexity.

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

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

Given the two parameters and no output schema, the description thoroughly explains the response structure (including nested fields like bankData and creditData), covers edge cases (provider incidents, different balance meanings), and provides usage patterns for both single and aggregated queries, making it fully complete.

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

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

With 0% schema description coverage, the description fully compensates by explaining the 'item' parameter's role (omit for all banks, pass for a single bank) and the 'type' parameter's effect (though not explicitly stated that omitting returns both, the context makes it clear). This adds significant meaning beyond the raw schema.

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

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

The description clearly states the tool returns accounts for bank connections with specific data fields (balance, number, type, etc.) and distinguishes between BANK and CREDIT types. It also clarifies the meaning of 'name' vs 'bank', and explains the behavior with and without the 'item' parameter, differentiating it from sibling tools like openfinance_list_credit_card_bills.

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

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

The description provides explicit guidance on when to omit or pass the 'item' parameter: omit to list accounts across all linked banks, pass to target a single bank. It also mentions when to use openfinance_list_credit_card_bills for standardized open-bill amounts, offering clear alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the tool is safe. The description adds behavioral details: cached per session, single aggregated response (no batch ids), and response structure (id, description, parentId, etc.). This adds value 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 concise: three sentences cover purpose, caching, response structure, and relationships. No redundant or excessive information. Front-loaded with the main action.

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

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

Given the tool's simplicity (no params, no output schema), the description provides sufficient context: what it returns, caching strategy, structure of entries, and relevance to update_transaction_category. Annotations cover safety. Complete for an AI 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?

Input schema has no parameters (100% schema description coverage), so the description does not need to explain them. It instead describes the response fields, which helps the agent understand usage. Baseline 4 is appropriate for zero-parameter tools.

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

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

The description clearly states it returns Pluggy's transaction category taxonomy (GET /categories), cached for the session. It specifies the verb (returns), resource (transaction category taxonomy), and provides context like caching and structure. It distinguishes from sibling tools like openfinance_list_transactions by focusing on categories alone.

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

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

The description explains that the response includes 'id' (used by openfinance_update_transaction_category) and mentions caching, implying efficient retrieval. It does not explicitly state when to use vs siblings, but the context clarifies its purpose for category taxonomy and integration with update tool.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds value by specifying the exact return fields, including the add_connection_url, which is not inferred from annotations.

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

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

Single sentence that is efficient and front-loaded with the main purpose. No unnecessary words.

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

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

Given no output schema, the description explains key returned fields (connector_id, item_id, bank name, add_connection_url). However, it does not mention potential pagination or limits, but for a simple list this is 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?

The input schema has zero parameters with 100% coverage, so the description is not required to add parameter details. Baseline score 4 applies.

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

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

The description clearly states the tool returns saved bank connections and lists specific fields (connector_id, item_id, bank name, add_connection_url). It distinguishes from siblings 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?

No explicit guidance on when to use this tool versus alternatives like openfinance_list_accounts or openfinance_list_transactions. The purpose is straightforward but lacks comparative 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, idempotentHint=true, and destructiveHint=false. The description adds extensive behavioral context beyond these: complex payment semantics, derived payment_status logic, connector asymmetry, open bill derivation with confidence levels, bill grouping reliability warnings, and behavior when CREDIT_CARDS product is not enabled (returns warning instead of failing). This fully informs the agent of important behavioral traits.

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

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

The description is verbose but well-structured. It front-loads the main return fields, then dives into important semantics, opt-in details, and warnings. Some repetition occurs (e.g., payment_status explanation given twice), and the length could be trimmed without losing information. Still, every sentence adds value and the structure aids comprehension.

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 (5 parameters, no output schema, nuanced behavioral semantics), the description is remarkably complete. It covers return fields, derived status logic, open bill opt-in with confidence levels, connector limitations, bulk execution, error handling, and distinctions from related tools. No apparent gaps remain for effective agent 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 coverage is 0%, meaning no parameter descriptions in the schema itself. The tool description compensates by explaining the key parameters: include_open_bill (detailed behavior), account_ids (bulk support), and implicitly account_id. However, page and page_size are not described beyond being pagination parameters, which are standard but still receive no explicit explanation. Overall, adds significant meaning for the non-obvious parameters.

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

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

Clearly states it returns CLOSED credit card bills for a CREDIT-type account. Specifies the resource (bills), the action (list), and the type (closed). Distinguishes from sibling tools like openfinance_get_credit_card_bill and openfinance_list_transactions by explicitly stating it provides bill-level summaries, not 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?

Provides explicit guidance on when to use this tool vs alternatives, e.g., 'To see itemized purchases/charges, use openfinance_list_transactions'. Also warns against reconstructing bill totals from transactions, and explains when to use the include_open_bill option. Implicitly contrasts with openfinance_get_credit_card_bill for single bill retrieval.

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

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

Annotations already indicate readOnly and idempotent. Description adds that it returns a warning object on 403 errors, disclosing upstream error handling behavior. No contradictions with annotations.

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

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

Description is concise and front-loaded with the core purpose and asset types. It packs useful details about returned fields without excessive verbosity. Could be slightly restructured for readability.

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

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

Given the complexity of investment portfolios and no output schema, the description details return fields well but omits parameter guidance. Pagination via page/page_size is implied but not explained. Incomplete for full agent decision-making.

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

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

Input schema has 4 parameters with 0% description coverage. Description does not explain 'item', 'page', 'type', or 'page_size' at all. Schema coverage is low, and description fails to compensate, leaving parameter semantics undefined.

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 investment portfolio for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.). This distinguishes it 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?

Description specifies the tool is for connections with INVESTMENTS enabled and explains the error handling (returns a warning instead of throwing). It implies when to use but does not explicitly mention alternatives or 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, destructiveHint=false, and idempotentHint=true. The description adds value by detailing the returned fields (quantity, value, netAmount, expenses breakdown) and the types of movements, which enriches the agent's understanding 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 concise with two focused paragraphs. The first explains the output, the second covers bulk support. Every sentence adds value with no redundancy, and the key usage hint is 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 4 parameters and no output schema, the description is adequate but incomplete. It explains return fields and usage sequence, but omits pagination behavior (page, page_size), default values, or parameter format constraints.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the role of investment_id and investment_ids (bulk), but does not describe page and page_size parameters, leaving gaps. Thus it adds some meaning but not complete coverage.

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

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

The description clearly states the tool returns movement history for a specific investment position, listing transaction types like BUY/SELL/TAX/INTEREST/AMORTIZATION/TRANSFER. It distinguishes itself from the sibling tool openfinance_list_investments by instructing to use that tool first to obtain the investment_id.

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

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

The description provides clear usage context: 'Use after openfinance_list_investments to get the investment_id' and mentions bulk support. However, it does not explicitly state when not to use this tool or compare to other siblings beyond the one referenced.

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 that queries are sequential with rate-limit spacing and returns a structured result per connection. It does not disclose potential pitfalls like authentication requirements.

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 consists of three concise sentences that deliver all necessary information without redundancy. Every sentence adds value.

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

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

Given the simple input schema (one optional parameter, no enums, no output schema), the description covers the tool's behavior, parameter usage, and return format completely.

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 the 'items' parameter: it accepts connection selectors (item_id, connector_id, or connector_name) and its omission lists all banks. This 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 lists loan contracts per bank connection, specifies the endpoint (GET /loans), and distinguishes from sibling tools by focusing on loans.

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 the 'items' parameter (for specific connections) and when to omit it (for all banks). It also mentions rate-limit spacing for multiple connections. However, it does not explicitly state when not to use this tool 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 indicate readOnlyHint=true and idempotentHint=true. Description adds extensive behavioral context: auto-pagination up to 5000 transactions, truncation warnings, upstream error handling (returns error structure instead of throwing), detail levels with token costs, and provider incident blocks. 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?

Well-structured with clear sections (pagination, detail levels, credit card specifics, bulk support). However, some details are repeated (e.g., billId caution appears twice), and the description is quite long. Still, every sentence provides value, and the structure aids comprehension.

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

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

Given the tool's complexity (8 parameters, no output schema, many edge cases), the description is remarkably complete. It covers query logic, pagination limits, error handling, detail options, credit card behavior, cross-references to sibling tools, and provider incidents. The response structure is also described (account echo, warning/error).

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

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

Schema coverage is 0%, but the description explains every parameter: from/to (ISO dates), search_queries (case-insensitive substring OR), detail (compact/rich/raw with specific field descriptions), page and page_size (default vs manual pagination), account_id/account_ids. It also clarifies behavior of search_queries and detail options.

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

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

The description clearly states it returns transactions for bank accounts, distinguishing between BANK and CREDIT types. It explicitly differentiates from sibling tools like openfinance_list_credit_card_bills, which is used for standardized bill totals, and openfinance_list_accounts for card statement dates.

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: for CREDIT accounts, it is the only way to get itemized transactions; when to use openfinance_list_credit_card_bills for totals; when to check openfinance_get_item_status if empty; and when to use openfinance_list_accounts for dates. Also includes bulk support and cautions about provider incidents.

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 behavioral traits beyond annotations: it resolves accounts internally, caps at 5000 transactions per account with a truncated flag, and includes a provider_incident block when data may be incomplete. Annotations already indicate read-only and idempotent, which the description aligns with.

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

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

The description is about 150 words, breaking down the tool's purpose, parameters, and behavior. Every sentence adds value, but it could be slightly more structured (e.g., bullet points) and trimmed without losing information.

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

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

Despite no output schema, the description explains what the tool returns: compact summary with totals, monthly evolution, top expenses, per-account breakdown for monthly granularity; raw transactions for raw granularity. It also covers truncation and provider incidents. Missing explicit error handling details but 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?

With 0% schema description coverage, the description explains most parameters: item (connector_id/name/item_id), from/to (ISO dates), granularity (monthly/raw), detail (compact/rich/raw), type (BANK/CREDIT). However, it does not explicitly state that top_n controls the number of top expenses/receipts, though it is implied.

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 provides consolidated cash-flow analysis for a bank connection in one call, resolving accounts internally. It distinguishes from siblings like openfinance_list_transactions by emphasizing aggregated analysis and avoiding multiple calls.

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 (e.g., for annual/monthly analysis, cash flow) and how to customize via granularity and detail. It tells users they do not need to call openfinance_list_accounts first. However, it does not explicitly state when to prefer sibling tools 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, destructiveHint. Description adds detailed behavioral context (checks provider's health, returns incidents, flags affected banks), which is valuable 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?

Description is well-structured with front-loaded purpose. Each sentence adds value, though slightly lengthy; still concise for the detail provided.

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

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

Despite no output schema, description explains return contents (global indicator, degraded components, incidents, affected banks). 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, so schema coverage is 100%. Description doesn't need to add param info, but it provides ample context about what the tool does without parameters.

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

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

Clearly states it checks the LIVE operational status of the Open Finance provider, distinguishing from sibling tool openfinance_get_item_status which checks connection status. Includes specific use cases.

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 (data incomplete/stale despite updated connection) and contrasts with alternative tool. Provides actionable 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 read-only, idempotent, non-destructive. The description adds that keywords[] is required, returns a hint if empty, and never dumps the full catalog. Also mentions plan-based filtering and caveat warning, providing useful 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 a single paragraph that is front-loaded with the main action and returns. It is somewhat long but each sentence adds value. Could be tightened slightly.

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, but the description lists the return fields (connector id, access, audience, links, connect_url). Also covers edge cases like non-Open-Finance caveats and plan filtering. Complete for a search 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%, so the description must compensate. It explains keywords[] with examples and states it's required, and explains include_accounts triggers account retrieval. This adds significant meaning beyond the raw schema.

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

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

The description uses a specific verb ('Searches') and resource ('available bank connectors') and clearly distinguishes it from sibling tools like 'connect' or 'authenticate' by stating it's the step before connecting. It lists what it returns and its role.

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 'Call this BEFORE connecting' and explains when to surface caveats. It doesn't explicitly state when not to use, but the context implies it's the default first step.

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 beyond annotations: overrides automatic categorization, teaches Pluggy by creating a Category Rule, batch behavior with per-item errors (does not fail whole batch), and response shape. No contradiction with annotations (readOnlyHint=false is consistent with write operation).

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 paragraph, dense but clear, front-loaded with purpose. Could be slightly more structured (e.g., separate side effects), but every sentence adds value 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?

Complete for a batch update tool with one parameter and no output schema: explains input structure, source of IDs, side effects, response shape, and error handling. No gaps for an AI agent to use correctly.

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

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

Schema has 0% description coverage; description fully compensates by specifying items as array of { transaction_id, category_id }, explaining where to get each ID (from other tools), and detailing batch response format including errors.

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?

Explicitly states it corrects the category of one or more transactions (PATCH /transactions/:id). Distinguishes from sibling tools by explaining its unique function and side effect of creating a Category Rule, and references where input IDs come from (openfinance_list_transactions, openfinance_list_categories).

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?

Clear context: use to fix miscategorized transactions and improve categorization accuracy. Describes side effect (future similar transactions categorized same way). No explicit when-not or alternatives, but implied by the tool's purpose and error handling description.

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

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

Annotations provide idempotentHint and destructiveHint, but the description adds no extra behavioral context beyond the core action. It doesn't discuss side effects or outcomes.

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

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

Two efficient sentences, no redundancy. The purpose is stated first, followed by a practical usage tip.

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 bug report tool, the description covers purpose and key usage hint. Lacks details on return values, but no output schema exists. Could elaborate on other parameters.

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

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

The description adds meaning to the 'conversation' parameter by mentioning it for reproduction, but does not explain 'context' or 'message' beyond their schema types. With 0% schema coverage, partial compensation is provided.

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 reports bugs, missing features, or feedback. It uses a specific verb and resource and distinguishes from sibling tools that focus on Open Finance operations or system info.

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 include the conversation array for reproduction, providing clear context for use. No direct comparison to alternatives, but siblings are unrelated.

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, covering safety and idempotency. The description adds that it returns version details for platform and adapter, providing concrete behavioral insight beyond annotations.

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

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

The description is a single sentence that is concise and front-loaded with the key action. Every word is necessary; no wasted text.

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

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

Given no parameters and no output schema, the description adequately covers what the tool does. It could optionally specify the output format (e.g., 'returns an object'), but the current description is sufficient for a simple version tool.

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

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

There are zero parameters, so the baseline is 4. The description does not need to explain parameters, and the schema already covers all cases. No additional parameter information 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 shows 'current MCP platform and adapter versions', using a specific verb and resource. It distinguishes from siblings, which are primarily finance-related or authentication, and no other tool covers version info.

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 does not provide explicit guidance on when to use or alternatives. However, the tool is simple and standalone; usage is self-evident. A higher score would require stating contexts like 'use to check system compatibility'.

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 destructiveHint. The description adds value by specifying the exact return content (installed MCPs, connection status, catalog tool counts), 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?

The description is a single, well-structured sentence that front-loads the purpose and packs essential detail without 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?

For a simple read-only tool with no parameters, the description fully explains the return value. Annotations cover behavioral traits. No output schema is needed. Everything is complete.

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

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

The tool has zero parameters and schema coverage is 100%. With no parameters to describe, the baseline is 4, and the description adds no unnecessary 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 verb 'Returns', the resource 'current toolkit state', and specifies the exact data included: installed MCPs, connection status, and catalog tool counts. This distinguishes it from any sibling 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?

The description implies the tool is for inspecting the toolkit state but does not explicitly state when to use it versus alternatives or mention any prerequisites. However, the sibling context shows no overlapping tools, so usage is reasonably clear.

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