QI SCD MCP

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

Annotations indicate idempotentHint=true and destructiveHint=false. The description adds behavioral context: it details the two authentication workflows (config vs session token) and the behavior of calling with no args to obtain a link. This adds value beyond the annotations, though it could mention error handling or token validation.

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 audience, then explains two usage methods. Every sentence adds value, though it could be slightly more concise. It is well-structured for an agent to parse.

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

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

While the description covers the main workflows, it does not specify the return value when a token is passed (likely a success response) or error cases. Given the lack of output schema, more detail on return format and potential errors would improve completeness. However, the annotations provide safety guarantees.

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 'token' parameter: it is a JWT to be pasted for session login. It also describes the effect of omitting the parameter (returns link). This provides meaningful semantics beyond the raw schema.

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

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

The description clearly states the tool's purpose: to authenticate the user. It specifies the verb 'authenticate' and identifies the resource (MCP.AI IDE agent login). It distinguishes from sibling tools by focusing on authentication for IDE agents, which is unique among the listed siblings.

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

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

The description provides clear guidance on when to use the tool: for login via browser token, either permanently by setting config or session-only by passing the token. It also explains the alternative of calling with no arguments to get the link. While it doesn't explicitly state when not to use it, the context 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?

The description adds value beyond annotations (readOnlyHint, idempotentHint) by detailing the return payload format: 'authenticated:true and empty pending[]' when connected, and 'connect_url' when credentials are missing. It does not contradict annotations and provides helpful 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 two sentences with no wasted words. The first sentence immediately states the core function, and the second elaborates on the two states. It is front-loaded and concise.

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

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

Given no output schema, the description completely explains the return values for both relevant states. It covers all necessary information for a zero-parameter, read-only tool.

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

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

The tool has no parameters and schema coverage is 100%, so no parameter description is needed. The description does not add parameter details, but the baseline score for zero-parameter tools is 4, indicating adequate handling.

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

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

The description clearly states the tool returns connection status and URLs, specifying the behavior under two distinct scenarios (all providers connected vs missing credentials). This is specific and distinguishes it from siblings like 'authenticate' or 'openfinance_list_connections', which focus on different actions or data.

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

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

The description implies usage for checking connection status but does not explicitly state when to use this tool instead of alternatives like 'openfinance_list_connections' or 'openfinance_get_item_status'. No when-not or exclusion criteria are provided, leaving the agent to infer usage 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 indicate openWorldHint=true, and the description confirms invoke works even when the MCP is not installed. It adds that writes require workspace owner/admin, invoke returns connect/checkout links in specific credential/payment scenarios, and that search/describe flag installed_in_toolkit vs installed_in_workspace, providing valuable behavioral context beyond annotations.

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

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

The description is long but necessary for a tool with 23 parameters and 16 actions. It is front-loaded with the purpose, then structured around the core flow and key distinctions. Some redundancy exists (portuguese example 'consulta um CPF') but overall 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 23 parameters and no output schema, the description is remarkably complete: it explains the flow, the return behavior for describe/invoke/publish_prompt, auth/permission requirements, billing/payment handling, and the prompt library. It leaves little ambiguity about how to use the tool.

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

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

With 0% schema description coverage, the description explains the core parameters: action values (search, describe, invoke, install, etc.), query, limit, mcp_id, tool_id, arguments, and the prompt_* fields. It doesn't cover every parameter (immediate, tier_slug, cancel_reason, etc.) but gives enough context to infer many, making the description a strong substitute.

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

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

The description clearly states the tool is the official mcp.ai marketplace, cataloging MCPs/tools and running them. It enumerates specific capabilities (search, describe, invoke, install, prompt library) and distinguishes from sibling tools like openfinance_* by being the central marketplace.

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

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

It explicitly contrasts invoke vs install, stating to prefer invoke for one-off use and install only to make an MCP permanent. It also says to use request_mcp when nothing fits and that subscribe/cancel handle billing, giving clear decision 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?

