Woop MCP

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

Beyond annotations (idempotentHint, destructiveHint), description explains the dual behavior: returning a link when called without token, and logging in when called with token. This adds context not present in annotations, though it omits error handling or side effects like session duration.

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

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

Four sentences that efficiently convey context, best practice, and two usage patterns. No redundancy or unnecessary detail.

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

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

Given no output schema, the description covers main behaviors (link generation, token login). It lacks details on return format, error cases (e.g., invalid token), and session behavior, but is largely sufficient for a simple authentication 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?

Parameter 'token' has 0% schema coverage, but description fully explains its purpose: providing a JWT to complete login. It also clarifies the alternative of calling with no args to get the link, which is essential for understanding the tool's usage.

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

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

Description clearly states the tool is for authentication, detailing two modes: getting a login link (no args) and completing login with a token. It distinguishes itself by focusing on authentication flow, but does not explicitly differentiate from sibling 'connect' 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 clear guidance on the two usage modes (permanent config vs. session token) and when to call with/without arguments. However, it does not compare to sibling tools like 'connect' or exclude scenarios where this tool is inappropriate.

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. Description adds valuable behavioral context about return values under different conditions (connected vs missing credentials), which goes beyond the annotations. 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?

Two concise sentences that deliver the purpose and key behavioral details upfront. 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 simple status check tool with no parameters and no output schema, the description sufficiently explains the two main return states. However, it does not mention intermediate states (e.g., partial connectivity), which might exist. Almost 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?

No parameters in input schema (100% coverage). Description appropriately adds no parameter info, as none are needed. Baseline 4 is suitable.

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

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

Clearly states it returns connection status and URLs, with specific scenarios for when all providers are connected vs missing credentials. Distinguishes from sibling tools like authenticate.

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 connection status and identifying next steps (e.g., obtaining URLs), but does not explicitly state when to use this tool vs alternatives like authenticate. Could be improved by adding guidance on prerequisites or when other tools are 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?

Annotations provide basic hints, but description adds significant behavioral context: invoke works even when MCP is not installed, returns connect/checkout links for missing credentials or payment, and the one-off install behind invoke. 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?

Front-loaded with purpose and high-level flow, but the description is lengthy. Every sentence adds value, but some redundancy exists (e.g., multiple mentions of invoke vs. install). Could be tightened 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?

Provides a solid overview of the tool's role and main workflow, but lacks detailed parameter explanations and does not describe return values (no output schema). For a complex tool with 13 parameters, the description is incomplete for fully understanding all inputs.

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

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

Despite 0% schema coverage, the description explains the main 'action' parameter and its variants (search, describe, invoke, install, etc.) and touches on mcp_id, tool_id, arguments through flow narrative. However, many parameters (limit, query, message, immediate, tier_slug, etc.) remain unexplained, leaving 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?

Clearly states it is the official marketplace for discovering and running MCPs/tools. Uses specific verbs like 'search', 'describe', 'invoke', and distinguishes itself from sibling tools by being the entry point for capability discovery.

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 use this tool FIRST before external registries. Describes core flow and when to use invoke vs. install, and notes that writes require workspace owner/admin. Provides clear context for when-not-to-use alternatives.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds context that data is permanently unavailable and a re-connection URL is returned, which is beyond what annotations provide. 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?

Two sentences, clear and concise, front-loaded with the action. 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?

Covers the core behavior and outcome, but lacks parameter explanation and does not mention potential side effects beyond deletion. Given the tool's simplicity and lack of output schema, the description is adequate but not 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?

Schema description coverage is 0%. The description does not explain the required 'item' parameter (what it represents, format, or example). This is a critical gap for correct invocation, especially for a destructive operation.

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 revokes consent and deletes connection data, making data unavailable. It also mentions returning a re-connection URL. This distinguishes it from sibling tools like openfinance_force_sync or 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 when to use (when disconnecting a bank), but does not explicitly state when not to use or provide alternatives. The context is clear, but lacks explicit guidance on exclusions or comparisons to 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?

Describes behavioral traits beyond annotations: that it modifies connections (readOnlyHint=false is consistent), the wait mechanism (polls up to ~60s), potential outcomes (needs_action, timed_out), and return structure. Adds value since annotations only show false hints.

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

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

The description is front-loaded with purpose and key behavior, but is somewhat long (4 sentences). However, every sentence is informative and necessary given no output schema, so minor deduction for verbosity.

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

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

