Neon MCP

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

Annotations indicate idempotentHint=true, and the description aligns by describing token submission as idempotent. It explains the two modes (permanent vs session) and that calling without args returns a link, adding 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?

Description is slightly verbose but well-structured: starts with purpose, then best practice, then alternative. Every sentence adds value, but could be tightened.

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 authentication tool with one optional parameter and no output schema, the description covers all needed behavior: how to authenticate permanently or session-only, and how to get the login link.

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 the 'token' parameter usage: pass a JWT after user pastes, or omit to get login link. This compensates well 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 is for authentication, explaining how to log in and retrieve an access token. It distinguishes itself from sibling tools (e.g., connect, openfinance_*) by focusing solely on authentication.

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: best to add token to server config, or paste for session, or call with no args to get the link. Clearly separates two use cases with clear when-to-use instructions.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context by specifying the exact return values (authenticated, pending, connect_url) and how they vary by connection state, without contradicting annotations.

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

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

The description is extremely concise with two sentences that efficiently convey the tool's behavior in two key states. No unnecessary words or 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?

The description covers the main scenarios (all connected vs missing credentials) adequately for a status check tool with no input parameters and no output schema. It could potentially mention error states or edge cases, but overall it is complete enough for most use cases.

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

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

The tool has no parameters, so the schema coverage is 100%. The description does not need to add parameter information; it correctly focuses on the return behavior. 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 that the tool returns connection status and URLs, and distinguishes two scenarios (all providers connected vs missing credentials). While it doesn't explicitly differentiate from sibling tools, the purpose is clear and 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?

The description implies usage by describing what is returned under different conditions, but it does not provide explicit guidance on when to use this tool versus alternatives like 'authenticate' or 'openfinance_provider_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?

The description discloses important behaviors beyond annotations: invoke works even for uninstalled MCPs, returns connect/checkout links on credential/payment needs, and writes require workspace owner/admin. It also mentions installed flags and the prompt library's shareable links. 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 a single dense paragraph containing substantial useful information. All sentences carry value, but the lack of structure (bullets/sections) and inclusion of a Portuguese word ('pontualmente') reduce scannability. It is appropriately sized for the tool's complexity but could be better 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 the tool's complexity (23 parameters, 14 actions, no output schema), the description provides a comprehensive and actionable picture: core workflow, authentication/payment handling, permission requirements, and the prompt library. It covers critical paths and edge cases thoroughly, leaving little 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?

With 0% schema description coverage, the description compensates by explaining the meaning of the 'action' parameter and related fields like tool_id, arguments, and tier_slug through the core flow. However, not all 23 parameters are explicitly covered (e.g., immediate, prompt_targets), leaving some ambiguity, though the most critical ones are addressed.

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 role as 'the official mcp.ai marketplace — the in-platform catalog of every MCP/tool, AND the way to run them,' covering discovery, description, installation, and invocation. It distinguishes itself from sibling tools (e.g., openfinance_*) by being the central marketplace platform.

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 core flow (search → describe → invoke), and contrasts invoke vs install: 'Use install only to make an MCP PERMANENT in the active toolkit... prefer invoke for a single/occasional use.' It also explains when to use subscribe/cancel, report_bug, and request_mcp, and notes permission requirements for writes.

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 the tool is destructive (destructiveHint=true). The description adds value by explaining that connection data is deleted and data becomes unavailable, and it mentions the return of an 'add_connection_url' for reconnection. This provides behavioral context beyond the annotations.

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

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

The description is concise (two sentences, 25 words) and front-loaded with the core action. Every sentence adds essential information without redundancy.

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

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

Given the tool's simplicity (one parameter, destructive action, no output schema), the description covers the main effect and return value. However, it lacks explanation of the required 'item' parameter and any prerequisites (e.g., must be connected). The presence of sibling tools like 'openfinance_list_connections' suggests a context, but the description does not leverage that.

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

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

The input schema has one required parameter 'item' with no description (0% coverage). The description does not explain what 'item' represents (e.g., a bank identifier or connection ID), only implying 'a specific bank'. With low schema coverage, the description should compensate by clarifying the parameter, but it fails to do so.

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

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