Description elaborates beyond annotations: confirms destructive behavior (consistent with destructiveHint), explains data unavailability, and mentions return of add_connection_url. Does not detail authentication or prerequisites, but adds useful 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?

Three sentences with no wasted words. Key action front-loaded immediately. Every sentence adds value: action, effect, return value. Very concise and 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?

For a simple tool with one required parameter, destructive annotation, and no output schema, the description covers the essential behavioral and outcome information. Lacks parameter explanation, but overall sufficient for selection and invocation.

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

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

Schema has 0% description coverage for the single 'item' parameter. Description only says 'for a specific bank' but does not explain that 'item' is the bank identifier (e.g., connection ID). Incomplete parameter guidance for a tool with no enum or nested objects.

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 revokes Open Finance consent and deletes connection data for a specific bank. Verb 'Revokes' and 'deletes' specify the action, and resource is clear. Slightly vague on identifying the bank, but adequate.

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

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

No explicit guidance on when to use this tool versus siblings like 'connect' or 'openfinance_list_connections'. It mentions reconnection URL but lacks direct comparison or 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?

Annotations provide only basic hints. The description adds rich behavioral detail: polling up to ~60s, response structure (results, errors, status fields), handling of re-authentication needs (reconnect_url), and timeout behavior. This fully compensates for lack of annotation detail.

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

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

The description is comprehensive yet well-organized: purpose, usage, parameter details, return value, error states, and wait option. Every sentence adds value; no fluff. It is appropriately front-loaded with the core action.

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

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

Given no output schema, the description fully explains the return format, including result fields and error conditions (needs_action, timed_out). All 2 parameters are thoroughly documented. The tool's behavior and edge cases are covered, making it complete for agent invocation.

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

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

Schema has 2 parameters with 0% coverage; description explains both in depth: 'wait' defaults to true and can be set false for fire-and-forget; 'items' is an array of selectors (item_id, connector_name, etc.) and omitting it syncs all. This adds 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 it forces a re-sync of bank connections and waits for completion. It distinguishes from sibling tools like openfinance_get_item_status (re-check) by specifying that this triggers a sync. The verb 'forces' and resource 'connections' 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?

The description explicitly tells when to use ('when a balance or transaction list looks stale') and provides context on wait behavior (fire-and-forget vs. wait). It also hints at alternatives (re-check with openfinance_get_item_status on timeout). However, it does not explicitly state when not to use or compare to other sync tools, missing some exclusion 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 important behaviors: CREDIT accounts may return BALANCE_FETCH_ERROR with structured warning, degradation to last-synced balance with realtime:false and warning on upstream unavailability. Annotations already indicate read-only and idempotent, so 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?

Four succinct sentences, well-structured, front-loaded. Every sentence adds value without redundancy.

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

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

Given one parameter and no output schema, the description is complete: covers input constraints, error scenarios, degradation, and response shape (results, errors). An agent can confidently use this 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 adds crucial meaning: account_ids is an array of strings, limited to 1-50. This goes beyond schema and compensates for lack of documentation.

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 real-time balance per account id, references the endpoint, and specifies the input parameter. It is unambiguous and distinct from sibling tools like openfinance_get_accounts_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?

The description explains how to use the tool (pass account_ids as array 1-50) and describes error handling. While it does not explicitly contrast with alternatives, the context is clear enough for correct 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds behavioral context about provider_incident block and unreliable values, which is 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?

Front-loaded with main action and parameter. Could be slightly more concise, but the added detail about provider_incident is important and earned. No 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?

For a single-parameter tool with no output schema, the description provides complete context: what is returned (full accounts with creditData), how to use (array of IDs), batch shape, and a critical warning. No gaps.

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

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

Schema only defines type array of strings with 0% description coverage. Description adds crucial meaning: array of 1-50 account IDs, batch shape, and provider_incident warning, fully compensating for lacking schema descriptions.

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

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

