Porto Bank MCP

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

The description discloses the two modes of operation (with or without token) and how the token is used. Annotations are minimal, and the description adds value by explaining the permanent vs session behavior, without contradicting the idempotent hint.

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 every sentence is informative. It is front-loaded with the primary use case and structured logically. A minor trim could improve conciseness.

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

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

Given the simple structure (one optional param, no output schema), the description covers the essential use cases. It could be more explicit about the return value format, but overall it provides enough context for an agent to use the tool correctly.

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

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

With 0% schema coverage, the description fully compensates by explaining the optional 'token' parameter: calling with a token logs in for the session, and without token returns a login link. This adds complete semantic meaning.

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

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

The description clearly states the tool is for authentication, explaining the login process and token usage. It is specific about the resource and action, and distinctly separates it from the unrelated sibling tools.

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

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

The description provides clear usage scenarios: permanent configuration vs session-only login. While it does not explicitly compare with siblings, the context is sufficient for an agent to understand when to use this 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 declare the tool as read-only, idempotent, and non-destructive. The description adds value by detailing the two possible response states (authenticated:true with empty pending[] vs connect_url). This extra context enriches the agent's understanding of behavior.

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 succinct with two sentences, front-loading the main purpose. Every sentence provides necessary information without redundancy or fluff.

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

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

Given the tool's simplicity (0 parameters, no output schema), the description adequately explains the output states. However, it could briefly mention that the tool is a quick status check, possibly helpful for agents deciding whether to proceed with other actions.

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, so baseline is 4. Schema coverage is 100% (no params), so the description doesn't need to add parameter information. The description is sufficient for parameter understanding.

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 different output formats for fully connected vs missing credentials. It uses a specific verb and resource, effectively distinguishing its purpose from siblings like authenticate or list_connections.

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

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

The description implies the tool is used to check connection status but does not explicitly state when to use it over alternatives like authenticate for initiating connections or list_connections for detailed listings. It lacks when-not-to-use 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?

Reveals key behaviors: invoke works for uninstalled MCPs, returns connect/checkout links for auth/payment, and requires owner/admin for writes. Annotations (readOnlyHint:false) are consistent; 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 informative but verbose. It front-loads the core purpose and flow, but includes extensive detail that could be streamlined. Still well-organized 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 (13 parameters, multiple actions, no output schema), the description covers the essential flow and responsibilities. Lacks explicit return value or error handling details, but suffices for a marketplace orchestrator.

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%, and the description does not detail the meaning of each of the 13 parameters. While it explains the action enum and some parameters like query, mcp_id, tool_id, it lacks comprehensive per-parameter guidance.

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' and the primary tool for discovering and running MCPs. It positions itself first before external registries, distinguishing it from sibling tools like openfinance tools.

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

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

Explicitly instructs to use this tool first for capabilities, explains when to use invoke vs install, and notes that writes require workspace owner/admin. Provides clear flow: search → describe → invoke.

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 mark destructiveHint true; description adds specifics (data deletion, return of re-connect URL) 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?

Two concise sentences with front-loaded action and consequence, no wasted words.

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

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

Covers purpose and outcome well, but lacks explanation of the required 'item' parameter, leaving ambiguity 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?

Single 'item' parameter is unexplained despite 0% schema description coverage; description fails to clarify what value identifies the bank.

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

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

The description clearly states it revokes consent and deletes connection data for a specific bank, distinguishing it from sibling tools like connect or openfinance_force_sync.

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

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

The description explains the result (data unavailable, re-connect URL) but does not explicitly state when not to use or mention alternatives like list_connections first.

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

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

Discloses behavioral traits beyond annotations: waits up to 60s, polls until done, returns final status and error states (needs_action, timed_out). Also explains the underlying PATCH and poll mechanism.

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?

Despite length, every sentence adds value. Structured with main action first, then usage, parameters, return, and follow-up. No redundancy.

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

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