The description explicitly states the tool revokes Open Finance consent, deletes connection data, and makes bank data unavailable. It uses specific verbs ('revokes', 'deletes') and clearly identifies the resource ('a specific bank'). This distinguishes it from sibling tools like 'openfinance_list_connections' or 'openfinance_get_item_status', which do not perform disconnection.

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 should be used when wanting to disconnect a bank and delete its data, but does not explicitly state when not to use it or mention alternatives among sibling tools. However, the context is clear enough for an agent to infer appropriate usage.

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

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

Discloses sync process (PATCH, polling up to 60s), return fields (status, executionStatus, lastUpdatedAt, synced, needs_action, reconnect_url, timed_out), and behavior of wait parameter. Annotations only indicate non-read-only and non-destructive; description adds critical behavioral details.

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 somewhat lengthy but packs essential information. Each sentence adds value, though it could be more structured (e.g., separating parameters and return values) for easier reading.

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 covers all return fields and error scenarios (needs_action, timed_out). It also explains edge cases (reconnect_url, no disconnect) and provides fallback guidance. 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?

Schema coverage is 0%, but description fully explains both parameters: 'wait' as boolean for fire-and-forget, 'items' as array of selectors with explanation of allowed values and omission behavior (sync 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?

Description clearly states the action: force re-sync of connections with waiting. It uses specific verbs and resources, and distinguishes from sibling tools like openfinance_disconnect_bank by emphasizing 'WITHOUT disconnecting/reconnecting'.

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

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

Explicitly says 'Use this when a balance or transaction list looks stale', providing clear context. It also advises to use openfinance_get_item_status if timed out, but does not list all alternatives.

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

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

Annotations already mark this read-only and idempotent, but the description adds important behavioral context: the balance is a snapshot anchored to the last upstream sync, not a live read. It also discloses error handling (structured warnings, BALANCE_FETCH_ERROR, BALANCE_CONSENT_ERROR) and degraded behavior when the provider returns 5xx.

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

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

The description is long but every sentence earns its place: freshness semantics, sync caveats, error modes, and the force_sync alternative are all directly useful. It is front-loaded with the core purpose before diving into edge cases.

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 tells the agent what to expect in the response (rows with updateDateTime/updatedAt and optional warnings), how to handle failures, and how to recover. For a read-only balance endpoint with a single parameter, this is complete enough for correct selection and invocation.

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

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

The input schema only defines account_ids as an array of strings with no description coverage, so the description carries the burden. It adds that this must be an array and limits it to 1–50 items. It does not explain where account_ids come from, but the name and sibling context make that mostly inferable.

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?

States a specific verb ('Returns') and resource ('latest available balance per account id') and gives the exact endpoint. It is clearly distinguishable from siblings like openfinance_list_accounts or openfinance_get_accounts_detail.

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

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

Explicitly tells the agent when to use openfinance_force_sync instead: if a recent movement is missing or the balance disagrees with transactions. It also explains what to do for credit consent errors, namely reconnect the bank.

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

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

The description adds critical behavioral context beyond annotations: it warns about a provider_incident block that may make credit limits and balances unreliable, and instructs not to present those values as real. This is transparent and useful.

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

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

The description is well-structured and front-loaded with the purpose, but slightly verbose with the provider_incident detail. However, every sentence adds value, so it remains concise enough.

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 parameter and no output schema, the description fully explains the batch shape ({ results, errors }) and important edge cases (provider_incident), making it sufficiently complete.

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

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

The description adds the constraint that account_ids must be an array of 1–50 strings, which compensates for the 0% schema description coverage by providing semantic constraints not present in 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 returns full account objects including extended creditData per ID, referencing the specific endpoint GET /accounts/:id. It distinguishes from sibling tools like openfinance_list_accounts by focusing on detailed data for specific accounts.

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

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

The description implies usage for retrieving detailed account data but does not explicitly state when to use this tool over alternatives like openfinance_list_accounts. It provides no guidance on 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 readOnlyHint: true, idempotentHint: true, and destructiveHint: false, so the safety profile is covered. The description adds substantial behavioral context: transactions_basis can mean exact bill_id matching or an estimated date_window, the bank payload carries no transactions, the bill's totalAmount is authoritative and not to be recomputed by summing transactions, and payments[] can refer to the previous bill, not the current one. There is no contradiction between description and annotations.

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

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

The description is long but every sentence carries information: it starts with the core return shape, then explains the opt-in transaction behavior, then flags estimate vs. exact basis, and closes with a critical paid-status caveat. It uses inline alerts like 'do NOT rebuild it' and 'do NOT assume' to emphasize important nuances, and has no filler or repeated schema 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 there is no output schema, the description does an excellent job of documenting both the standard response fields and the opt-in transaction enrichments, including transactions_count, transactions_sum, and reconciles_with_total. It also covers the batch shape, the fee-account dependencies, and how to derive the missing paid status from a sibling tool. An agent would know how to call this correctly and how to interpret the results.

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

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

Despite the schema having no parameter descriptions, the description meaningfully explains bill_ids as an array to be discovered via list_credit_card_bills, and explains that include_transactions: true must be paired with the credit card account_id because the bill payload carries no account reference. The only parameter not clarified is transactions_detail; compact/rich/raw are not defined, which is a small gap given the otherwise high level of 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 states explicitly that the tool 'Returns bill-level detail for one or more credit card bills by id' and lists specific fields, which is a clear verb+resource combination. It also distinguishes itself from siblings by explaining where transactions actually live (on the account, not the bill payload), helping an agent separate this from openfinance_list_credit_card_bills 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 provides strong usage routing: it says to use openfinance_list_credit_card_bills first to discover ids, mentions openfinance_list_transactions as the alternative for fetching transactions directly, and explicitly advises preferring openfinance_list_credit_card_bills for paid status because this endpoint has no status field. It even warns about a common misunderstanding of payments[] and when the estimate vs exact basis should be trusted.

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 (readOnly, idempotent, non-destructive), the description discloses behavioral details: reconnect_url reopens widget in UPDATE mode without disconnecting or consuming a slot, and bulk mode returns {count, items}. This adds significant 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 concise and well-structured, starting with the core functionality and layering details efficiently. Every sentence adds value without redundancy.

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

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

Given no output schema and sparse input schema, the description comprehensively covers return formats, fields included, and special behavior of reconnect_url. It provides sufficient context for an agent to invoke the tool correctly.

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

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

With 0% schema coverage, the description fully explains the meaning and effect of each parameter: omitting 'item' returns all banks, passing 'item' returns a single bank, and 'item_ids' enables batch execution. This is essential for correct usage.

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

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

The description clearly states it returns the current status of a bank connection, listing specific status values and additional fields like executionStatus and reconnect_url. It distinguishes between single and bulk modes and implies differentiation from sibling tools that focus on other aspects like accounts or transactions.

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

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

The description explains when to omit or include the 'item' parameter for single vs. all banks, and mentions bulk support with item_ids. It implicitly guides usage but does not explicitly contrast with alternative tools or state when not to use.

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

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

Annotations already provide readOnlyHint, idempotentHint, destructiveHint. The description adds valuable behavioral details beyond annotations: batch shape ({ results, errors }) and array size limits. 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 a single sentence that front-loads the purpose and then lists key subfields. It is concise but could be slightly better structured (e.g., bullet points for fields). Still, it earns its place.

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

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

Given the complexity of a loan detail tool with many subfields and no output schema, the description clearly enumerates all major return fields (interestRates, contractedFinanceCharges, installment schedule, CET, etc.) and explains the batch shape. It is comprehensive for an AI agent.

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

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

Schema description coverage is 0%, so the description must compensate. It does so by specifying that loan_ids is an array of 1-50 items and mentioning the batch result shape. This adds meaningful usage guidance beyond the schema type definition.

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 loan contract details by ID, enumerating specific fields (interestRates[], etc.). It distinguishes from sibling tools by explicitly recommending use after openfinance_list_loans for deep-dive.

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

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

The description explicitly advises using this tool after openfinance_list_loans and provides constraints on the loan_ids array (1-50). It does not list when-not-to-use or alternatives but gives clear context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, but the description adds rich behavioral context beyond them: balance_notice means a reported 0.00 balance may still have outstanding debt, bankData derived fields can lag after connection creation, provider_incident can make balances unreliable, and identity_notice requires dedup by account number before summing balances. These are exactly the non-obvious behaviors an agent needs to avoid giving misleading answers.

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 it is front-loaded with the core return contract and organized into clear caveat paragraphs. Every sentence earned its place given the complexity and missing output schema, though some parenthetical explanations and repeated references to `bank`/`connector_id` could be slightly tightened without losing meaning.

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 that there is no output schema and very sparse parameter documentation, this description is exceptionally complete. It explains the result shape, field-level semantics, single-bank vs cross-bank behavior, batching, stale data, connector incidents, identity deduplication, and when to delegate to sibling tools. An agent has enough context to select, invoke, and interpret this tool correctly in most realistic scenarios.

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 carries the burden, and it does a strong job on `item` and `item_ids` by explaining their behavioral difference. However, the `type` parameter and singular `item_id` are only inferable from the enum and the bulk-support sentence rather than being explicitly tied to their filtering or batching semantics.

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 first sentence states a specific verb ('Returns') and resource ('accounts for a bank connection'), then enumerates account categories (BANK, CREDIT) and returned fields (balance, number, type, subtype, bankData, creditData). It clearly distinguishes the bulk-all-banks behavior from single-bank behavior and differentiates this tool from siblings like openfinance_list_credit_card_bills.

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

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

The description gives explicit when-to-use guidance: OMIT `item` to list accounts across ALL linked banks when the user asks for 'my accounts/cards' without naming a bank, and pass `item` to target a single bank. It also explicitly routes the agent to openfinance_list_credit_card_bills for standardized open-bill amounts and to openfinance_force_sync for reconciling stale derived fields.

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

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

Annotations already indicate read-only and idempotent behavior. The description adds value by stating the response is cached for the adapter session, and that it's a single aggregated response with no batch IDs. This provides behavioral context beyond what annotations alone offer.

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 three sentences covering purpose, cache behavior, and field details. It is well-structured and front-loaded with the main purpose. Minor cut: could be even more streamlined, 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?

Despite lacking an output schema, the description fully informs about the response structure: each entry's fields (id, description, descriptionTranslated, parentId, parentDescription) and their semantics. It also clarifies cache behavior and that it's a single aggregated result. This is complete for a category listing 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 input schema has zero parameters, so the description does not need to explain parameters. Per guidelines, a baseline score of 4 is appropriate when there are no parameters, as the description cannot add value in this dimension.

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 transaction category taxonomy from Pluggy. It specifies the source (GET /categories) and relates its output to another tool (openfinance_update_transaction_category). This is distinct from other sibling tools like openfinance_list_transactions, which deal with transactions rather than 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 implies that this tool should be used when category taxonomy is needed, especially to obtain categoryId for update_transaction_category. However, it does not explicitly state when not to use it or mention alternatives among siblings. The context makes it clear enough for an agent to infer usage, but lacks explicit guidance.

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

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

The description discloses behavioral traits beyond the annotations: it explains the reconnect_url behavior (reopens widget in UPDATE mode for existing connections) and states that no connection slot is consumed and no disconnection is needed. Annotations already indicate readOnlyHint, idempotentHint, destructiveHint, so the description adds valuable context 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 concise (three sentences) and front-loaded with the most important information (what is returned). Every sentence adds value: the first states the output, the second explains the reconnect_url, and the third clarifies usage constraints.

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, the description adequately explains the returned fields and the crucial reconnect_url behavior. It covers all necessary aspects for an AI agent to understand and correctly invoke 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?

There are no parameters, so schema coverage is 100%. The description does not need to add parameter details; it provides full context about what the tool returns. Baseline of 4 is appropriate 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 that the tool returns saved bank connections with specific fields (connector_id, item_id, bank name, reconnect_url, add_connection_url). It distinguishes from sibling tools like openfinance_list_accounts by focusing on connections rather than accounts or transactions.

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

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

The description provides explicit guidance on when to use the reconnect_url for re-authentication needs (MFA connectors, LOGIN_ERROR, stale data) and clarifies that it does not consume a connection slot or require disconnecting first. However, it does not explicitly state when to use the main list functionality versus alternatives, but the list's basic purpose 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?

The description discloses extensive behavioral traits beyond annotations: payment_status derivation, connector asymmetry, open bill availability conditions, bill grouping reliability warnings, and the fact that payments on one bill may relate to another. No contradiction with annotations (readOnlyHint, idempotentHint).

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

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

The description is front-loaded with the core function and then dives into necessary details. While lengthy, every sentence adds value, covering complex semantics. It is well-structured with logical sections, though it could benefit from slight condensation.

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 the complexity of the domain (Brazilian Open Finance, payment status logic, connector differences), the description is remarkably complete. It covers return fields, derived statuses, limitations, and cross-references to sibling tools, leaving little 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?

With 0% schema description coverage, the description adds meaning for account_id, account_ids, and include_open_bill, explaining their roles and the bulk execution support. However, it does not explain page and page_size parameters, which are standard but still 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 it returns closed credit card bills for a CREDIT-type account, listing specific fields. It distinguishes from sibling tools like openfinance_list_transactions by mentioning when to use that tool for itemized purchases.

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

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

The description provides explicit guidance on when to use this tool vs alternatives, such as using openfinance_list_transactions for itemized purchases, and explains the opt-in include_open_bill parameter and when to rely on it over account balance. It also warns against reconstructing bill totals from 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?

Beyond annotations (readOnlyHint, etc.), the description discloses error handling behavior (returns warning on 403), data integrity checks for mass zeroing, and flags suspect rows. This adds significant context for safe invocation.

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

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

The description is front-loaded with purpose but becomes verbose with the data integrity warning, which could be more concise. It is not overly long but could be streamlined.

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 error handling and data integrity well, but fails to document most parameters. Given the complexity (6 params, no output schema), the missing parameter info leaves the tool incomplete.

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 should explain all parameters. It only mentions 'item_ids' for bulk support. 'item', 'page', 'type', 'item_id', 'page_size' are undocumented, leaving their purpose unclear.

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 an investment portfolio for connections with INVESTMENTS product enabled, listing specific asset types. It distinguishes from sibling tools like openfinance_list_investment_transactions which focus on transactions.

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

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

The description provides context on when to use (connections with INVESTMENTS enabled) and handling of errors (403 return format). It does not explicitly state when not to use or compare with alternatives, but the sibling list and tool name provide implicit differentiation.

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. The description adds value by detailing output fields (quantity, value, netAmount, etc.) and the variety of transaction types, which is not in the annotations or schema. It also mentions bulk support. It does not address pagination behavior or error handling, 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 concise, with two short paragraphs. The first paragraph explains the core functionality and output; the second addresses bulk support. It is front-loaded with key information. A bulleted list might improve readability, but overall structure is efficient.

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

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

Given no output schema, the description provides substantial detail about return fields and transaction types. It also covers the prerequisite (use after openfinance_list_investments) and bulk capability. It does not explain pagination or potential errors, but for a read-only listing tool with clear annotations, this is fairly 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%, so description must compensate. It explains the required investment_id and the bulk investment_ids parameter ('Bulk support: accepts investment_ids for batched execution'). However, it does not describe page and page_size parameters, which are left entirely to the schema. This is adequate but incomplete, as pagination parameters are common but their meaning could be clarified.

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

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

The description clearly states the tool returns movement history for a specific investment position, listing transaction types (BUY/SELL/etc.) and output fields. It distinguishes itself from sibling openfinance_list_investments by requiring the investment_id obtained from that tool, and implies it is specific to investment transactions rather than general 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 explicitly says to use this tool after openfinance_list_investments to get the investment_id, providing sequential guidance. It also mentions bulk support for batched execution. However, it does not directly compare to alternatives like openfinance_list_transactions, though context implies differentiation.

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 readOnly and non-destructive; description adds GET method, return structure { results, errors }, and concurrency behavior (sequential spacing). 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?

Two sentences, front-loaded purpose, efficient parameter details. No redundancy or 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?

With no output schema, description includes return structure. Could specify format of results/errors, but sufficient for simple list tool given 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?

Only parameter `items` is described in detail: array of connection selectors (item_id, connector_id, or connector_name), one per connection. Schema coverage is 0%, so description provides essential 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 'Lists loan contracts per bank connection' with the API endpoint, and distinguishes from siblings like openfinance_get_loan_detail by specifying the scope (per connection vs. single item).

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

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

Explicit guidance: pass `items` for specific connections or omit for all banks, with behavior for multiple connections (sequential with rate-limit spacing). Helps agent decide when to use.

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

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

Annotations already indicate readOnly/idempotent/non-destructive behavior, and the description adds substantial behavioral context well beyond that: pagination auto-manipulation, scheduled row ordering, upstream error fallback shape, provider_incident behavior, and caution about per-connector differences. No annotation contradiction exists.

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 the high complexity of the tool justifies much of it. It is mostly structured with clear topics, but it repeats the billId warning and credit-pending caveat in multiple places, so it's not as tightly edited as it could be.

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 supplies essential return-shape expectations: account echo, total/totalPages, scheduled_count, notice, truncated, warning/error, and rich/raw fields. It also covers error behavior and connection-health follow-up, making it highly complete given the complexity.

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

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

Schema description coverage is 0%, so the description carries full responsibility. It explains from/to as ISO YYYY-MM-DD filters, search_queries as case-insensitive substring OR-matching, page/page_size manual vs auto-pagination semantics, detail as compact/rich/raw with row payload details, and account_ids for batched execution. Every parameter is meaningfully covered.

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?

Starts with a specific verb and resource: 'Returns transactions for a bank account.' It further differentiates the tool by noting it is the ONLY way to get itemized credit-card transactions, distinguishing it from the bill and account sibling tools. The scope is unequivocal.

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 is explicit about when to use alternatives: use openfinance_list_credit_card_bills for open-bill totals, openfinance_list_accounts for closing/due dates, and openfinance_get_item_status when credit-card total is 0. It also specifies when pagination should be omitted vs used, providing clear decision rules.

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 false. The description adds critical behavioral traits: a cap of 5000 transactions per account with a truncated flag, potential provider_incident block explaining incomplete data, and that it resolves accounts internally. These go 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 thorough but somewhat lengthy. It is well-structured with key sections (bullets in original? but here as prose). Every sentence adds value, but could be more concise by combining some sentences. Still, it remains readable and front-loaded with the main purpose.

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 thoroughly explains the return structure: totals, monthly evolution, top expenses/revenues, per-account breakdown, and the optional raw rows with detail levels. It also covers edge cases like truncation and provider incidents. This is complete for a complex 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 description coverage is 0%, so the description must compensate. It explains every parameter: item (connector_id/connector_name/item_id), from/to (ISO dates), granularity (monthly/raw), detail (compact/rich/raw with explanation of each), type (BANK/CREDIT), and item_ids for bulk. The meaning of top_n is implied by 'largest N'.

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

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

The description clearly states it provides 'consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call.' It distinguishes from sibling tools like openfinance_list_accounts by explicitly saying you don't need to call them first. The verb 'analyze' and resource 'connection transactions' are 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?

The description gives explicit guidance: when to set granularity to monthly vs raw, when to use detail options, and filters. It states usage scenarios like 'análise anual/mensal, fluxo de caixa'. It also advises that for all linked banks you omit the item parameter.

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 behavioral context about what the tool returns (global indicator, degraded components, incidents) and how it flags incidents affecting connected banks, going 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 well-structured with purpose first, then usage guidance, then return details. It is slightly verbose but every sentence adds value; could be tightened slightly without loss.

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

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

For a zero-parameter tool with no output schema, the description fully covers purpose, usage context, return data, and how it helps diagnose provider-side problems. It is complete and actionable.

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

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

No parameters exist in the schema, so baseline 4 applies per guidelines. The description adds no parameter information, which is appropriate given zero parameters and 100% 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 the tool checks the LIVE operational status of the Open Finance provider, explicitly distinguishing it from the sibling tool openfinance_get_item_status by explaining the provider health vs. connection status difference.

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

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

The description provides explicit guidance on when to use this tool: when data looks incomplete or stale even though a connection shows UPDATED, and it names the alternative openfinance_get_item_status for connection-level issues.

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 read-only and idempotent. The description adds context: returns connector details, caveat warnings for non-Open-Finance connectors, and plan-based filtering. 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 quite detailed and somewhat lengthy, but each sentence adds value. It is front-loaded with the main purpose, but could be slightly more concise.

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

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

Covers key behaviors: what is returned, caveat warning, plan handling, and when to call. No output schema, but the description provides sufficient information for an agent to invoke correctly.

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

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

With 0% schema description coverage, the description compensates by explaining the purpose of 'keywords' (with examples) and 'include_accounts'. It also clarifies that 'keywords' is required in practice.

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 searches bank connectors by name and returns specific fields including a connect_url. It distinguishes from sibling tools by advising to call this before connecting.

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

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

Explicitly advises 'Call this BEFORE connecting' and explains that keywords are required (without it returns a hint). Mentions plan behavior, but does not explicitly contrast with all 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?

Discloses critical side effect: creates Category Rule affecting future transactions. Also explains batch error behavior. Annotations are minimal, so description carries full burden.

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 paragraph but dense; covers all necessary information. Could be slightly more structured (e.g., separate side effects) but remains concise relative to 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?

No output schema, but description fully specifies batch return shape (updated, results, errors) and explains error handling. Covers all behavioral aspects for a write tool.

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

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

No schema descriptions (0% coverage), but description explains items array structure, required fields, and sources (list_transactions, list_categories). Adds essential 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?

Clearly states it corrects transaction categories (PATCH /transactions/:id), specifies parameters from sibling tools, and explains side effect of creating category rules. Distinguishes from list/get 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 for fixing miscategorized transactions; mentions side effect of creating rules which informs when not to use. Could add more contrast with siblings but 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 indicate idempotentHint=true and non-destructive, but the description does not clarify the idempotent behavior or other traits (e.g., what happens after reporting). It adds minimal behavioral context beyond the structured fields.

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

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

The description is a single sentence, concise and front-loaded. However, it could be more structured (e.g., separate lines for each usage aspect) 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?

The tool has no output schema and sparse descriptions. For a feedback tool, it lacks information on expected response or behavior after submission, making it incomplete for agents to fully understand consequences.

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 should compensate. It only addresses the 'conversation' parameter ('include the conversation array'), but does not explain 'context' or 'message' parameters, leaving them undefined.

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 the tool reports bugs, missing features, or sends feedback (specific verb+resource). It distinguishes from siblings which are primarily OpenFinance or general connectivity tools, but does not explicitly differentiate from alternatives.

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 'include the conversation array with recent messages for reproduction', providing one usage guideline. However, it lacks explicit guidance on when to use this tool vs alternatives 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 already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds what versions are shown, which is consistent. No extra behavioral details needed; 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?

Single sentence that directly states the tool's action, front-loaded, no extraneous information.

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

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

For a simple version display tool with zero parameters and no output schema, the description is nearly complete. Could hint at return format but not required.

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

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

Input schema has zero parameters, so description carries no burden. Baseline score 4 applies because there is nothing more to add.

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 'show' and the resource 'current MCP platform and adapter versions,' which is specific and distinguishes from sibling tools focused on authentication, Open Finance operations, etc.

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

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

Although no explicit when-to-use or alternatives are given, the tool is trivial (no parameters, no side effects) and its sole purpose is obvious; the guidance is implicit and sufficient for this simplicity.

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, indicating a safe read-only operation. The description adds value by specifying the returned fields (installed MCPs, connection status, accounts, catalog tool counts), which is behaviorally informative. 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 sentence that front-loads the action ('Returns') and lists the key outputs. Every phrase contributes meaningful information, with no wasted words or 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 simplicity of the tool (no params, no output schema), the description fully covers the return value by enumerating the components of the toolkit state. It is sufficiently complete for an agent to understand what to expect without additional documentation.

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 is empty with 100% coverage. The baseline for 0-param tools is 4, and the description does not need to elaborate on parameters. No additional parameter explanation is required.

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: 'Returns the current toolkit state' and specifies the exact contents (installed MCPs, connection status, accounts, catalog tool counts). The verb 'returns' is specific, the resource is 'toolkit state,' and the details distinguish it from sibling tools like show_version or openfinance_provider_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 implies clear usage: to get an overview of the toolkit's current state. It does not explicitly mention alternatives or exclusionary conditions, but the context is unambiguous and matches typical diagnostic tools. The lack of explicit 'use when' phrasing is offset by the clarity of purpose.

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