Clearly states returns full account objects with extended creditData per ID. Distinguishes from sibling tools like openfinance_list_accounts by specifying it provides detailed objects including credit limits.

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 usage: pass account_ids array (1-50) and mentions batch shape. Includes a warning about provider_incident and not presenting values as real. Lacks explicit when-not or alternatives, but 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 valuable behavioral context: it does not return individual transactions, returns a batch shape with results/errors, notes that Pluggy does not return a paid/status field, and explains the meaning of payments[] (typically referring to previous bill's payment). 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 front-loaded with the main purpose and is efficiently structured. Every sentence adds value, from specifying the return fields to explaining caveats. Despite being long, it avoids redundancy and is well-organized, making it easy for an agent to parse.

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 (no output schema but description explains return shape and fields, annotations provide safety), the description is remarkably complete. It covers what the tool returns, what it does not return, how to use it in conjunction with other tools, and important behavioral notes about payments and bill status. No gaps are apparent.

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

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

The input schema has one required parameter `bill_ids` with no description (0% coverage). The tool description adds that it should be passed as an array and discovered via openfinance_list_credit_card_bills. While this adds some meaning, it does not specify the format or constraints of the IDs, which could leave the agent guessing. Given the low schema coverage, more detail would be beneficial, but the existing context is adequate for basic 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 bill-level detail for credit card bills by id. It distinguishes itself from sibling tools by specifying that it does not return individual transactions, and that for itemized transactions one should use openfinance_list_transactions. It also differentiates from openfinance_list_credit_card_bills for discovering bill ids.

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

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

The description provides explicit guidance: use openfinance_list_credit_card_bills first to discover ids, do not reconstruct bill totals from transactions, and prefer openfinance_list_credit_card_bills for payment status. It also explains when to use openfinance_list_transactions for individual 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 indicate readOnly, idempotent, non-destructive. Description adds behavioral context: reconnect_url for re-authentication, no connection slot consumption, and bulk behavior. 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 convey all necessary information without filler. Front-loaded with primary function and statuses, then details on usage variants.

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?

Describes return fields (status, executionStatus, connector metadata, reconnect_url) and bulk output format. Missing details on error cases, but sufficient for a status-check tool given no output schema.

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

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

Schema coverage is 0%, but description explains the purpose of 'item' (single bank), 'item_id' (likely synonym), and 'item_ids' (batch). Compensates well for the lack of schema descriptions.

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

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

The description clearly states the tool returns the current status of a bank connection with specific statuses like UPDATED, UPDATING, LOGIN_ERROR. It distinguishes from sibling tools by noting bulk support and the ability to get all linked banks at once.

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: omit 'item' for all banks, pass 'item' for a single bank, and mentions bulk support via 'item_ids'. Does not explicitly state when not to use this tool versus alternatives, but context is clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds behavioral context like batch processing with '{ results, errors }' and lists returned fields. No contradictions, but limited added value over 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, front-loaded with purpose and key fields, no extra words. Efficiently communicates essential information.

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

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

Lists many return fields and batch shape, which helps despite no output schema. However, does not describe error handling or behavior when loan IDs are invalid, leaving 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 has 0% description coverage, so description compensates by stating 'Pass loan_ids as an array (1-50).' This adds range and format semantics. Also mentions batch shape. Effectively explains the single parameter.

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

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

Clearly states the tool returns full loan contract detail by ID, lists many specific fields, and distinguishes from sibling openfinance_list_loans by directing to use it after listing loans for deep-dive.

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

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

Explicitly says 'Use after openfinance_list_loans to deep-dive on a specific contract.' Provides batch shape and array size (1-50). Does not mention when-not or alternatives, but context is clear.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description adds significant behavioral context: credit card balance is connector-dependent, provider incident may cause unreliable values, identity_notice for duplicate accounts, and bulk support. This goes beyond the annotations.

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

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

The description is detailed and well-structured, with key information front-loaded. While slightly long, every sentence adds necessary value given the tool's complexity. It could be trimmed slightly but 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 tool's complexity (4 params, no output schema, many siblings), the description is comprehensive. It covers edge cases, caveats, alternative tools, and explains response fields. It leaves little 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?

With schema description coverage at 0%, the description fully compensates by explaining the semantics of 'item' (omitting vs passing), 'type' (BANK/CREDIT), and 'item_ids' (bulk support). It adds meaning that the schema alone does not provide.

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 a bank connection with specific fields, and distinguishes between listing all accounts (omitting item) and targeting a single bank (passing item). It uses specific verbs and resources, and the scope is 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 explicitly says when to omit item (for all accounts across banks) vs pass item (for a single bank), and provides context about credit card balance meaning and provider incidents. It also recommends an alternative tool (openfinance_list_credit_card_bills) for standardized open-bill amounts.

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

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

Annotations already declare readOnly, idempotent, non-destructive. Description adds caching behavior, mentions single aggregated response, and explains the structure of each entry—providing useful 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?

Concise, well-structured, front-loaded with main purpose. Every sentence adds value—no redundant information.

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

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

Despite no output schema, the description fully explains the return structure (fields, nesting, language variants) and caching behavior. Sufficient for this simple lookup 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; description correctly states it has no inputs. Baseline 4 per rules for zero-parameter tools. The description implicitly confirms no parameters needed.

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

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

Clearly states it returns Pluggy's transaction category taxonomy, cached. Distinguishes itself by mentioning its use by another sibling tool (openfinance_update_transaction_category) and specifying the output fields.

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 via context about caching and reference to another tool, but does not explicitly state when to use this tool versus alternatives or provide when-not scenarios.

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 behavioral details about reconnect_url (no slot consumption, no prior disconnection needed), which goes beyond annotations. No contradiction found.

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

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

The description is concise (two sentences) yet informative. It front-loads the main purpose and then adds key behavioral context. Every sentence earns its place without redundancy.

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

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

Given no output schema, the description adequately explains the main return values and the important reconnect_url behavior. It could potentially mention add_connection_url behavior, but it's not essential. Overall complete for a listing tool with rich annotations.

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

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

No parameters exist, so the description does not need to explain them. Schema coverage is 100%, and the description adds value by explaining return fields and URL behavior. Baseline for zero parameters is 4.

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

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

The description clearly states the tool returns saved bank connections with specific fields (connector_id, item_id, bank name, reconnect_url, add_connection_url). The purpose is distinct from sibling list tools by focusing on connections and providing connection-specific URLs.

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

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

The description provides explicit usage guidance for the reconnect_url, specifying when to use it (re-authentication, LOGIN_ERROR, stale data) and noting it does not consume a slot or require disconnection. However, it does not compare usage to sibling tools or state when to use the tool itself (though the main use case is straightforward).

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

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

Annotations already indicate readOnlyHint and idempotentHint; description adds rich behavioral context: payment_status derivation, cross-bill payment rules, open_bill confidence levels, connector asymmetry, and bill grouping reliability. No contradiction with annotations – all disclosed behaviors are consistent with a read-only idempotent operation.

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

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

The description is very long and dense, covering numerous nuances in a single paragraph. While the level of detail is necessary for the complex domain, the structure could be improved with breaks or bullet points for readability. It front-loads the main result but becomes a wall of text.

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

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

Given the tool's complexity, absent output schema, and rich annotations, the description is exhaustive. It covers return fields, derived statuses, connector asymmetries, edge cases, and performance implications (include_open_bill scans extra data). An agent has all necessary context to 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?

Schema coverage is 0%, so description must compensate. It explains include_open_bill in detail, mentions account_ids for bulk, and implies account_id's role. However, pagination parameters (page, page_size) are not described, though they are self-explanatory. The omitted explanation is a minor gap given the depth elsewhere.

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 a CREDIT-type account, listing specific fields (dueDate, totalAmount, etc.) and distinguishing from individual transactions (openfinance_list_transactions). It includes details about open_bill and bulk support, leaving no ambiguity about the tool's function.

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

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

Explicit guidance on when to use this tool vs. transaction tools, opt-in include_open_bill, cross-bill payment logic, and not summing transactions by billId. Also warns against misinterpreting payment_status and connector-specific limitations. Provides clear when-to-use and when-not-to-use instructions.

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

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

The description adds significant behavioral details beyond annotations: error handling (returns warning instead of throwing on 403), data integrity cross-checking with integrity flags, and bulk support. Annotations already declare readOnlyHint=true, destructiveHint=false, so 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 detailed and front-loaded with the main purpose, but it is verbose with technical details that could be structured more concisely. Every sentence adds value, but the length could be reduced.

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 missing output schema and detailed parameter explanations, the description covers error handling, data integrity, bulk support, and return structure comprehensively for this tool's complexity.

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

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

Schema description coverage is 0%, but the description explains bulk support for item_ids and mentions filtering by type. However, it does not explain item, page, page_size, or item_id parameters, leaving significant gaps.

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

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

The description clearly states the tool returns investment portfolio for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.). It distinguishes from sibling tools like openfinance_list_investment_transactions by focusing on portfolio rather than 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 when to use (to get investment portfolio) and provides guidance on handling data integrity warnings. However, it does not explicitly contrast with alternatives or state when not to use.

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

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