Complete for a tool with 2 simple params and no output schema. Covers parameters, behavior, return object fields, error handling, and timeout scenario with sibling tool reference.

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

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

Adds full meaning to both parameters: 'wait' explained as synchronous vs fire-and-forget; 'items' explained as array of selectors (item_id, connector_id, connector_name) with omission syncing all. This compensates for 0% schema coverage.

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

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

The description clearly states it forces a bank to re-sync and waits, using specific verbs like 'forces' and 're-sync'. It distinguishes from sibling tools by explaining it does not disconnect/reconnect and is used when data looks stale.

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 usage guidance is provided: 'Use this when a balance or transaction list looks stale'. It also advises against disconnecting/reconnecting, explains how to sync all or specific items, and mentions setting wait:false for fire-and-forget.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral details: credit accounts may return a warning instead of throwing an error, and the response shape includes an errors array. This exceeds 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?

Three sentences cover all essential information: purpose, usage, edge case, and response shape. No wasted words. The description is front-loaded with the most critical information.

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

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

Given the tool's simplicity (1 parameter, no output schema), the description fully covers purpose, parameter constraints, error handling, and response format. It is 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?

The schema has 0% description coverage, so the description carries the full burden. It explains the single parameter account_ids and adds an array size constraint (1–50), which is not in the schema. This adds significant meaning beyond the raw 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 'Returns real-time balance payload per account id' and specifies the REST endpoint, making the tool's purpose immediately obvious. It distinguishes from siblings like openfinance_list_accounts or openfinance_get_accounts_detail by focusing on balance retrieval.

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

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

The description specifies that account_ids must be passed as an array with a size limit (1–50) and mentions handling of credit accounts. It does not explicitly state when to use or not use this tool compared to alternatives, but the context 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 indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable behavioral context: the batch response shape `{ results, errors }`, inclusion of a `provider_incident` block, and warning about unreliable credit limits/balances during provider incidents. 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 concise: two sentences with clear structure. First sentence states purpose and batch shape. Second sentence adds critical caveat. No redundant information; 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 single-parameter read-only tool with no output schema, the description is complete. It explains the return format (full account objects, batch shape), error handling (`errors`), and exceptional conditions (provider_incident). The caution about reliability is essential 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 has one required parameter 'account_ids' (array of strings) with 0% description coverage. The description adds semantics: 'Pass `account_ids` as an array (1–50)', specifying the allowed count range and how to pass it. It also explains that the tool returns data per ID, compensating fully for the missing schema descriptions.

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

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

The description clearly states the tool returns 'full account objects including extended creditData' per ID, distinguishing it from sibling tools like openfinance_list_accounts (which likely returns summaries) and openfinance_get_account_balance (which returns only balance). The verb 'Returns' and specific resource 'full account objects' provide clear 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 specifies when to use: to get detailed account data by ID, with a batch of 1-50 account_ids. It includes a critical usage caution about provider_incident blocks, advising not to present unreliable values as real. While it does not explicitly name alternatives, the purpose implies when not to use (e.g., for summaries).

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint = false. Description adds critical behavioral detail: batch shape { results, errors }, fields structure, warning that payments may reflect previous bill, and that Pluggy lacks paid/status field. 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?

Description is fairly long but every sentence adds necessary context. Front-loaded with main purpose and key details. Could be slightly more concise but remains efficient within the complexity required.

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, description thoroughly explains return shape { results, errors }, lists contained fields (financeCharges, payments[].id, date, amount, valueType, paymentMode), and addresses edge cases like payments interpretation and paid status. Fully equips an agent to use and understand 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?

Schema only defines bill_ids as array of strings with 0% description coverage. Description adds meaning: instructs to pass as array, advises to discover ids via openfinance_list_credit_card_bills first. This compensates well for missing schema parameter 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?

Description explicitly states it returns bill-level detail for credit card bills by ID, lists returned fields (financeCharges, payments), and clarifies what it does NOT return (non-itemized transactions). It distinguishes from sibling tool openfinance_list_transactions for transaction 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?