Given no output schema and 0% schema coverage, the description is fully complete: covers purpose, when to use, parameter semantics, return values (results/errors, fields explained), edge cases (needs_action, timed_out), and alternatives (openfinance_get_item_status). No gaps remain.

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

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

Despite 0% schema coverage, the description fully explains both parameters: 'wait' boolean with effect (true=wait, false=fire-and-forget) and 'items' as array of selectors (item_id, connector_id, or connector_name) with behavior when omitted (sync all). This adds meaning far 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 states specifically that the tool forces a bank to re-sync connections and waits for completion. It uses strong verbs like 'forces', 're-sync', and 'waits', distinguishing it from related tools like openfinance_get_item_status which is for checking 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?

Explicitly states when to use: when balance or transaction list looks stale and a connection 'can read UPDATED yet be hours old'. Also provides when-not-to: if timed_out, use openfinance_get_item_status; if needs_action, user must reconnect. Additionally explains options like omitting items to sync all or setting wait:false.

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. Description adds context about real-time nature, error behavior for CREDIT accounts, and the response shape including errors array. This supplements the annotations well.

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 that front-load purpose and key usage details. No extraneous 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 simple balance retrieval tool with one parameter and no output schema, the description covers purpose, parameter constraints, error handling, and response shape comprehensively.

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

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

The input schema has no description coverage (0%), so the description compensates by explaining that 'account_ids' must be an array and limits to 1-50 items. It adds useful constraints beyond the schema type.

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 the real-time balance for an account ID, with a specific HTTP endpoint. It distinguishes itself from sibling tools like 'openfinance_list_accounts' or 'openfinance_get_accounts_detail' by focusing solely on balance.

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

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

Specifies the parameter format (array of 1-50 account IDs) and explains how CREDIT account errors are handled via structured warnings. However, it does not explicitly state when to use this tool versus alternatives or provide exclusion criteria.

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 context beyond annotations by describing the batch shape ({ results, errors }) and the endpoint, which is consistent with readOnlyHint and 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?

Two sentences that front-load the purpose and immediately provide the critical parameter constraint, 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?

Covers the key behavioral aspects: input constraint and output shape, though the meaning of 'extended creditData' could be expanded. No output schema is present, but the description compensates with the 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?

Despite 0% schema coverage, the description adds the array size constraint (1-50), which is meaningful usage guidance beyond the raw schema.

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

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

Clearly states it returns full account objects with extended creditData per ID, distinguishing from sibling openfinance_list_accounts which likely provides a list without detail.

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

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

Explicitly instructs to pass account_ids as an array of 1-50 items, but does not state when to use this over list alternatives or when not to use it.

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

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

Beyond the annotations (readOnlyHint, idempotentHint), the description adds important behavioral context: it warns that Pluggy does not return a paid/status field, explains that payments[] reflects payments during the current billing cycle (typically of the previous bill), and advises against assuming payment status from payments[]. This prevents misinterpretation.

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

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

The description is well-structured and efficiently uses sentences. It starts with the core purpose, then provides usage alternatives, then domain-specific notes. Every sentence adds value, and there is no redundancy or unnecessary detail.

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

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

Despite lacking an output schema, the description fully explains the tool's behavior, parameters, return shape, and domain-specific nuances. It ties into sibling tools for a complete workflow (list bills first, use transactions for details). The context about Brazilian Open Finance and payment interpretation ensures correct usage.

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, but the description compensates by explaining that bill_ids should be passed as an array and that they can be discovered using openfinance_list_credit_card_bills. It also describes the return shape ({ results, errors }). This provides useful 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 the tool returns bill-level detail for credit card bills by ID, listing specific fields (financeCharges, payments). It explicitly distinguishes what it does NOT return (individual transactions) and contrasts with sibling tools like openfinance_list_transactions.

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

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

The description provides explicit guidance: when to use this tool (to get bill-level detail), when not to use it (for itemized transactions), and which alternative tools to use (openfinance_list_transactions for transactions, openfinance_list_credit_card_bills to discover IDs and check payment status). It also instructs to pass bill_ids as an array and to list bills first.

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

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

Annotations already declare the tool as read-only and idempotent. The description adds behavioral context by detailing the returned data (status, executionStatus, connector metadata) and the response structure for both single and bulk queries, which is beyond what annotations provide.

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

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