Annotations already declare readOnlyHint and destructiveHint as safe, and the description adds value by detailing the return structure (fields like netAmount, expenses) and bulk support behavior. No contradiction with annotations; the description enriches understanding of what the tool produces and how it operates.

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 cover purpose, use case, fields, and bulk support. Every word adds value, and the most critical information (prerequisite) is front-loaded. No unnecessary elaboration.

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

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

With no output schema, the description helpfully lists the returned fields and provides prerequisite context. However, it omits explanation of pagination parameters (page, page_size), which are relevant for a list tool. Still, the core use case is well-covered.

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 0% description coverage, so the description must compensate. It explains the purpose of investment_id and investment_ids (batch) but does not describe page and page_size parameters at all. This leaves the agent uncertain about pagination, which is a gap for such a list tool.

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 movement history for a specific investment position, listing transaction types and key fields. It clearly distinguishes from sibling tools like openfinance_list_investments (which lists positions) and openfinance_list_transactions (general transactions) by focusing on investment-specific movement.

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 to use this tool after openfinance_list_investments to get the investment_id, offering a clear prerequisite and sequence. It also mentions bulk support via investment_ids, but does not explicitly state when not to use it or alternatives for cross-investment queries.

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

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

Annotations already indicate readOnly, idempotent, non-destructive. The description adds the important behavioral trait of sequential rate-limit spacing for multiple connections, which is 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 sentences, no wasted words, front-loaded with main purpose and immediately covers key usage details. Highly efficient.

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

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