Clearly advises when to use this tool (get bill detail) and when not (itemized transactions → use openfinance_list_transactions). Gives prerequisite: first use openfinance_list_credit_card_bills to discover ids. Provides important caveats about payments array and paid status, directing to alternative tool for payment status.

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

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

Annotations already declare readOnly, idempotent, and non-destructive hints. The description adds value by detailing the returned fields (status, executionStatus, connector metadata) and the shape of the response for the all-banks case (`{ count, items }`). It does not mention edge cases like invalid `item` values or rate limits, but these are less critical given 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 two sentences, each packed with essential information. No unnecessary words, and the most important detail (dual mode) is front-loaded. 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 read-only tool with one optional parameter and no output schema, the description is complete. It explains the purpose, parameter usage, return types, and differentiates behavior. No gaps are evident.

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 a single parameter `item` with 0% description coverage. The description fully compensates by explaining that omitting `item` returns all bank statuses and passing a specific `item` returns that bank's status, adding meaning that the schema alone does not convey.

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 the status of bank connections, enumerates example status values, and explains two modes of operation (all vs. single). It distinguishes itself by specifying the exact return fields and the behavior difference with and without the `item` parameter.

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 omit vs. pass the `item` parameter, but does not explicitly contrast with sibling tools like `openfinance_list_connections` which may also list connection statuses. It gives usage context for its own two use 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?

Adds context beyond annotations by describing the batch shape ({ results, errors }) and listing returned fields. Annotations already indicate safe read operations, and the description complements 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 well-structured with front-loaded purpose and a clear list of fields, but it is slightly verbose; could be tightened without losing information.

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

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

For a tool with no output schema, the description covers many return fields and the batch response shape, but lacks explicit error cases or type details for each field. Still reasonably 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 coverage is 0%, but the description explains the parameter 'loan_ids' (array, 1-50 items), adding meaning beyond the raw schema which only defines type and required status.

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 full loan contract detail by ID and lists specific fields (interestRates, charges, etc.), distinguishing it from the sibling tool openfinance_list_loans which is used for listing.

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?

Directly advises to use after openfinance_list_loans for deep-diving, and specifies that loan_ids should be an array of 1-50 items, providing clear context for when and how 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?

Disclosure about potential 'provider_incident' block and its implications for unreliable balances/limits. Explains the connector-dependent meaning of credit balance. Annotations already indicate read-only, idempotent, non-destructive; description adds critical behavioral context.

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

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

The description is fairly detailed but well-organized, with each paragraph covering a distinct aspect. Could be slightly more concise, but no unnecessary information.

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

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

Given the absence of output schema, the description thoroughly covers return fields, behavior for different input scenarios, edge cases like provider incidents, and clarifies credit balance semantics. It equips the agent to understand and use the tool correctly.

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

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

The description explains the 'item' parameter in detail (omit vs pass) but does not explicitly describe the 'type' enum parameter (though its purpose is implied). With 0% schema description coverage, the description compensates partially but could be more explicit about the 'type' filter.

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 types (BANK, CREDIT) and lists key fields. It distinguishes itself from sibling tools like openfinance_list_credit_card_bills by mentioning that tool's purpose 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 on when to omit 'item' to list all linked banks versus passing 'item' for a single bank. Also warns about the credit balance interpretation and directs to openfinance_list_credit_card_bills for standardized billing 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 readOnlyHint, idempotentHint, and destructiveHint as true, false, and false respectively. The description adds behavioral details beyond annotations: it is 'cached for the adapter session' (fast, consistent), and the response format is fully described (id, description, descriptionTranslated, parentId, parentDescription). No contradictions with annotations.

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

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

The description is a single dense paragraph that efficiently conveys all necessary information: main purpose, caching, response structure, and cross-reference to another tool. Every sentence adds value, and there is no redundancy or unnecessary detail.

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

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

