EQI MCP

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

Annotations provide readOnlyHint=false, destructiveHint=false, idempotentHint=true. The description adds context about login flow, token usage, and permanent vs session behavior, which goes beyond 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 slightly long but well-structured, with a clear first sentence and detailed explanation of usage. Every sentence adds value, though it could be more succinct.

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

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

Given no output schema, the description covers the authentication flow, method selection, and token handling. It could mention error cases or token format, but is fairly complete for an auth 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 schema has one optional parameter 'token' with 0% coverage. The description fully explains its purpose: either provide a JWT for session login or omit to get a link. This adds crucial 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 states it is for authentication, explaining two methods: browser login to get a permanent token via config, or session-only by pasting a token. It distinguishes from siblings like 'connect' by focusing on authentication flow.

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 clearly explains when to use each method: for permanent connection via config, or for session login by pasting token, or with no args to get a link. It lacks explicit when-not-to-use or alternatives among siblings but provides clear 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds valuable behavioral details about return states (e.g., authenticated:true vs connect_url), which annotations do not cover.

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

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

Two sentences with no wasted words. Front-loaded with purpose and then explains behavior. Every sentence adds value.

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

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

Given zero parameters and no output schema, the description adequately explains return behavior for all states. No additional information needed.

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

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

No parameters exist, so schema coverage is 100% by default. Description does not need to add parameter info. Baseline 4 is appropriate.

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

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

Description clearly states the tool returns connection status and URLs, with specific behavior for different states. Distinguishes from sibling tools like 'authenticate' by focusing on status checking.

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

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

Description implicitly guides usage by describing when to expect certain results, but does not explicitly state when not to use or suggest alternatives. However, given the tool's simplicity, this is acceptable.

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

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

Beyond the annotations, the description reveals key behaviors: invoke runs one-off without installing, returns connect/checkout links under auth/payment failures, and requires owner/admin for writes. It also explains the distinction between installed_in_toolkit vs installed_in_workspace and the prompt library's purpose. These details go well beyond the generic annotation hints.

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

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

The description is a single dense paragraph but is front-loaded with the main purpose and every sentence contributes unique information (core flow, invoke behavior, permissions, prompt library). It is appropriately detailed for a multi-action hub, though it could benefit from greater structural organization.

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 (14 actions, 23 parameters, no output schema), the description covers the primary workflows, edge cases (credentials/payment), permission requirements, and the prompt library. It omits some details like the 'resume' action and several parameter meanings, but it provides enough context for an agent to understand the tool's scope and main behaviors.

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

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

With 0% schema description coverage, the description compensates by explaining the action enum values (search, describe, invoke, install, etc.) and the roles of mcp_id, tool_id, arguments, and prompt_vars. However, many of the 23 parameters (limit, immediate, tier_slug, cancel_reason, report_context, prompt_targets, etc.) remain undocumented, so compensation is only partial.

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

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

The description clearly identifies the tool as the official mcp.ai marketplace, a catalog and execution engine for MCPs/tools, and also a prompt library. It enumerates the core flow (search→describe→invoke) and lists all major actions, distinguishing it from the openfinance sibling tools which are specialized financial connectors.

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: prefer invoke for one-off use over install for permanent additions, use list_tools to see what is callable, use request_mcp when nothing fits, and use subscribe/cancel for billing. It also clarifies prerequisites such as owner/admin for writes and the retry flow when connect/checkout links are returned.

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

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

Annotations already indicate destructiveHint=true, so the destructive nature is known. The description adds valuable context: data deletion, unavailability of data, and a reconnection URL. 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 concise sentences front-load the main action and outcome. Every sentence adds value with no redundancy.

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

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

The description covers the destructive effect and return value but lacks detail on parameter format. With no output schema, the mention of add_connection_url helps but is incomplete for an agent to fully understand the response.

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 described only as 'specific bank' with no format or identifier type (e.g., bank ID, connection ID). Schema description coverage is 0%, and the description does not compensate with sufficient detail.

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

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