For a simple read-only list tool with good annotations, the description is adequate. It explains parameter behavior and mentions return structure ({ results, errors }). No output schema needed as it's a list of loans.

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 detailing that `items` accepts connection selectors (item_id uuid, connector_id, or connector_name) and one per connection, adding 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 it lists loan contracts per bank connection via GET /loans, and the differentiating parameter behavior (items vs omit) distinguishes it from siblings like openfinance_get_loan_detail and 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 explains when to pass `items` (for specific connections) vs omit (list all), and notes sequential rate-limited querying. It does not explicitly contrast with sibling tools, but the context is clear for its own 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 readOnly and idempotent. The description adds extensive behavioral details: auto vs manual pagination, truncation, error handling, detail levels, upstream incident handling, and variation in credit card pending/posted across connectors. 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 quite long and dense. While it covers many details, it could be more concise. However, it is well-structured with clear sections.

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 (8 params, no output schema), the description is remarkably complete: covers usage, parameters, behavior, error handling, edge cases, and cross-references to sibling tools. Only minor omission is direct comparison to openfinance_list_transactions_by_item.

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

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

With 0% schema coverage, the description fully explains all 8 parameters: from/to (ISO YYYY-MM-DD), page/page_size (pagination modes), detail (compact/rich/raw), search_queries (case-insensitive substring), account_ids (bulk), and implicit account_id. Adds 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 it returns transactions for bank accounts (BANK or CREDIT). Distinguishes itself from openfinance_list_credit_card_bills by noting it's the only way for credit card transactions. However, it does not explicitly differentiate from the sibling openfinance_list_transactions_by_item.

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 (e.g., for credit card itemized transactions), when not to (e.g., reconstructing bill totals), and mentions alternatives like openfinance_list_credit_card_bills and openfinance_list_accounts for specific needs.

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: truncation at 5000 transactions per account, truncation flag, provider incident block, and that reconnecting does not fix provider issues. This adds significant context beyond the read-only and idempotent hints already annotated.

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

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