Despite having no output schema, the description fully documents the return values: id, description, descriptionTranslated, parentId, and parentDescription. It also explains the caching behavior and that it is a single aggregated response. This is complete for a simple list-without-pagination tool, and it explicitly ties to sibling tools where relevant.

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 input schema is empty with 100% coverage. The baseline score for zero parameters is 4. The description does not need to add parameter semantics, but it adds value by explaining the response fields and caching behavior, which indirectly aids parameter understanding (none 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 clearly states it returns 'Pluggy's transaction category taxonomy' and explicitly mentions the endpoint GET /categories. It distinguishes itself from sibling list tools by specifying that the returned id is used by openfinance_update_transaction_category, and the response includes parent-child structure, setting it apart as a taxonomy listing tool.

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

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

The description provides clear context: it is a cached single-response call, no batch ids. However, it does not explicitly state when to use this tool vs. alternatives like fetching individual categories from other endpoints, nor does it mention when not to use it. The connection to openfinance_update_transaction_category is hinted but not fully elaborated.

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, so safety profile is clear. Description adds value by mentioning the add_connection_url for linking banks, but does not disclose potential prerequisites like authentication status.

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

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

Single sentence, no redundancy, front-loaded with purpose. Every word 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 simple list tool with no parameters, good annotations, and no output schema, the description provides sufficient detail on return values. Could be slightly improved by noting it lists connections for the current install, but overall complete.

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

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

No parameters exist (0 params, 100% schema coverage), so the baseline is 4. Description adds meaning by listing return fields, which is adequate for a parameterless 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?

Description clearly states it returns saved bank connections and lists specific fields (connector_id, item_id, bank name, add_connection_url). It distinguishes from sibling tools like openfinance_list_accounts or openfinance_list_transactions by focusing on connections.

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

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

No explicit guidance on when to use this tool vs alternatives like openfinance_list_accounts or openfinance_get_item_status. The description only states what it does, not the appropriate context or exclusions.

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

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

Annotations show readOnlyHint true, idempotentHint true, destructiveHint false. The description goes far beyond, explaining complex behaviors like payment assignment across bills, connector asymmetry, derivation of payment_status and open_bill, and the PAST_DUE_UNCONFIRMED status. 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 long but structured with clear sections (IMPORTANT, OPEN BILL & TOTAL DEBT, CONNECTOR ASYMMETRY). Every sentence adds necessary context due to the complexity of the domain. Slightly verbose 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 no output schema and complex domain, the description is fully self-contained. It details all output fields, derived statuses, connector limitations, and cross-tool references (openfinance_list_transactions). Provides warnings and fallback behavior.

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

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

Schema description coverage is 0%, so description must compensate. It explains account_id, include_open_bill (including default and when to opt-in), and bulk support via account_ids. However, page and page_size are not described, though their usage is implied. Still adds significant value over 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 closed credit card bills for a CREDIT-type account, listing specific fields and distinguishing from sibling tools like openfinance_list_transactions for itemized purchases. It also mentions bulk support and opt-in open bill, making the purpose highly specific.

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 guidance on when to use, including Brazilian Open Finance semantics, derived payment_status logic, and when to use include_open_bill. It also warns about not assuming payment from payments array and directs to 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, establishing safe read-only behavior. The description adds value by disclosing specific error handling: returns {total:0, results:[], warning} instead of throwing on 403 or upstream errors. It also lists returned fields (balance, amount, rates, etc.), which provides operational 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 moderately concise, front-loading the core purpose in the first sentence. It lists asset types and key fields efficiently. While it could be slightly more compressed, it earns its length by providing useful details. No unnecessary filler.

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

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

Given the tool has 4 parameters and no output schema, the description adequately covers the output shape (including error fallback) but fails to document parameters. This leaves a significant gap for agent understanding. The description is sufficient for basic use but incomplete for parameterized queries.

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

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

Schema description coverage is 0% (no parameter descriptions in JSON schema). The description does not explain any of the four parameters (item, page, type, page_size). Since it carries the full burden for param semantics, the lack of any explanation leaves the agent without guidance on how to use these parameters effectively.

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 investment portfolio for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.). The verb 'Returns' and resource 'investment portfolio' are precise. The description implicitly distinguishes from siblings like openfinance_list_investment_transactions (transactions vs portfolio) and openfinance_list_accounts, 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 implies usage when you need investment portfolio data for a connection with INVESTMENTS enabled. It explains the error handling fallback, suggesting when to rely on the tool. However, it does not explicitly state when not to use this tool or provide alternatives (e.g., for transaction-level data, use openfinance_list_investment_transactions). The guidance is functional but lacks 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 already declare readOnlyHint, idempotentHint, destructiveHint. The description adds value by detailing the types of transactions returned, fields (quantity, value, netAmount, expenses breakdown), and bulk support. It does not contradict annotations. However, it omits behavior for pagination parameters (page/page_size) and any rate limits or 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 concise with two short paragraphs. The first paragraph front-loads the purpose and output fields. The second paragraph adds bulk support. Every sentence adds meaningful information 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 tool has 4 parameters, including pagination, no output schema, but good annotations. The description covers the return fields and prerequisites but fails to explain pagination behavior or bulk execution details (e.g., limits, response structure). This leaves gaps for an agent to use the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It only mentions 'investment_id' implicitly in the usage note and 'investment_ids' in bulk support. It does not describe page, page_size, or provide any formats, constraints, or defaults for any parameter. This is insufficient given 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 'movement history for a specific investment position' with a list of transaction types (BUY/SELL/TAX/INTEREST/AMORTIZATION/TRANSFER). It distinguishes itself from siblings by specifying it's for a specific investment, and explicitly references openfinance_list_investments for obtaining the investment_id, which differentiates it from general transaction listing tools.

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

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