The description clearly states the action ('Revokes the Open Finance consent'), the resource ('specific bank'), and the outcome (deletes connection data, data no longer available). This distinguishes it from sibling tools like connect or 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 usage for disconnecting a bank but does not explicitly state when to use this tool versus alternatives (e.g., openfinance_force_sync). No guidance on prerequisites or when not to use.

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

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

Annotations indicate mutation (readOnlyHint=false), non-destructive (destructiveHint=false), non-idempotent (idempotentHint=false). Description adds extensive context: PATCH then polls up to ~60s, explains needs_action with reconnect_url, timed_out behavior, and return fields. No contradiction.

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

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

Description is thorough but slightly long. However, it is well-structured: core action first, then parameters, return format, edge cases. Every sentence adds value. Minor room for trimming but overall effective.

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

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

Given complexity (polling, multiple outcomes, no output schema), the description is very complete. It covers all aspects: sync behavior, parameter meaning, return fields, error states (needs_action, timed_out), and alternatives. 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 has 2 params (wait boolean, items array of strings) with 0% description coverage. Description fully compensates: items can be selectors (item_id, connector_id, etc.) or omitted for all; wait defaults to true (implied) and false for fire-and-forget. Explains implications of each 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?

The description clearly states it forces a bank to re-sync connections and waits for completion. It distinguishes from sibling tools like openfinance_get_item_status (re-check) and openfinance_disconnect_bank (disconnect/reconnect). Verb 'forces' and resource 'bank 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?

Explicitly says when to use (stale balance/transactions) and when not (disconnect/reconnect not needed). Provides guidance on omitting items to sync all, and setting wait: false for fire-and-forget. Also mentions alternative tool openfinance_get_item_status for timed_out cases.

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

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

The description richly details edge cases: CREDIT accounts returning warnings instead of errors, and degradation to last-synced balance with realtime: false under upstream failures. This goes well beyond annotations like readOnlyHint.

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

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

The description is dense and well-structured, front-loading the primary action and method, then detailing error handling and response format. Every sentence adds value without repetition.

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 response shape and error conditions. It covers all necessary information for an agent to understand tool behavior and handle outcomes correctly.

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

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

With 0% schema description coverage, the description adds that account_ids is an array of strings with a 1–50 length constraint. This is useful but could be more explicit about the parameter's role.

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 'Returns real-time balance payload per account id' and specifies the endpoint. It distinguishes from sibling tools like openfinance_list_accounts by focusing on balance retrieval for specific 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 does not explicitly state when to use this tool over alternatives. It implies usage for real-time balance queries and provides constraints on input size, but lacks guidance on when not to use or trade-offs.

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 batch shape with results/errors, provider_incident block causing unreliable data, and advises against presenting values during incidents. Annotations confirm readOnlyHint, idempotentHint, non-destructive; no contradictions.

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

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

Description is concise with three sentences covering purpose, usage, and warning. Could front-load the core purpose more, but no wasted words.

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

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

No output schema, but description explains return shape (results/errors/provider_incident). Covers key behavioral aspects and edge cases. Complete for a single-param 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?

Only parameter account_ids explained as array (1-50) with batch behavior. Since schema coverage is 0%, description compensates by adding size limit and implied per-item result structure.

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

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

Description clearly states it returns full account objects including extended creditData per id, with batch shape. Distinguishes from siblings like list_accounts which likely returns summaries without extended 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?

Specifies to pass account_ids as an array (1-50) and warns about provider_incident. Could explicitly contrast with list_accounts for when to use this tool vs others, but usage 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. The description adds further behavioral details: batch return shape { results, errors }, absence of paid/status field from Pluggy, and nuanced interpretation of payments array. 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 detailed but efficient; every sentence adds value. It is front-loaded with the core functionality. Slightly verbose but no filler, thus well-structured for an agent.

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 output (financeCharges, payments fields) and addresses important caveats like paid status and billId hints. Some details on financeCharges structure are missing, but overall complete for safe invocation.

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

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

The input schema has 0% coverage, so the description must compensate. It explains that bill_ids should be an array of IDs discovered via openfinance_list_credit_card_bills, and mentions the batch output shape. This adds meaning, though it could specify ID format or constraints.

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

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