The description is comprehensive but somewhat verbose. It front-loads the core purpose but contains redundant phrasing and could be tightened without losing meaning. For example, the first sentence is excellent, but later sentences on details could be condensed.

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 high parameter count (9), zero schema descriptions, and no output schema, the description provides thorough context: explains when to use each parameter, behavior, limitations (truncation, provider incidents), and bulk support. It leaves no major gaps for the agent to infer.

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 each parameter's meaning, allowed values, defaults (granularity: monthly, detail: compact), and behavioral implications (e.g., 'compact' returns summary, 'rich' adds merchant info). It also clarifies the dual use of 'item' and 'item_ids' for bulk.

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 provides consolidated cash-flow analysis for a bank connection over a period, resolving accounts internally and fanning out transactions. It distinguishes itself by eliminating the need to first call openfinance_list_accounts and by supporting analysis of all linked banks at once.

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 (analyze connection transactions, cash flow, bigger expenses) and when alternatives like calling openfinance_list_accounts are not needed. It also explains different granularity levels for compact summaries versus raw rows. However, it could be more explicit about comparing to the sibling openfinance_list_transactions.

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

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

Annotations already declare readOnlyHint and idempotentHint. Description adds that the tool is 'LIVE', checks a public status page, and returns specific data: global indicator, degraded components, open incidents, and affected banks. This goes well 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?

Four well-structured sentences, each adding distinct value: purpose, differentiation, usage scenario, and return data. No fluff, front-loaded 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?

Despite no output schema, the description fully explains return values (global indicator, components, incidents, your_banks_affected). Covers all needed context for a parameterless read-only tool.

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

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

No parameters exist (0 params), so baseline is 4. The description correctly does not attempt to explain parameters.

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

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

Clearly states the action ('Checks'), the resource ('LIVE operational status of the Open Finance provider'), and explicitly differentiates from the sibling tool 'openfinance_get_item_status' by noting it checks provider health, not connection health.

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 usage scenario: 'Use it whenever data looks incomplete or stale even though a connection shows UPDATED' and when to differentiate provider-side problems from connection issues. Also names an alternative tool.

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

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

Annotations indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds critical behavior: it returns a connect_url, honors user plan (PF/PJ), and mentions caveats for non-Open-Finance connectors. 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 detailed but not overly long. It front-loads the main purpose and adds necessary caveats. A minor reduction for slightly dense phrasing, but 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?

With no output schema, the description thoroughly explains what the tool returns per match, including connector id, access, audience, connections, accounts, and connect_url. It also covers plan behavior and caveats, making it complete for an agent to use correctly.

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

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

Schema coverage is 0%, but the description explains that keywords[] is required for search terms and include_accounts is boolean to include accounts. It provides syntactic and semantic context beyond the schema, which only specifies types.

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

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

The description clearly states that the tool searches bank connectors by name, returns specific fields like connector id, access type, audience, and a ready connect_url. It explicitly says to call this BEFORE connecting, distinguishing it from sibling tools like 'connect' 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 tells when to use the tool (before connecting, to get a one-click link) and that keywords[] is required. It explains the behavior without keywords (returns a hint). However, it does not explicitly state when not to use it or mention alternatives, 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?

