EQI MCP

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

The description discloses behavior beyond annotations: it explains that the config-based method yields a non-expiring connection, while token-based is session-only. Annotations indicate idempotentHint=true, which matches the description's implication that calling with no args gets a link (no side effects). No contradiction.

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

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

The description is two sentences, front-loaded with purpose and audience, and efficiently conveys multiple usage modes. It could be slightly more concise but is 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 one optional parameter, no output schema, and annotations covering idempotency and non-destructiveness, the description provides complete context for using the tool correctly. It covers all behavioral aspects needed for an agent to select and invoke it.

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 optional string parameter 'token' with no description. The description adds meaning by explaining that passing a token performs session-only login, and that calling with no args returns a login link. This compensates for the 0% schema description 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 what the tool does: handles authentication for IDE agents like Cursor, providing options for permanent or session-only login. It distinguishes itself from sibling tools, none of which are authentication-related.

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 three distinct usage scenarios: for permanent connection (add to config), for session-only login (pass token), and to get the login link (no args). While it doesn't explicitly state when not to use it, the guidance is clear and actionable.

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

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

Annotations already indicate read-only and idempotent behavior. The description adds value by explaining the two response scenarios (authenticated vs missing credentials), surpassing what annotations alone 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 concise sentences front-load the core purpose and provide specific behavioral details without any 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?

The description adequately covers return values for the two main states. It could be more complete by mentioning potential error conditions or additional fields, but it is sufficient for the tool's simplicity.

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

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

With zero parameters, the baseline score is 4. The description is not required to elaborate on 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 that the tool returns connection status and URLs, with specific details on two possible states. It distinguishes the purpose from siblings like 'authenticate' implicitly, but lacks explicit differentiation.

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

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

The description implies usage for checking connection status but does not provide explicit guidance on when to use this tool versus alternatives like 'authenticate' or other openfinance 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?

The description discloses key behavioral traits beyond annotations: invoke works even when MCP not installed, returns connect/top-up links if credentials or payment needed; install makes MCP permanent; search/describe flag installed status. This adds significant context that annotations (which only give readOnlyHint=false, openWorldHint=true) do not cover, with no contradictions.

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

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

The description is lengthy but well-organized, starting with overall purpose, then core flow, then specific action details, and finally contrast with install. It front-loads the most important information. While every sentence adds value, some redundancy could be trimmed, but it remains clear and 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 the tool's complexity (13 parameters, multiple actions, no output schema), the description covers most critical aspects: how to search, describe, invoke, and the differences between invoke/install. It mentions return values for invoke (links) and search/describe (installed flags). However, it lacks explicit details on outputs for list_tools, subscribe, or request_mcp, and some parameters are not described. Overall, it is quite complete but has minor gaps.

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

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

Schema coverage is 0%, so the description carries the full burden. It explains the 'action' parameter and its values, and describes the roles of 'query', 'limit', 'mcp_id', 'tool_id', 'arguments' in the core flow. However, it does not explicitly detail all 13 parameters (e.g., 'immediate', 'tier_slug', 'conversation', 'request_name', etc.), leaving some ambiguity. Overall, it adds substantial 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 defines the tool as the official marketplace for discovering, describing, and invoking MCPs/tools. It distinguishes from sibling tools by stating it should be used first before external registries, and specifies its role as the in-platform catalog. The verb 'manage marketplace' is specific, and the resource (MCPs/tools) is clear.

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

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

The description provides explicit guidance on when to use this tool versus alternatives: use before external registries; core flow of search→describe→invoke; when to use install vs invoke; and mentions specific actions like subscribe, cancel, report_bug, request_mcp for different needs. It also notes that writes require workspace owner/admin, giving clear context for authorization.

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 explicitly states that bank data will no longer be available and that a re-connection URL is returned, adding behavioral context beyond the destructiveHint annotation. It aligns with annotations and discloses the consequence of data loss.

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 at two sentences, front-loading the core action and consequence. Every sentence is essential and free of extraneous 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 the absence of output schema and insufficient parameter documentation, the description is incomplete. It does not specify the expected format of the re-connection URL or clarify the parameter, leaving significant gaps for the 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?