Two sentences cover the tool's purpose and parameter usage without any redundancy. Information is front-loaded: the first sentence states the core function, and the second provides parameter guidance. 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?

For a simple read tool with one optional parameter and no output schema, the description is sufficiently complete. It explains the two operational modes and the return structure. It could optionally define 'executionStatus' or list all status enum values, but the examples given (UPDATED, UPDATING, LOGIN_ERROR) provide adequate 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?

The input schema has 0% description coverage, so the description fully compensates. It explains the effect of omitting vs passing the 'item' parameter, including the return format for each case. No additional formatting or constraints are mentioned, but the semantic meaning is clear.

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

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

The description clearly states the tool returns the current status of a bank connection with specific fields (status, executionStatus, connector metadata) and enumerates possible status values. It distinguishes from sibling tools by focusing on status retrieval for one or all connections.

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

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

The description explicitly explains when to omit or pass the 'item' parameter to get all banks vs a single bank. It does not mention when not to use this tool or suggest alternatives, but the two usage modes are clearly defined.

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 important behavioral nuance about connector-dependent credit balance meaning and billing cycle dates (balanceCloseDate, balanceDueDate), which is beyond what annotations provide.

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

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

Well-structured with front-loaded core purpose, then details. Some sentences are dense but each adds necessary information. Could be slightly 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?

Given no output schema and low schema coverage, the description covers key aspects: returned fields, parameter usage, behavioral caveats, and alternative tools. Lacks explicit response structure details but is sufficient for correct tool 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?

With 0% schema description coverage, the description explains item parameter usage (omit vs pass) and implicitly describes type filtering through account types. It also clarifies creditData fields, adding value 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 it returns accounts for bank connections with specific fields (balance, number, type, etc.). It distinguishes between listing all banks (omit item) and a single bank (pass item), and differentiates 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?

Explicitly tells when to omit or pass item parameter, and warns against using CREDIT balance as 'this month's bill', directing to openfinance_list_credit_card_bills for standardized billing data.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds value by detailing caching (adapter session), the response structure (id, description, parentId, etc.), and language options (English vs Portuguese). 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 with two sentences, each conveying essential information: what the tool does, how it works (cached), and what the output contains. No unnecessary words.

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

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

Given the tool's simplicity (0 parameters, rich annotations, no output schema), the description is complete. It covers the purpose, behavior, output fields, and relationship to another tool, leaving no gaps for an agent to understand its 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?

The tool has zero parameters, so the baseline is 4. The description does not need to add parameter details but compensates by explaining the output structure and its use, which is sufficient.

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

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

The description explicitly states it returns Pluggy's transaction category taxonomy, specifying the API endpoint (GET /categories) and the caching behavior. It clearly distinguishes from sibling tools by focusing on categories, while other tools deal with transactions, accounts, etc.

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

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

The description implies usage context by mentioning that category IDs are used by openfinance_update_transaction_category, guiding the agent on when to use this tool. However, it does not explicitly state when to avoid using it or provide alternatives, leaving room for slight ambiguity.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to repeat that. It adds context about the returned fields, but does not disclose any other behavioral traits such as rate limits, authentication requirements, or pagination behavior. The description adds some value but is limited.

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 and immediately states the purpose and key output fields. Every word is meaningful; there is no wasted text. It is well-structured and front-loaded.

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

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

The description is adequate for a simple tool with no parameters and no output schema. It lists the key returned fields. However, it does not mention whether the result is a list, pagination, or error handling, which would be useful for complete understanding. Minor gap.

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

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

The input schema has zero parameters, so schema description coverage is 100% trivially. The description adds meaning by detailing the output fields (connector_id, item_id, bank name, add_connection_url), which helps the agent understand what the tool returns. Baseline 4 is appropriate.

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

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

The description clearly states the verb 'Returns' and the resource 'saved bank connections', listing specific fields (connector_id, item_id, bank name, add_connection_url). It distinguishes itself from sibling tools like openfinance_list_accounts by focusing on connections rather than accounts or transactions.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. The purpose implies it should be used to list bank connections, but there is no mention of alternatives or contexts where another tool might be more appropriate. Usage is only implied.

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 extensive behavioral context beyond annotations: explains payment attribution to cycles, derived payment_status logic, connector asymmetry for open bills, and warning instead of failure. Annotations already indicate read-only and idempotent, and description reinforces safe read behavior 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?