The description clearly states the verb and resource: 'Returns bill-level detail for one or more credit card bills by id'. It explicitly distinguishes itself from sibling tools by specifying what it does NOT return (individual transactions) and directing to openfinance_list_transactions for that purpose.

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

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

The description provides explicit when-to-use and when-not-to-use guidance, including prerequisites (discover IDs via openfinance_list_credit_card_bills), exclusions (not for transactions), and alternatives (openfinance_list_transactions). It also warns about semantic pitfalls like payments belonging to previous bills and sparse billId hints.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds valuable details: the reconnect_url reopens the widget in UPDATE mode without disconnecting or consuming a slot. No contradictions.

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

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

The description is concise with two paragraphs, front-loading key return values. Every sentence adds information, though slightly more structured formatting could improve readability.

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

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

Given no output schema, the description explains the return structure for single and bulk requests, and covers the reconnect_url behavior. It lacks details on error conditions or prerequisites, but overall covers the essential 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?

With schema description coverage at 0%, the description compensates by explaining that `item` is for a single bank, omitting it returns all banks, and `item_ids` supports bulk. However, it does not clarify the difference between `item` and `item_id`, leaving slight ambiguity.

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

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

The description clearly states it returns the current status of a bank connection, listing specific output fields (status, executionStatus, connector metadata, reconnect_url). It distinguishes between single bank and all banks usage, making the purpose unambiguous.

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

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

The description explains when to omit or include the `item` parameter for single vs. bulk queries, and mentions bulk support with `item_ids`. It provides clear context but does not explicitly compare to sibling tools or 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 already declare readOnly, idempotent, not destructive. Description adds batch shape with results/errors, array size constraint (1-50). This provides useful behavioral context beyond annotations. No contradictions.

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

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

Description is compact with two sentences. First sentence states purpose and lists key fields; second provides usage guidance and input constraints. No wasted words.

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

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

Given no output schema, description enumerates many returned fields (interestRates, warranties, etc.) and specifies batch shape. Lacks details on field semantics (e.g., CET, ipocCode) but adequate for a detail retrieval tool with 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?

Schema coverage is 0% so description must compensate. Description adds that loan_ids is an array (1-50) and the field name implies loan IDs, but no format or example given. Baseline 4 for 0 params not applicable since one param exists; compensation is partial.

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 explicitly states 'Returns full loan contract detail by id' and lists specific fields like interestRates, warranties, installments. Clearly distinguishes from sibling openfinance_list_loans with 'Use after openfinance_list_loans to deep-dive on a specific contract'.

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: 'Use after openfinance_list_loans to deep-dive on a specific contract'. Implicitly indicates when to use, but does not explicitly state when not to use or mention alternatives for other detail tools.

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

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

Annotations already indicate read-only, idempotent, non-destructive. Description adds critical behavioral details: connector-dependent credit balance meaning, provider_incident block affecting reliability, identity_notice for deduplication, and batch support via item_ids.

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?

Long but each sentence adds value; front-loaded with purpose, followed by detailed usage nuances. Could trim minor redundancy but remains efficient for the complexity.

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

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

Given no output schema, multiple edge cases (provider incidents, identity notices, connector-dependent balances), and cross-referencing other tools, the description is comprehensive and leaves no major 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?

Despite 0% schema coverage, description explains 'item' (omit vs. pass), 'type' (implicit via enum), and 'item_ids' (bulk support). 'item_id' is implied but not explicitly described; still adds significant meaning beyond the bare schema.

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

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

The description clearly states the tool returns accounts for bank connections with specific fields (balance, number, type, etc.) and distinguishes it from sibling tools like openfinance_list_credit_card_bills for 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?

Provides explicit guidance: omitting 'item' lists all accounts, passing 'item' targets a single bank; warns against using credit card balance as 'this month's bill' and suggests alternative tool; explains provider incidents and identity notices.

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 value by specifying that the result is cached for the session and a single aggregated response without batch ids, going beyond what annotations provide.

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

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