The description provides a clear prerequisite: 'Use after openfinance_list_investments to get the investment_id.' It also mentions bulk support with 'investment_ids'. However, it does not explicitly contrast with similar tools like openfinance_list_transactions or provide when-not-to-use 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 indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds behavioral details: sequential querying with rate-limit spacing and the per-connection result structure. 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?

Three sentences, no filler, front-loaded with purpose. 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?

For a tool with one optional parameter, no output schema, and safe annotations, the description fully covers purpose, parameter semantics, usage behavior, and result structure. 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 0% description coverage, but description explains `items` is an array of connection selectors (item_id uuid, connector_id, or connector_name) and the effect of omitting it. Adds significant meaning beyond schema.

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

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

The description clearly states it lists loan contracts per bank connection via GET /loans. It distinguishes from siblings by detailing how to specify connections with the `items` parameter or omit for all banks, and mentions the return format.

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

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

Provides explicit guidance on when to pass `items` (specific connections) vs omit (all banks), and notes sequential querying with rate-limit spacing. Lack of explicit when-not-to-use or alternatives is acceptable given no sibling loan 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?

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description details auto-pagination, 5000 ceiling, truncation warning, error handling (returns object with warning/error), detail levels with token cost and coverage variance, and provider incident block. 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 lengthy but well-structured with clear section headers and front-loaded purpose. While dense, the detail is justified by the tool's complexity. Could be slightly trimmed but remains 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 8 parameters, no schema descriptions, no output schema, and complexity in pagination, detail levels, and CREDIT-specific behaviors, the description covers all aspects: parameter semantics, edge cases, error handling, integration with other tools, and bulk support. Nothing seems missing.

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: from/to (ISO dates), page (auto vs manual), page_size (max 500), detail (enum meanings), search_queries (case-insensitive substring, OR semantics, pre-filter aggregation), account_ids (bulk support). Provides constraints and use cases beyond field names.

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 transactions for a bank account (BANK or CREDIT type)' and distinguishes from sibling tools like openfinance_list_credit_card_bills and openfinance_list_accounts by specifying exact use cases for each.

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 and when-not-to-use guidance: for CREDIT accounts it's the only way to get itemized transactions; directs to openfinance_list_credit_card_bills for bill totals, openfinance_list_accounts for statement dates, and openfinance_get_item_status for connection health. Also explains when to narrow date ranges due to truncation.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description reveals critical behaviors: internal account resolution and fan-out, truncation at 5000/account with a `truncated:true` flag, provider_incident block details, and the distinction between summary and raw modes. This adds significant context beyond the structural hints.

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

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