Beyond annotations (which indicate a write operation), the description reveals important side effects: overriding Pluggy's automatic categorization and creating a Category Rule. It also explains partial batch errors.

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

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

The description is moderately sized and front-loaded with the main purpose. It efficiently explains input, side effect, and response format without redundancy.

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

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

Given the complexity (batch update with side effects and partial errors), the description covers input, behavior, and output shape. It does not mention limitations or prerequisites, but it is sufficiently 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 schema has 0% description coverage; the description compensates by explaining the structure of 'items' as an array of { transaction_id, category_id } and where to obtain those IDs, adding meaning beyond the raw schema.

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

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

The description clearly states the verb 'corrects' and the resource 'category of one or more transactions', with the endpoint. It distinguishes from sibling tools like openfinance_list_transactions by specifying the source of IDs.

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

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

The description explicitly states the use case: 'fix miscategorized transactions and improve categorization accuracy going forward.' It does not list exclusions or alternatives, but the context is clear.

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

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

Annotations already indicate idempotentHint=true and destructiveHint=false. The description adds that the tool accepts a message and conversation for feedback but does not disclose any behavioral aspects beyond what annotations provide, such as how the feedback is processed.

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, each serving a purpose: first states the overall function, second provides actionable guidance. It is front-loaded and free of 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 (3 parameters, no output schema), the description covers the essential use case and provides guidance on reproduction. It could mention that feedback is sent to developers, but it is largely 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%, so the description must compensate. It explains the conversation parameter (include recent messages) but does not explain context or message in detail. This partially covers the parameters but leaves the context parameter ambiguous.

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

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

The description clearly states the tool is for reporting bugs, missing features, or sending feedback. It specifies the verb 'report' and resource types, and distinguishes itself from sibling tools which are all finance-related or authentication 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 advises including the conversation array for reproduction, which gives clear usage guidance. While it doesn't explicitly state when not to use this tool, the sibling tools are all unrelated, so context is adequate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the behavioral profile. The description adds only that it shows version information, which is useful but not necessary beyond annotations.

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

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

The description is a single, well-formed sentence that immediately conveys the tool's purpose. No extraneous words, front-loaded.

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

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

Given no output schema, the description mentions what is shown (versions) but could be more precise about the format or structure of the output. However, for a simple version tool, it is largely sufficient.

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

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

There are no parameters, so schema coverage is 100%. The description does not need to explain parameters; it appropriately states the output (version info). Baseline 4 applies as per evaluation criteria for 0 parameters.

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

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

The description clearly states the tool displays current MCP platform and adapter versions, using a specific verb ('Show') and resource ('current MCP platform and adapter versions'). It is distinct from sibling tools, which focus on authentication, OpenFinance operations, or bug reporting.

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

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

The description only states what the tool does but offers no guidance on when to use it versus alternatives, such as checking version before other operations. Usage is implied but not explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is established. The description adds valuable context about what the returned state includes (installed MCPs, connection status, accounts, catalog tool counts), going beyond the annotations to clarify the tool's informational scope.

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, front-loaded sentence that clearly states the purpose and then enumerates the key components of the return value. Every word earns its place, with no redundant phrases 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?

For a zero-parameter, read-only tool with no output schema, this description is sufficiently complete. It tells the agent exactly what information will be returned (installed MCPs, connection status, accounts, catalog tool counts), leaving no significant ambiguity about the tool's 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 accepts zero parameters, and the empty schema provides no parameters to document. Baseline 4 is appropriate since there is nothing to explain; the description focuses on the return value rather than parameters.

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

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

The description clearly states the verb 'Returns' and specifies the resource 'current toolkit state' with concrete details (installed MCPs, connection status, accounts, catalog tool counts). This distinguishes it from sibling tools focused on financial operations or version details.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It implies a state-checking purpose but does not state when to invoke it (e.g., before other operations) or explain why it should be preferred over similar informational tools like show_version or report_bug.

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