The description is concise (3 sentences) and front-loaded with the main purpose. Every sentence adds value: purpose, caching, and output structure.

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?

Although there is no output schema, the description details the fields in each entry (id, description, etc.) and mentions caching and session scope. For a read-only taxonomy tool, this is fairly complete, but could mention if there are any limitations or pagination.

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 (schema coverage 100%), so the baseline is 4. The description does not need to add parameter info, and it doesn't, but it compensates by explaining the output fields clearly.

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 Pluggy's transaction category taxonomy, cached for the adapter session. It distinguishes itself from sibling tools like openfinance_list_transactions by focusing on categories and mentions its use in updating transaction categories.

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

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

The description provides clear context on what the tool does and how its output is used (e.g., the `id` field is used for openfinance_update_transaction_category). It does not explicitly state when not to use it or alternatives, but the purpose is distinct enough among siblings.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds context: the reconnect_url reopens the widget in UPDATE mode for EXISTING connections and refreshes data in place without disconnecting. This goes beyond the annotations and provides actionable behavioral 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 a single paragraph that is clear and front-loaded with the main purpose. It contains no wasted sentences, but could be slightly more structured (e.g., bullet points for the returned fields). Nevertheless, it is efficient and informative.

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 zero parameters, no output schema, and low complexity, the description fully covers what the tool does, what it returns, and how the reconnect_url is used. It leaves no unanswered questions for 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 zero parameters, so schema description coverage is 100% automatically. The description adds significant meaning by explaining the output fields (connector_id, item_id, bank name, reconnect_url, add_connection_url) and their purposes. Per rules (0 params = baseline 4), the comprehensive context justifies an above-baseline score.

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 saved bank connections and lists specific fields (connector_id, item_id, bank name, URLs). It distinguishes itself from sibling tools like connect, disconnect, etc. by explaining the scope (listing only) and the special reconnect_url 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 provides explicit guidance on when to use the reconnect_url (for re-authentication, MFA connectors, LOGIN_ERROR, stale data) and notes that it does not consume a connection slot. This helps the agent decide when to use this list tool versus triggering reconnect via other means.

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 reveals critical behaviors: Pluggy lacks paid/status field, cycle logic for payment attribution, derived payment_status logic, open_bill availability with reasons (connector_exposes_no_pending, open_bill_not_published), and connector asymmetry. Fully discloses how the tool operates and its caveats.

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

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

The description is verbose and lacks clear structure (e.g., bullet points or sections). Important details are embedded in paragraphs, making it harder to scan quickly. However, it is front-loaded with the basic purpose, and every sentence adds value, so it is not padded.

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 (5 params, no output schema, nuanced domain), the description covers almost all aspects: returned fields, payment status derivation, open bill semantics, connector limitations, warnings, bulk support, and cross-account identification. Minor omissions: no pagination defaults or exact error responses, but overall highly complete.

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

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

With 0% schema description coverage, the description fully explains all five parameters: account_id (required), page, page_size, account_ids (bulk support), and include_open_bill with detailed semantics (what open_bill contains, confidence levels, availability false with reason). No extra meaning is needed beyond what the description provides.

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 key fields. It distinguishes from siblings like openfinance_get_credit_card_bill (singular bill) and openfinance_list_transactions (transactions, not bills). The verb 'list' and scope 'closed bills' are precise.

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 extensive when-to-use and when-not-to guidance: warns not to assume payment from payments[], explains derived payment_status, recommends openfinance_list_transactions for itemized charges, and specifies include_open_bill as opt-in. Explicitly mentions alternatives and limitations like connector asymmetry and bill_grouping_reliability.

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 significant behavioral context: data integrity cross-checks, mass zeroing detection, warning fields, and that zeros should not be treated as real balances. 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 informative but somewhat verbose. Key purpose is front-loaded. Each sentence adds value, but some details (like bulk support) could be more prominent. Still efficient for the complexity.

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

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

Given 6 parameters with no schema coverage and no output schema, the description should compensate with parameter guidance. It does not explain how to use item, page, type, etc., leaving significant gaps for an agent.

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

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