Description is verbose and includes many technical details. While every sentence adds value, it could be more concise. Structure with sections helps, but length may overwhelm an agent. A front-loaded summary would improve conciseness.

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 Open Finance credit card semantics, the description is remarkably complete. It explains payment attribution, derived status, open bill handling, connector limitations, and cross-tool relationships. Without an output schema, it fully describes return structure and edge 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?

Schema coverage is 0%, so description compensates by explaining include_open_bill and account_ids in detail. However, page and page_size are not explicitly described (though implied as standard pagination). Still, description adds meaning to the key 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?

The description clearly states it returns CLOSED credit card bills for CREDIT-type accounts, listing specific fields. It distinguishes from sibling tools like openfinance_list_transactions and openfinance_get_credit_card_bill by specifying the scope and derived payment 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?

Provides explicit guidance on when to use this tool vs. others (transactions vs. bills), when to opt-in for open bill, and warns against misinterpreting payments array. Also describes connector asymmetry and warning behavior for unavailable product, giving clear context for tool selection.

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

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

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds behavioral context: returns a safe error structure ({ total:0, results:[], warning }) instead of throwing for disabled features or upstream errors, which is valuable for agent decision-making.

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 one paragraph of moderate length, front-loading the core purpose and output details. While comprehensive, it could be slightly more concise, but no wasted words.

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

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

Given 4 optional parameters (no schema descriptions) and no output schema, the description is incomplete: it lacks parameter explanations (e.g., pagination via page/page_size, filtering via type) and does not specify default behavior or pagination limits.

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

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

Schema description coverage is 0% and the description provides no information about the four parameters (item, page, type, page_size). The description focuses entirely on output, failing to add meaning to input parameters.

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

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

The description clearly states it returns investment portfolios for a connection, listing specific asset types and output fields, distinguishing 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?

The description implies usage for investment portfolio retrieval but does not explicitly provide when-to-use or when-not-to-use guidance, nor alternatives like openfinance_list_investment_transactions for 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=true and destructiveHint=false, so the description is not required to reiterate safety. It adds value by detailing output fields and expenses, but does not disclose additional behavioral traits like pagination behavior, error responses, or permissions. Thus it provides moderate added transparency.

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 (3 sentences) and front-loaded with the main action and output details. No redundant information; every sentence serves a purpose: output details, usage instruction, and bulk support.

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

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

Given no output schema, the description compensates with detailed output fields. It provides prerequisite usage and bulk support. It lacks pagination details and error handling, but for a read-only list tool with annotations, it provides sufficient operational context for an agent.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the meaning of investment_id (from prerequisite) and introduces investment_ids for bulk. However, page and page_size remain undocumented both in schema and description, so only half the parameters have semantic context 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?

The description clearly states it returns movement history for a specific investment position, listing types (BUY/SELL/TAX/INTEREST/AMORTIZATION/TRANSFER) and fields (quantity, value, amount, etc.). It distinguishes from siblings like openfinance_list_investments by noting prerequisite use, making the tool's purpose explicit 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?

The description provides explicit usage context: 'Use after openfinance_list_investments to get the investment_id' and mentions bulk support with investment_ids. It does not explicitly state when not to use or compare to alternatives, but the purpose is distinct enough among sibling tools to imply appropriate 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?

Annotations confirm read-only and idempotent. Description adds behavioral details: sequential processing, rate-limit spacing, and return format { results, errors } per connection. No contradiction.

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

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

Three concise sentences, each necessary: purpose, parameter usage, and omission behavior. 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 the simple input and no output schema, the description covers purpose, parameter semantics, behavioral quirks, and return structure. Fully sufficient for an agent.

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

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

With 0% schema description coverage, the description fully explains the 'items' parameter as an array of connection selectors (item_id uuid, connector_id, or connector_name), adding crucial 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 'Lists loan contracts per bank connection (GET /loans)' with a specific verb and resource. It distinguishes from sibling tools like openfinance_list_accounts 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?

Provides explicit guidance on when to pass items (for specific connections) and when to omit (list all). Mentions sequential querying with rate-limit spacing, but lacks explicit when-not-to-use or 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. The description adds significant context: explains CREDIT PENDING vs POSTED behavior varies by bank, error handling returns warning/error instead of throwing, and bulk support via account_ids. No contradictions with annotations.

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

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