The description is front-loaded with the core purpose and key benefit, then systematically covers parameters, defaults, use cases, and warnings. Every sentence adds essential information without redundancy, maintaining a clear structure that aids quick comprehension.

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

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

For a tool with 7 parameters and no output schema, the description is remarkably complete. It explains the return structure (total entradas, saídas, por_mes, top despesas, by_account), invocation patterns, and error conditions like provider incidents. It leaves no significant 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 explains each parameter: the `item` parameter can be connector_id/connector_name/item_id or omitted; `from`/`to` are ISO dates; `granularity` defaults to 'monthly' for a compact summary vs. 'raw'; `detail` offers 'compact', 'rich', or 'raw' levels; `type` filters BANK or CREDIT; and `top_n` is implied via 'largest N each'. This far exceeds what the schema 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 the tool's purpose: 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call.' It uses specific verbs and resources, and distinguishes from siblings by noting it eliminates the need to call openfinance_list_accounts first, targeting either a single bank or all linked banks.

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 and how to use the tool: 'Pass `item` to target one bank, or OMIT it to analyze ALL linked banks.' It also explains when not to use other tools ('you do NOT need to call openfinance_list_accounts first') and describes parameter behavior, defaults, and caveats like truncation and provider incidents.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the agent knows it's a safe, non-destructive operation. The description adds value by detailing the real-time behavior (live check) and the specific data returned (global indicator, degraded components, open incidents, affected banks), 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, front-loaded with the purpose, followed by usage guidelines and return details. Every sentence is purposeful 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?