The single parameter 'item' is not described in either the schema (0% coverage) or the tool description. The description fails to explain what 'item' represents (e.g., bank identifier), leaving the agent without necessary semantic 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 the tool revokes Open Finance consent, deletes connection data, and makes bank data unavailable. It also mentions the return of a re-connection URL, distinguishing it from sibling tools like openfinance_list_connections or openfinance_force_sync.

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 use for disconnecting a bank but does not specify when to use versus alternatives or provide guidance on prerequisites or exclusions. No when-not-to-use context is given.

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

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

Annotations only indicate readOnlyHint=false and destructiveHint=false. The description adds rich behavioral context: it forces sync, polls up to ~60s, returns results/errors structure with fields like synced, needs_action, timed_out. 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 a dense paragraph but well-organized with front-loaded purpose and subsequent details. Every sentence adds value, though slightly more structured formatting (e.g., bullet points for return fields) could improve scanability.

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

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

Given no output schema, the description comprehensively covers return structure, edge cases (needs_action, timed_out), and references alternative tool. Covers all necessary context for an agent to correctly invoke and interpret results.

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

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

Schema description coverage is 0%, so the description must explain parameters. It does so effectively: 'wait' is explained with defaults and behavior; 'items' is explained as array of selectors or omit for all. Adds essential 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 forces a bank to re-sync connections and waits for completion. It specifies the verb 'forces' and the resource 'one or more connections', distinguishes from siblings by describing when to use it versus alternatives like openfinance_get_item_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 a balance or transaction list looks stale'. Explains both usage modes: wait=true (default) and wait=false (fire-and-forget). Also advises using openfinance_get_item_status for timed_out scenarios, providing 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?

The description adds significant behavioral context beyond the annotations: it reveals that the balance is real-time, that credit accounts may return a structured warning on error, and it outlines the response shape. This aligns with the readOnlyHint and destructiveHint=false annotations without contradiction.

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

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

The description is extremely concise: three sentences, each serving a distinct purpose (what, how/errors, response). No redundant or extraneous 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?

For a simple tool with one parameter and no output schema, the description fully covers the key information: purpose, parameter usage, error behavior, and response structure. It is complete given the tool's complexity.

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

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

With 0% schema description coverage, the description compensates by specifying the parameter type ('array'), the element type ('strings'), and an important constraint (1–50 items). It omits explaining what an 'account id' represents, but the tool name and context make that obvious.

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 ('real-time balance payload per account id'), and references the underlying API endpoint (GET /accounts/:id/balance). It distinguishes itself from sibling tools like openfinance_list_accounts or openfinance_get_accounts_detail by focusing on balance retrieval.

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

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

The description specifies that account_ids must be passed as an array with a size range of 1-50, and explains how errors are handled for CREDIT accounts (BALANCE_FETCH_ERROR yields a warning instead of throwing). However, it does not explicitly state when not to use this tool or mention alternative methods for balance 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 declare readOnlyHint=true and idempotentHint=true, so the description adds value by mentioning the batch error shape ({ results, errors }) and the inclusion of extended creditData. There is no contradiction with annotations.

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

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

Two sentences: first defines functionality, second gives parameter and return shape. No wasted words, front-loaded with key information.

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

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

Given one parameter, rich annotations, and no output schema, the description covers parameter usage, return shape, and batch error format. It does not detail individual fields of account objects, but annotations provide safety 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 description coverage is 0%, but the description compensates by specifying that account_ids is an array (1-50), adding constraints not present in the schema (no min/max items). This is necessary for correct invocation.

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

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