The description is long but well-structured. It starts with the main purpose, then details credit card specifics, filtering/pagination/search, error handling, and bulk support. It is front-loaded with the core functionality. While longer than strictly necessary, the detail is justified given 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 complexity (7 parameters, no output schema, annotations present), the description is highly complete. It covers account types, credit card nuances, filtering, pagination, search, error handling, bulk support, and ties to connection health via sibling tool. All necessary behavioral and usage details are present.

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

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

Schema description coverage is 0%, but the description compensates by explaining the purpose of key parameters: from/to date filters (ISO YYYY-MM-DD), pagination (max 500/page), search_queries (case-insensitive substring match, OR semantics, aggregates up to 5000). It also mentions bulk support via account_ids. While not every parameter is individually described, the explanation is sufficient for usage.

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

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

The description clearly states it returns transactions for bank accounts (BANK or CREDIT types). It distinguishes itself from sibling tools like openfinance_list_credit_card_bills by specifying that for CREDIT accounts this is the only way to get itemized transactions, and it mentions the link to bills via creditCardMetadata.billId. This is specific and differentiates the tool's 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?

Explicit guidance is provided: for CREDIT accounts, this is the only way for itemized transactions; to get standardized open-bill totals, use openfinance_list_credit_card_bills. It also advises on troubleshooting when total is 0 (check connection health) and on narrowing date ranges when truncated:true is returned. This clearly tells when and when not to use the 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?

Beyond annotations (readOnlyHint, destructiveHint, etc.), the description reveals important behavioral traits: it internally resolves accounts, fans out transactions, caps at 5000 transactions per account (with truncated flag), and returns either a compact summary or raw rows. 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 dense but well-structured, starting with the main purpose and then detailing parameters and usage. However, it could be slightly more concise; some information (e.g., repetition about not needing to call list_accounts) takes extra space. 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?

For a tool with 6 parameters, no output schema, and complex behavior (compact vs. raw output, per-account breakdown, truncation), the description covers all necessary details. It explains the output structure, filtering, and limitations, making it complete for an AI agent to select and 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?

Despite 0% schema coverage, the description thoroughly explains all six parameters: `item` accepts multiple formats and can be omitted, `from`/`to` are ISO dates, `granularity` defaults to 'monthly' with a detailed description of its output, `type` filters by account type, and `top_n` is implied by 'top_despesas/recebimentos'. The description adds significant meaning beyond the bare schema.

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

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

The description clearly identifies the tool as 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call.' It distinguishes itself from sibling tools like openfinance_list_transactions by stating it resolves accounts internally and avoids calling list_accounts first. The description also provides specific use cases such as 'fluxo de caixa' and 'maiores gastos/recebimentos', leaving no ambiguity about 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 explicitly states when to use this tool for consolidated analysis and when not to, e.g., 'you do NOT need to call openfinance_list_accounts first.' It explains how to target one bank by passing `item` or omit it for all banks. It also advises on granularity: use 'raw' only when itemized rows are needed, otherwise default 'monthly' is sufficient. This provides clear guidance.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds detailed behavioral context: it returns global indicator, degraded components, open incidents, and flags incidents affecting connected 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 relatively long but each sentence serves a purpose: states the action, provides usage context, and lists return values. It is front-loaded with the main purpose. Minor redundancies but overall 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 no output schema, the description fully explains what the tool returns: global indicator, degraded components, open incidents, and `your_banks_affected`. For a simple status-check tool with no parameters, this is complete and informative.

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%. According to guidelines, baseline is 4 for 0 params. Description does not need to add parameter info, and it doesn't. All parameter semantics are implicitly clear.

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

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

The description clearly states it checks the LIVE operational status of the Open Finance provider, specifically distinguishing it from the sibling tool `openfinance_get_item_status`. It uses specific verbs and identifies the resource (provider status page), 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?

Explicitly tells when to use: 'whenever data looks incomplete or stale even though a connection shows UPDATED'. It also explains what the tool reveals (upstream outage, known incident) and differentiates from the sibling tool that checks connection-specific status.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds meaningful context: it honors the user's plan (PF vs PJ), never dumps the entire catalog without keywords, and produces a ready connect_url. This goes beyond annotations by explaining side effects and plan-based filtering.

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

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

The description is dense but every sentence adds unique value: purpose, return details, plan behavior, usage advice, parameter requirement, and a caution about empty input. It is front-loaded and well-structured, with 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?

Given the lack of output schema, the description adequately covers what the tool returns and the key parameters. It ties into the sibling 'connect' tool by mentioning the ready connect_url. However, it does not describe error cases or pagination/limits, which would enhance completeness 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?