Given no output schema, the description fully explains the return values (global indicator, degraded components, open incidents, affected banks) and the usage context. It also distinguishes from a sibling, making it complete for agent understanding.

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 (0 parameters, 100% schema coverage), so baseline is 4. The description does not need to add parameter info and correctly focuses on usage and output.

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, uses a specific verb ('checks'), identifies the resource ('provider's health'), and explicitly distinguishes it from the sibling tool 'openfinance_get_item_status' which checks connection status.

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

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

The description provides explicit guidance on when to use (when data looks incomplete/stale despite an updated connection) and what it reveals (upstream outage vs connection issue). It also names the alternative tool 'openfinance_get_item_status' for when to not use this tool.

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

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

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description discloses the caveat warning about non-Open-Finance connectors needing manual reconnection, that the tool honors the user's plan (PF hides PJ banks), and that missing keywords returns a hint instead of dumping the catalog.

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 packed with information but remains readable. It front-loads the core purpose and then adds context. A couple of sentences could be slightly tightened, but overall efficient for the detail provided.

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

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

With no output schema, the description thoroughly explains the return values (connector id, access, audience, linked connections, connect_url, caveat). It also covers edge cases (keyword omission, plan enforcement). This is comprehensive for a search tool.

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

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

Despite 0% schema description coverage, the description explains keywords[] with an example and states it's REQUIRED (though schema marks 0 required), and describes the effect of include_accounts. This adds meaning beyond the raw parameter names.

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, returning specific fields (id, access, audience, connections, connect_url) and caveat warnings. It distinguishes itself from siblings like 'connect' and 'authenticate' by being a search/preparation 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 explicitly says 'Call this BEFORE connecting' and emphasizes that keywords[] is REQUIRED. It provides context on when to prefer Open Finance connectors over credential ones, but doesn't explicitly list contraindications for 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 reveals important behavioral traits beyond annotations: that the call overrides automatic categorization, creates a Category Rule for future similarity, and returns batch results with detailed error handling. No contradiction with annotations (readOnlyHint=false, destructiveHint=false).

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

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

The description is a single paragraph with all essential information, front-loaded with the main purpose. It is effective but a bit dense; breaking into sections would improve readability without losing information.

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

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

Given the tool's complexity (batch mutation with side effects and no output schema), the description covers input format, ID sources, automatic rule creation, batch error behavior, and output shape. It is complete and leaves no critical questions unanswered.

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

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

With 0% schema description coverage, the description fully compensates by explaining the required fields (transaction_id, category_id) and their provenance. It could be more structured (e.g., bullet points) but adds clear 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 read tools like openfinance_list_transactions and openfinance_list_categories.

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

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

The description provides explicit guidance on how to construct the `items` array, which IDs to use from which sibling tools, explains the side effect of creating a Category Rule, and clarifies that per-item errors do not fail the batch. It tells when to use this tool (to fix miscategorized transactions) and what the outcome will be.

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 idempotent and not destructive. Description adds that it sends feedback with conversation for reproduction, but doesn't explain response or side effects beyond submission. Moderate transparency.

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

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

Single sentence, concise and front-loaded with purpose. Slightly more detail on parameters could improve without losing conciseness.

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

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

Given 3 parameters and no output schema, description covers main usage but misses parameter explanations and post-submission behavior. Adequate but with clear gaps.

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

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

Schema coverage is 0%. Only 'conversation' is partially described as needing recent messages. 'message' and 'context' are not explained. Inadequate compensation for zero 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 it reports bugs, missing features, or feedback. Among sibling tools focused on openfinance operations and connectivity, this is uniquely for user feedback, so it distinguishes well.

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

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

Explicitly instructs to include the conversation array for reproduction. No alternatives exist among siblings, so no need for when-not-to-use. Provides clear context for usage.

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

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

Annotations already indicate readOnlyHint=true and idempotentHint=true, covering safety. The description adds context that the tool shows versions, but does not disclose more detailed behavior like output format or network usage. Still, it's adequate for a simple read operation.

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

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

Single sentence, no waste. Perfectly concise and front-loaded.

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

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

Given no parameters and no output schema, the description is largely complete. It could mention the shape of the output, but the core purpose is clear. For a version-check tool, this is 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?

The tool has no parameters and schema coverage is 100%. The description does not need to add parameter information. Score baseline 4 for zero 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 shows current MCP platform and adapter versions, which is specific and distinguishable from sibling tools that focus on authentication, finance operations, or other functionalities.

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

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

No explicit guidance on when to use this tool versus alternatives, but given its simplicity and unique purpose, the usage is implied. There are no exclusion criteria mentioned.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, covering common behavioral traits. The description adds value by specifying exactly what information is returned (installed MCPs, connection status, catalog count), providing context beyond the annotations.

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

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

The description is a single clear sentence with no wasted words. It is concise and front-loaded with the key information.

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

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

Given no output schema, the description sufficiently covers the return value by listing three specific components of the toolkit state. It is complete for an information-retrieval tool with no parameters.

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

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

The tool has no parameters, so the description cannot add parameter detail. However, with 0 parameters and 100% schema coverage, the description is not required to compensate. Baseline score of 4 is appropriate.

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

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

The description clearly states the tool returns the current toolkit state, listing specific elements (installed MCPs, connection status, catalog count). It uses a specific verb ('Returns') and resource ('current toolkit state'), and it distinguishes itself from sibling tools, which are action-oriented (e.g., authenticate, openfinance_*).

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

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

The description implies usage context (checking toolkit state) and is self-explanatory. However, it does not explicitly state when to use this tool over alternatives. Given the tool's nature and sibling tools, the context is clear enough for an agent to decide.

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