Schema coverage is 0%, meaning no parameters are described in the schema. The description does not mention any of the 6 parameters (item, page, type, item_id, item_ids, page_size), failing to add 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 returns investment portfolio for a connection, listing specific types (FIIs, stocks, ETFs, etc.) and fields. It distinguishes from sibling tools like openfinance_list_investment_transactions by focusing on portfolio summary.

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

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

The description indicates it's for connections with INVESTMENTS product enabled and explains error handling (returns warning on 403). However, it doesn't explicitly contrast with alternatives or 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 already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable context: the types of transactions returned, specific fields, and the ability to batch request via investment_ids. No contradictions with annotations.

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

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

The description is concise with two focused paragraphs. The first paragraph details purpose, transaction types, and output fields without unnecessary words. The second paragraph adds bulk support information succinctly.

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 4 parameters, no output schema, and no enumeration, the description covers the essential purpose, usage, and most parameters. It lists output fields partially, which helps. However, pagination behavior and output structure are not fully explained.

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 explain parameters. It explains investment_id (required) and investment_ids (bulk support), but page and page_size are not mentioned at all. This leaves two parameters undocumented.

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, TAX, etc.) and fields (quantity, value, netAmount, etc.). It distinguishes itself from sibling tools like openfinance_list_investments by noting it should be used after that tool to get the investment_id.

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

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

The description provides explicit context for when to use the tool: after openfinance_list_investments to obtain the investment_id. It also mentions bulk support. However, it does not explicitly state when not to use it or compare to other transaction listing tools like openfinance_list_transactions.

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

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

Annotations already provide readOnlyHint, destructiveHint, and idempotentHint. The description adds that multiple connections are queried sequentially with rate-limit spacing and returns `{ results, errors }` per connection, which provides 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?

Three sentences, front-loaded with the main action, and no redundant information. Each sentence adds essential value.

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

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

Given the simple parameter schema and presence of annotations, the description is largely complete. It explains the core behavior and return structure. Minor gap: it doesn't detail the exact format of `results` and `errors`, but the tool's purpose is clear enough for correct invocation.

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

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

The input schema only defines `items` as an array of strings with no further description (0% coverage). The description fully compensates by explaining that `items` are connection selectors (item_id uuid, connector_id, or connector_name) and what happens when omitted (lists all).

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 and specifies the endpoint (GET /loans). This distinguishes it from sibling tools like openfinance_list_accounts and openfinance_list_transactions.

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

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

The description explains when to pass `items` (for specific connections) and when to omit it (all linked banks). It also mentions sequential querying with rate-limit spacing. However, it does not explicitly state when not to use this tool or point to alternatives like openfinance_get_loan_detail for individual loans.

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 readOnlyHint=true and idempotentHint=true, and the description adds extensive behavioral context: credit card billId is a per-connector hint, sparse and inconsistent; pending vs posted behavior varies by connector; error handling returns error object instead of throwing; provider_incident block may appear; and bulk support with account_ids. 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 comprehensive but somewhat lengthy, with some redundancy (billId hint explained twice). However, it is front-loaded with the main purpose and each paragraph adds unique value. The structure could be slightly tighter, but it remains highly informative and well-organized.

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 8 parameters, no output schema, and many sibling tools, the description is remarkably complete. It covers the return format (account echo, transactions, provider_incident), error handling, pagination modes, coverage variations per bank, and integration with other tools. All critical context for correct invocation is present.

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

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

Schema description coverage is 0%, but the description fully compensates. It explains each parameter: from/to are ISO YYYY-MM-DD dates; search_queries is case- and accent-insensitive substring match with OR semantics; page and page_size control pagination (auto vs manual); detail has three levels (compact, rich, raw) with explanations; account_id and account_ids for bulk. It also notes the 5000 ceiling for search aggregations and token cost for detail levels.

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

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