With 0% schema description coverage, the description compensates by explaining 'keywords' with an example and stating it is required. 'include_accounts' is explained as affecting the inclusion of accounts in results. The meaning is clear, though no constraints or types beyond schema are given.

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 verb 'searches', the resource 'bank connectors by name', and details what is returned (connector id, access, audience, linked connections, accounts, connect_url). It distinguishes itself from siblings by stating 'Call this BEFORE connecting', implying a prerequisite 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?

The description explicitly advises when to use the tool ('Call this BEFORE connecting') and what input is required (keywords[], without which it returns a hint). It does not explicitly state when not to use it or mention alternative tools, but the guidance is clear for the typical use case.

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 (which indicate non-readonly, non-destructive, non-idempotent), the description discloses that the tool overrides automatic categorization, teaches Pluggy by creating a Category Rule (case-insensitive exact match), and that per-item errors do not fail the whole batch. 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 information-dense but well-structured, starting with the core action and then detailing side effects and response format. Every sentence adds value, though it could be slightly more concise by merging some repetitive phrases.

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 batch updating with side effects and no output schema, the description is complete: it covers payload construction, behavioral implications, response structure, and error handling. The agent has all necessary context to use the tool correctly.

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

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

With 0% schema description coverage, the description fully explains the 'items' parameter: it must be an array of objects with transaction_id and category_id, with clear origins for each ID. The response shape is also described, compensating for the missing output 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's purpose: 'Corrects the category of one or more transactions (PATCH /transactions/:id).' It uses a specific verb ('corrects') and resource ('transactions'), and distinguishes itself from siblings like openfinance_list_transactions and openfinance_list_categories by referencing them for ID 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?

Provides explicit guidance on when to use the tool ('fix miscategorized transactions'), how to construct the payload (items array with transaction_id from openfinance_list_transactions and category_id from openfinance_list_categories), and explains the side effect of creating a Category Rule. Also describes batch error handling, making usage 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 idempotentHint=true and destructiveHint=false. The description 'Include the conversation array with recent messages for reproduction' adds minor behavioral context (suggesting the tool may use the conversation for debugging), but does not significantly expand on the annotation-provided safety profile.

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 states the purpose and a key requirement. It is efficient and front-loaded, but could be improved by adding a brief structured breakdown of parameters.

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 3 parameters and no output schema, the description only partially covers the tool's context. It lacks information about the return value, side effects (e.g., whether the report is stored or sent to developers), and the meaning of the 'context' parameter.

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%, yet the description only mentions the conversation parameter. It does not explain the 'message' parameter (required) or the 'context' parameter, leaving the agent without sufficient understanding of their purpose or expected 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 states the tool's purpose: to report a bug, missing feature, or send feedback. This is specific and distinct from sibling tools that focus on authentication and Open Finance operations.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any exclusions or context for when reporting via this tool is appropriate, nor does it reference sibling tools.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds no further behavioral context beyond what the annotations provide, but does not contradict them.

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

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

Single, front-loaded sentence with no wasted words. Every part is essential 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?

For a simple tool with no parameters and a straightforward return value (versions), the description is complete. No output schema is necessary.

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

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

No parameters exist, so schema coverage is 100%. With 0 params, the baseline is 4. The description does not need to add param details.

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 (Show) and the resource (current MCP platform and adapter versions). It distinguishes this tool from siblings that deal with authentication, finance, or other 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?

No explicit guidance on when to use or alternatives, but it is a simple version info tool. The usage is implied by the purpose.

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 context about the specific state returned (installed MCPs, connection status, catalog tool counts). No contradictions. 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?

Single sentence, front-loaded with the core action, no wasted words. Every part earns its place.

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

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

Given no output schema, the description adequately explains what is returned (installed MCPs, connection status, catalog tool counts). No additional context needed for a simple read-only query.

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 baseline is 4. Description does not need to add parameter info. Schema coverage is 100% (no params), so no burden on description.

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 'returns the current toolkit state: installed MCPs, their connection status, and how many catalog tools each exposes.' It specifies the verb 'returns' and the resource 'toolkit state' with concrete details, distinguishing it from siblings like 'authenticate' or 'connect' which have different purposes.

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 or when not to use this tool vs alternatives. It is implied as a read-only informational tool, but no exclusions or alternatives are mentioned. With a clear purpose, the usage is inferred, not stated.

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