The description explicitly states the tool returns full account objects including extended creditData, which is specific and distinguishes it from siblings like openfinance_list_accounts (list without detail) and openfinance_get_account_balance (single 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?

The description provides clear guidance on how to use the tool: pass an array of account IDs with size 1-50. It implies the batch shape but does not explicitly say when to use this tool versus alternatives like openfinance_list_accounts for summaries.

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. Description adds critical nuances: batch shape {results, errors}, Pluggy does not return paid/status field, and payments[] reflect previous bill's payments. This is valuable 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 relatively long but well-structured with parentheticals and notes. Could be slightly tightened, but every sentence serves a purpose. Front-loaded with main functionality.

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 covers return shape, fields, batch behavior, and links to related tools. Provides enough context for effective tool 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?

Input schema has 0% description coverage for bill_ids, but description explains it is an array, how to obtain IDs (via openfinance_list_credit_card_bills), and the expected format. This fully compensates for lack of schema 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?

The description clearly states it returns bill-level details for credit card bills by ID, specifying included fields (financeCharges, payments) and explicitly distinguishes from openfinance_list_transactions by stating what it does NOT return.

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

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

Provides explicit guidance: use openfinance_list_credit_card_bills first to discover IDs, and for transactions use openfinance_list_transactions. Also warns about interpreting payments[] in Brazilian Open Finance 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, destructiveHint=false, and idempotentHint=true. The description adds behavioral context beyond safety: it specifies the two output formats, the return of executionStatus and connector metadata, and that omitting `item` returns a count and items object. 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 three sentences long, front-loaded with the primary purpose in the first sentence, and the second sentence explains the dual usage pattern. Every sentence contributes necessary information without redundancy or filler.

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 parameter and no output schema, the description adequately covers both input behavior (omit vs. pass `item`) and output format (status, executionStatus, connector metadata; for all banks: `{ count, items }`). The description fully equips an agent to select and invoke 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?

The input schema has only one optional parameter `item` with no description, enum, or constraint (0% schema description coverage). The description fully compensates by explaining that omitting `item` returns all banks' statuses, while passing a specific `item` returns a single bank's status. This adds essential semantic meaning that the schema alone lacks.

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

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

The description clearly states the tool returns the current status of a bank connection, listing possible values (UPDATED, UPDATING, LOGIN_ERROR, etc.). It distinguishes between two modes: omitting the `item` parameter returns all banks at once (with format `{ count, items }`), and providing `item` returns a single bank's status. This makes the purpose highly specific and distinct from siblings like openfinance_list_connections.

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

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

The description explicitly tells when to use each invocation pattern (omit vs. provide `item`) and what output to expect in each case. It provides clear context but does not explicitly state when not to use this tool or mention alternatives, though the usage is well-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, idempotent, non-destructive. The description adds critical context: balance meaning is connector-dependent for CREDIT accounts, and explains creditData fields (balanceCloseDate, balanceDueDate). 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 detailed but not overly verbose; every sentence adds value. It is front-loaded with the core purpose and then provides caveats and usage instructions. However, it is somewhat lengthy, which slightly reduces 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 no output schema and the tool's complexity (multiple account types, connector-dependent balance), the description is very complete. It explains return fields, filtering, aggregation, and directs to related tools for complementary data.

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

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

Schema description coverage is 0%, so the description fully compensates. It explains the effect of omitting vs providing `item`, and that `type` filters by account type (BANK/CREDIT). This adds 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 states the tool returns accounts for bank connections (BANK and CREDIT) with detailed fields like balance, number, type, subtype, bankData, and creditData. It distinguishes from sibling tools like openfinance_list_credit_card_bills by noting that the latter provides standardized bill amounts.

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: omit `item` to list across all linked banks (for queries like 'my accounts/cards'), pass `item` to target a single bank. Also warns not to treat `balance` as billing amount, directing to openfinance_list_credit_card_bills for standardized 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 destructiveHint. The description adds that the response is cached, originates from a GET endpoint, and is a single aggregated response with no batch semantics. This adds valuable behavioral context 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 extremely concise—two sentences—yet covers purpose, caching, field details, language preference, and relationship to another tool. Every sentence adds value with no wasted words.

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

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

For a zero-parameter read-only tool with no output schema, the description fully explains the return fields, caching behavior, and usage in conjunction with update_transaction_category. It is complete and leaves no ambiguity.

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

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

The tool has zero parameters, so baseline is 4. No parameter information is needed in the 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?

The description clearly states it returns Pluggy's transaction category taxonomy, specifying the verb (returns), resource (category taxonomy), and key fields (id, description, etc.). It explicitly connects the categoryId to the sibling tool openfinance_update_transaction_category, differentiating it from other list tools.

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

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

The description provides usage context: it's cached, returns a single aggregated response, and advises using descriptionTranslated for pt-BR users. It implicitly suggests using this tool to obtain categoryId before calling update_transaction_category. No explicit when-not-to-use, but the context is sufficient.

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 real value by specifying the return fields and the presence of add_connection_url, which is beyond what annotations provide. 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 sentence, front-loaded with the main purpose, and contains zero unnecessary words. It is appropriately sized for the tool's simplicity.

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 conveys the return values (list of fields). For a simple list tool, this is sufficient. Could optionally mention pagination or ordering, but not strictly 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?

The tool has 0 parameters and schema coverage is 100%. Per guidelines, baseline is 4. The description adds no parameter info, which is acceptable as none exist.

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

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

The description clearly states the verb 'Returns', the resource 'saved bank connections', and lists specific fields (connector_id, item_id, bank name, add_connection_url). It effectively distinguishes the tool from siblings like openfinance_list_accounts.

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

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

The description implies usage for listing saved connections, but provides no explicit guidance on when to use this tool versus alternatives (e.g., openfinance_list_accounts) 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?

The description goes far beyond annotations, explaining the complex payment status derivation, cycle semantics, connector asymmetry, and the extra scan for open_bill. It also notes that a warning is returned if the product is not enabled, adding significant 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 long but every sentence is necessary given the domain complexity. It is well-structured with bold warnings, sections, and critical information front-loaded. 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 and high complexity, the description thoroughly covers return fields, payment status derivation, open bill semantics, connector limitations, and cross-tool references. It even explains edge cases like PAST_DUE_UNCONFIRMED.

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 explains account_id, account_ids, and include_open_bill in detail, covering their usage and effects. However, page and page_size parameters are not mentioned despite schema coverage being 0%, so some semantic gap 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 it returns closed credit card bills for CREDIT-type accounts, listing specific fields like dueDate, totalAmount, etc. It distinguishes from sibling tools by noting that for itemized transactions, use 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?

Provides explicit guidance on when to use this tool, including warnings about not assuming payment status from payments[] and when to use the include_open_bill parameter. It also advises against using account balance for total debt and directs users to the derived fields.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the behavioral baseline is clear. The description adds value by explaining that the tool returns a specific fallback object (with total, results, warning) instead of throwing on errors like 403. This goes beyond annotations, though it does not cover all behavioral aspects (e.g., rate limits, 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 is a single paragraph that front-loads the purpose, then lists asset types and return structure. It is informative without being verbose, but it could be slightly more concise by summarizing asset types rather than listing many examples. Overall, it is well-organized and earns its length.

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 an investment portfolio tool with no output schema and no parameter descriptions, the description adequately explains the return structure and error handling. However, it lacks crucial details about pagination (how to navigate pages) and parameter usage, leaving gaps that could confuse an agent. It 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?

The input schema has four parameters (item, page, type, page_size) with zero description coverage. The description does not explain any parameter, such as what 'item' refers to, how pagination works, or what the 'type' enum values filter. With no schema descriptions and no explanations in the description, the agent has no semantic guidance for filling 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 the investment portfolio for a connection, listing specific asset types (FIIs, stocks, ETFs, fixed income, etc.) and even describes the error fallback. This distinguishes it from siblings like openfinance_list_accounts, openfinance_list_transactions, and openfinance_list_investment_transactions by focusing on the portfolio overview rather than accounts, transactions, or individual investment 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 does not provide any guidance on when to use this tool versus alternatives like openfinance_list_investment_transactions or openfinance_list_accounts. It only states what the tool does, without conditions or exclusions. For a tool with many siblings, explicit usage guidelines are missing.

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 destructiveHint=false. The description adds value by detailing the return fields (quantity, value, amount, etc.) and itemized expenses, and mentions the types of transactions covered. It does not contradict annotations.

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

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

The description is concise with two main sentences and a short note on bulk support. It avoids fluff and front-loads the core purpose and usage context.

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 describes the return fields and usage context. However, it lacks explanation of pagination parameters (page, page_size), which are part of the input schema. Overall, it provides sufficient context for an agent to use the tool effectively.

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

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

Schema description coverage is 0% (no parameter descriptions in schema). The description explains investment_id and investment_ids (bulk support) but does not mention page or page_size parameters. Thus it partially compensates for the missing schema descriptions.

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

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

The description clearly states the tool returns movement history for a specific investment position, listing transaction types (BUY, SELL, etc.). It distinguishes from sibling tools like openfinance_list_transactions by specifying it's for investment transactions and explicitly mentions using after openfinance_list_investments.

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 advises using the tool after openfinance_list_investments to get the investment_id, and mentions bulk support with investment_ids. This provides clear context for when and how to use, though it does not explicitly state when not to use.

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

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

Annotations already indicate read-only and idempotent behavior. The description adds value by disclosing sequential querying with rate-limit spacing and the return format of '{ results, errors }' per connection, which are 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 three sentences, front-loaded with the main purpose, followed by parameter usage details and return format. Every sentence adds essential information with no waste.

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

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

Given the single optional parameter and no output schema, the description covers purpose, parameter usage, behavioral nuances, and return structure. It lacks details on response fields per loan but provides enough for an agent to understand usage. Slightly incomplete for a complete picture.

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 only defines 'items' as an array of strings with no description (0% coverage). The description compensates fully by explaining that items are connection selectors (item_id uuid, connector_id, or connector_name) and that omitting them lists all banks. This adds significant meaning.

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

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

The description clearly states the tool lists loan contracts per bank connection, referencing the endpoint (GET /loans). It distinguishes from sibling list tools by specifying the focus on loans and mentioning per-connection behavior.

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 pass the 'items' parameter (for specific connections) and when to omit it (to list across all banks). It also notes sequential fetching with rate-limit spacing. However, it doesn't explicitly guide on when not to use this tool compared to alternatives like openfinance_list_credit_card_bills.

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

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

Discloses behavioral traits beyond annotations: explains pending vs posted variation by connector, auto-pagination with 5000 ceiling, error handling returning structured errors instead of throwing, and detail mode impacts on data richness and token usage. No contradiction with readOnlyHint, idempotentHint, or destructiveHint.

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

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

The description is lengthy but well-structured with logical sections covering purpose, CREDIT-specific behavior, search, pagination, error handling, detail modes, and bulk support. Every sentence adds value, though it could be slightly more concise without losing clarity.

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

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

Given the tool's complexity (8 parameters, no output schema), the description is remarkably complete. It covers output shape (results array on success, warning/error on failure), explains result fields at different detail levels, addresses edge cases (pending vs posted, connection health), and references sibling tools for complementary information (e.g., openfinance_list_accounts for dates).

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 thoroughly explains each parameter: account_id (required, identifies account), from/to (ISO date filters), page/pagination behavior, page_size (max 500 for manual), detail (compact/rich/raw with specifics), search_queries (case-insensitive substring match, OR semantics), and account_ids (batch support). Adds significant meaning beyond schema.

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

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

Clearly states 'Returns transactions for a bank account (BANK or CREDIT type)' and distinguishes from sibling tools like openfinance_list_credit_card_bills and openfinance_get_credit_card_bill. It specifies that for CREDIT accounts it is the only way to get itemized transactions.

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

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

Provides explicit guidance on when to use this tool vs alternatives (e.g., for open-bill totals use openfinance_list_credit_card_bills). Gives detailed instructions on pagination, date filtering, search queries, and handling truncated results. Also recommends checking connection health if total is 0 for CREDIT accounts.

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

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

Annotations declare readOnlyHint=true and idempotentHint=true, indicating safe, non-destructive operations. The description adds significant behavioral details: it resolves accounts internally, fans out transactions, returns a compact summary by default, and flags truncation at 5000/account with `truncated:true`. It also explains the difference between `detail:'rich'` and `detail:'raw'`, providing full transparency 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 lengthy but every sentence serves a purpose. It is front-loaded with the main value proposition and then systematically details parameters and behaviors. Could be slightly more structured with bullet points, but it remains clear and efficient. No redundant or wasted sentences.

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

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

Despite lacking an output schema, the description thoroughly explains the return format: compact summary with fields like total entradas, saídas, saldo_liquido, monthly evolution, top expenses/receipts, and per-account breakdown for `granularity:'monthly'`, and individual transactions for `granularity:'raw'`. It also covers filters, truncation behavior, and optional enrichment. All relevant aspects for agent decision-making 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?

With 0% schema description coverage, the description carries the full burden and succeeds. It explains each of the 7 parameters: `item` can be connector_id, connector_name, or item_id; `from`/`to` are ISO dates; `granularity` defaults to 'monthly' for compact output; `detail` enriches rows with merchantInfo or raw data; `top_n` controls the largest expenses/receipts; `type` filters BANK or CREDIT. All parameters are given meaningful context 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 uses specific verbs ('Consolidated cash-flow analysis') and clearly states the resource (whole bank connection over a period). It distinguishes from siblings like openfinance_list_transactions by noting that this tool resolves accounts internally, eliminating the need for separate calls. The purpose is unambiguous and well-defined.

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 (e.g., 'análise anual/mensal', 'fluxo de caixa') and explicitly states what is not needed (e.g., 'do NOT need to call openfinance_list_accounts first'). It explains parameter behavior such as omitting `item` to analyze all banks and when to use `granularity:'raw'`. While it does not explicitly list alternative sibling tools for comparison, the guidance is sufficient for an agent to choose correctly.

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

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

Description adds significant behavioral context beyond annotations, such as revealing upstream outages and degraded components. It aligns with readOnlyHint and idempotentHint by indicating it reads the provider's public status page without mutation.

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 well-structured, with a clear separation of use case and return details. Each sentence adds value, though slightly longer than necessary; still efficient.

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

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

Despite no output schema, the description fully explains the return values: global indicator, degraded components, open incidents, and 'your_banks_affected'. For a parameterless tool, this is complete and actionable.

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

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

No parameters exist (schema coverage 100% with empty properties), so the description does not need to add parameter info. Baseline 4 is appropriate as there is no missing information.

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

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

Description clearly states the tool checks the LIVE operational status of the Open Finance provider's public status page, distinguishing it from the sibling tool openfinance_get_item_status which checks the user's own connection. The verb 'checks' and resource 'provider status' are specific and unambiguous.

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

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

Explicitly tells when to use the tool: when data looks incomplete or stale even when a connection shows updated. It distinguishes provider-side problems from connection issues and mentions the return of incidents affecting the user's banks, guiding 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?

Description discloses behaviors beyond annotations: returns connect_url, honors plan, returns hint if no keywords, caveat for credential connectors. No contradictions with annotations (readOnlyHint, idempotentHint, destructiveHint).

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 detailed yet concise, front-loading purpose and workflow. Each sentence adds value—return fields, caveat, plan, usage instruction. 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?

Despite no output schema, description fully covers return fields, parameter effects, and behavioral nuances (caveat, plan, hint). Complete for a search tool with two 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?

Adds meaning to both parameters: keywords as array of strings (required, with example), include_accounts for returning accounts. However, description states keywords as required while schema has no required field, causing a minor inconsistency. Otherwise, explanation is thorough.

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 searches bank connectors by name, returns specific fields (connector id, access, audience, connections, connect_url), and is intended to be called before connecting. Distinguishes from siblings like 'connect' and 'marketplace' by specifying its role in the workflow.

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 provides usage context: keywords are required, without it returns a hint. Also advises surfacing caveat for non-Open-Finance connectors to encourage Open Finance preference. Honoring user plan (PF vs PJ) adds situational 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?

Discloses key behavioral traits: overrides automatic categorization, teaches Pluggy by creating a Category Rule, and batch error handling (per-item errors don't fail batch). This goes well beyond sparse 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 fairly long but each sentence adds value. Front-loaded with purpose. Slightly verbose (e.g., repeating endpoint path) but overall efficient.

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

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

Covers parameters, input sources, side effects, return shape, and error handling. No output schema exists but description explains the return format thoroughly.

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 items array structure, where to get transaction_id and category_id, and the batch return shape.

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 'Corrects the category of one or more transactions' with HTTP method and endpoint. It differentiates from siblings by referencing where to get input IDs (list tools).

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

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

Explicitly says 'use this to fix miscategorized transactions and improve categorization accuracy going forward.' Provides clear context but doesn't explicitly state when not to use it.

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

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

Annotations indicate the tool is idempotent, adding behavioral safety. The description adds minimal extra context (need for conversation), but does not elaborate on side effects or response behavior 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 concise sentences with no redundant information, front-loading the purpose and then the key usage hint.

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

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

The description covers the core purpose and a key usage detail but lacks information about the return value or what happens after reporting. Given no output schema, it could be more 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 partially compensates by explaining the 'conversation' parameter and implying 'message' is the report content. However, 'context' is unmentioned, and parameter meanings could be clearer.

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: reporting a bug, missing feature, or sending feedback. This distinguishes it from sibling tools which are mostly finance-related.

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 advises including the conversation array for reproduction, providing clear usage context. However, it does not specify when not to use or alternative tools, though none are directly comparable.

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, covering the safety profile. The description adds specific context about what version information is shown (platform and adapter), which aligns with annotations and provides value.

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

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

A single sentence of 8 words perfectly describes the tool's function. No extraneous information; every word is necessary and earns its place.

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

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

Given the tool has no parameters, no output schema, and annotations fully describe safety, the description is complete. It adequately informs the agent of the tool's purpose and 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?

The tool has no parameters, and the schema coverage is 100% (trivially). Baseline for 0 parameters is 4. The description does not need to add parameter details, as none exist.

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

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

The description clearly states the tool shows current MCP platform and adapter versions. It uses a specific verb ('Show') and identifies distinct resources. No sibling tool provides similar functionality, so differentiation is inherent.

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

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

While no explicit when-to-use or when-not-to-use guidance is provided, the tool is unique among siblings (no other version-related tools), making its usage context clear: call it to retrieve version information. The description implies this without 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?

Annotations already indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds context about what data is returned (installed MCPs, status, catalog tools), which goes beyond annotations without contradicting them.

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

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

Single sentence that is concise, front-loaded with the main action, and contains 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?

Given no parameters and no output schema, the description adequately explains the tool's return value. It could optionally specify data format or example, but overall it is sufficient for a simple info tool.

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

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

No parameters exist, so schema coverage is 100% by default. The description does not need to add parameter meaning, and baseline for zero-parameter tools is 4.

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

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

The description clearly states the tool returns toolkit state with specific items: installed MCPs, connection status, and catalog tool count. It uses a specific verb ('returns') and distinguishes from sibling tools that perform actions like authentication, connection, or 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?

The description implies usage for checking toolkit state but provides no explicit guidance on when to use or when not to use it versus alternatives. No mention of prerequisites or exclusion criteria.

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