The description clearly states it returns transactions for bank accounts (BANK or CREDIT types). It specifically differentiates itself from siblings by explaining that for CREDIT accounts, this is the only way to get itemized transactions, and it references openfinance_list_credit_card_bills for bill totals. The verb 'returns transactions' and resource specification are precise.

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 when-to-use and when-not-to-use guidance. It states to use openfinance_list_credit_card_bills for standardized open-bill totals, and openfinance_list_accounts for closing/due dates. It also details pagination auto vs manual modes, and advises to narrow date range if truncated:true. It warns against summing transactions by billId. All usage contexts are covered.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds substantial behavioral context beyond these: a cap of 5000 transactions per account with a 'truncated:true' flag, a 'provider_incident' block for incomplete data from Open Finance providers, and bulk support via 'item_ids'. 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 relatively long but well-structured. It front-loads the core purpose and usage, then details parameters and edge cases. Every sentence adds value, though some sections (like the granularity explanation) could be slightly more terse. Overall, it is appropriately sized for the tool's complexity.

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

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

Given the absence of an output schema and low schema coverage, the description compensates thoroughly. It explains the return structure (compact summary vs raw rows, fields like 'entradas', 'saídas', 'por_mes', 'top_despesas', 'by_account'), handling of truncation, provider incidents, and bulk execution. The tool is complex (9 parameters, multiple modes), and the description covers all necessary context for correct usage.

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

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

Schema description coverage is 0%, placing the burden on the description to explain parameters. The description does so comprehensively: 'item' accepts connector_id, connector_name, or item_id; 'from'/'to' are ISO dates; 'granularity' values ('monthly' vs 'raw') are explained; 'detail' values ('compact','rich','raw') are detailed with output differences; 'type' filters BANK or CREDIT; 'top_n' is implied as controlling 'top_despesas'/'top_recebimentos' counts. All nine parameters are effectively documented.

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: consolidated cash-flow analysis for a whole bank connection over a period, resolving accounts internally. It distinguishes itself from sibling tools by explicitly noting that users do not need to call openfinance_list_accounts first. The verb 'analyze' and resource 'transactions' are specific, and the scope (connection-level, with option to omit for all banks) 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 provides explicit usage scenarios (e.g., 'análise anual/mensal', 'fluxo de caixa') and explains when to set 'granularity' to 'raw'. It also clarifies that omitting 'item' analyzes all linked banks. However, it does not explicitly mention when not to use this tool versus its siblings, though the context implicitly differentiates it from other transaction- or account-related tools.

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

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

Annotations already declare readOnlyHint and idempotentHint, and the description adds context by explaining that the tool fetches data from a public status page, returns global indicators, degraded components, open incidents, and flags affected banks. 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 slightly longer but well-structured: first sentence states purpose, then usage scenario, then output details. It front-loads the main purpose and provides necessary context without unnecessary 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 no output schema, the description fully explains the return values: global indicator, degraded components, open incidents, and your_banks_affected. It also provides context for when to use and how it differs from related tools. Complete for a parameterless 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 (0 params, 100% schema coverage). The description does not need to add parameter information, and the baseline for zero parameters is 4. The description focuses on behavior and output, which is appropriate.

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

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

The description clearly states the tool checks the LIVE operational status of the Open Finance provider's public status page, using specific verbs and resources. It distinguishes itself from the sibling tool openfinance_get_item_status by explaining the difference between provider health and 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 when-to-use guidance: when data looks incomplete or stale despite a connection showing UPDATED, to differentiate provider-side problems from connection issues. It also describes the output that helps identify upstream outages and bank-specific incidents.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the tool is safe. The description adds behavioral details such as caveat warnings for non-Open-Finance connectors and plan-dependent filtering, enhancing transparency 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 dense and informative but somewhat lengthy at over 200 words. It front-loads the main purpose but could be more concise by splitting into paragraphs or reducing 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 tool's complexity (2 parameters, no output schema), the description covers return fields, plan behavior, caveats, and usage order. It is sufficient for an agent to invoke correctly, though an explicit output schema would further help.

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 carries full burden. It explains that keywords[] takes names like ['nubank','btg'] and is required, and include_accounts returns associated accounts. This adds meaningful context beyond the schema structure.

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 searches bank connectors by name and returns specific details like connector id, access type, audience, linked connections, and connect_url. It distinguishes itself from sibling tools like 'connect' by being a prerequisite search step.

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 instructs to call this BEFORE connecting and explains that keywords[] is required (effectively a required parameter). It also discusses plan behavior (PF vs PJ) and hints at preferring Open Finance connectors due to caveats. However, it does not explicitly list alternatives or when not to use.

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

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

The description goes beyond annotations by explaining the side effect of creating category rules that affect future categorization, and details batch behavior including per-item error handling. This provides rich 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 concise yet comprehensive, front-loading the purpose, then explaining side effects, then the return shape. Every sentence adds value 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?

The description is complete given no output schema: it explains return shape, error handling, and side effects. It covers all necessary context for correct invocation.

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

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

Despite 0% schema description coverage, the description fully explains the 'items' parameter structure, required fields (transaction_id, category_id), and their sources (from list transactions and list categories). It adds significant meaning beyond the schema.

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

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

The description clearly states the tool corrects transaction categories via PATCH /transactions/:id. It specifies the batch operation and distinguishes from sibling tools like openfinance_list_transactions and openfinance_list_categories by naming them as data sources.

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

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

The description explains when to use the tool (to fix miscategorized transactions) and provides context on sourcing IDs from other tools. It does not explicitly state when not to use, but the usage is clear enough.

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 'Report a bug', implying a write operation, which aligns with readOnlyHint=false. It does not add significant behavioral context beyond the annotations, but also does not contradict them.

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

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

The description is only two sentences: the first defines the purpose, the second provides a key usage tip. No unnecessary words, 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?

Given the three parameters and no output schema, the description covers the main usage pattern. It could mention expected behavior (e.g., no confirmation, async) but overall is adequate 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?

Schema coverage is 0%, so the description must add meaning. It explains the 'conversation' parameter ('Include the conversation array with recent messages for reproduction') but does not clarify 'message' or 'context'. This partial coverage is helpful but incomplete.

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 reports a bug, missing feature, or feedback. It uses a specific verb ('Report') and resource types. While it does not distinguish from siblings because no other sibling offers similar functionality, it is still specific enough.

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: 'Include the conversation array with recent messages for reproduction.' This tells when to use the conversation parameter. However, it does not mention when not to use the tool or provide alternatives, which is acceptable given the unique purpose of this tool among siblings.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint. The description adds no behavioral context beyond what annotations declare. With annotations present, a score of 3 is appropriate as the description does not mislead but adds no extra 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?

The description is a single, concise sentence that front-loads the purpose with no unnecessary words.

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

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

Given the tool's simplicity, zero parameters, no output schema, and safety annotations, the description is complete and sufficient for an agent to understand and invoke it 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 tool has zero parameters, so the description need not add parameter information. Baseline is 4, and the description is adequate.

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 function: showing MCP platform and adapter versions. It is a specific verb+resource that distinguishes it from sibling tools which are mostly financial or connection 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 gives clear context (showing version info), but does not explicitly state when to use it over alternatives. However, given its simplicity and uniqueness among siblings, 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, and destructiveHint=false, so the safe read-only behavior is covered. The description adds useful context about what 'state' includes but does not go deeper into potential behavioral traits like latency or data freshness.

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?

One well-structured sentence communicates the core purpose and the specific output categories without waste. It is front-loaded and every clause adds 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?

With no output schema, the description carries the full burden of explaining the return value, and it does so by listing the key dimensions: installed MCPs, connection status, connected accounts, and catalog tool counts. For a zero-parameter info tool, this is complete and unambiguous.

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

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

The tool has zero parameters, and the schema confirms an empty input object. The description appropriately avoids parameter details, and no further semantics are 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?

The description uses a specific verb ('Returns') and a clear resource ('current toolkit state') while enumerating exactly what is included. This makes it easy to distinguish from sibling tools like show_version or the individual openfinance_* 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 context is clear: use this tool when you need an overview of installed MCPs, connection status, and connected accounts. It does not explicitly mention alternatives or exclusions, but its purpose is distinct enough from sibling tools.

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