Banco PAN MCP

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

Description aligns with annotations (idempotent, non-destructive). Adds context: token can be set once, permanent vs session, and that calling without args returns a link. 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?

Informative but slightly verbose with informal opening. However, front-loaded with key action, and every sentence adds value. Could be tightened slightly.

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 simple 1-param tool with no output schema. Covers both usage modes (with/without token), implications for session vs permanent, and references config setup.

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

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

Despite 0% schema description coverage, the description fully explains the token parameter: optional, use for pasting JWT, or omit to get login link. Adds meaning beyond schema.

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

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

The description clearly states the tool's purpose: authentication via token retrieval. It distinguishes from sibling tools (e.g., connect, report_bug) by focusing on auth flow.

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

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

Explicit guidelines: when to call with token (session login) vs without (get link), and best practice for permanent config-based auth. Differentiates from alternative approach.

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 a safe read operation. The description adds valuable behavior context by describing the response structure in both connected and missing credentials states, which goes 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 extremely concise with two sentences that front-load the main purpose. Every sentence adds value with no wasted words.

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

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

Given the tool has no parameters and no output schema, the description is complete. It adequately explains the return behavior and different states, which is sufficient for this simple 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 no parameters, so schema coverage is 100%. According to the rubric, a baseline of 4 applies when there are 0 parameters, and no additional parameter details are needed.

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

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

The description clearly states the tool returns connection status and URLs, with specific detail on two states (all connected vs. missing credentials). It is specific and covers the resource, but does not explicitly differentiate from sibling tools like 'authenticate'.

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

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

The description gives clear context on when to use the tool (to check connection status) and what to expect in different scenarios. However, it lacks guidance on when not to use it or mention of alternative 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?

Discloses side effects like the one-off install behind invoke without adding to toolkit, permission requirements (workspace owner/admin for writes), and conditional behavior for missing credentials/wallet. These go beyond annotations, which only note non-read-only and non-destructive.

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

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

The description is dense but well-structured, starting with the core function, then the flow, key behavioral caveats, and prompt library. Some sentences are long, but every sentence contributes meaningful guidance.

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 14 actions and 23 parameters, the description covers the primary flows and edge cases like auth/payment well. However, it omits the 'resume' action and does not explain return structures or several params like immediate/tier_slug, so it is not fully complete.

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

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

With 0% schema description coverage, the description must define the parameters, but it only names the action values and high-level purpose of tool_id, leaving limit, query, prompt_* fields, immediate, tier_slug, etc. unexplained. This forces agents to guess about parameter formats and defaults.

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 is the official mcp.ai marketplace and the way to run MCPs, enumerating the catalog and run capabilities. It distinguishes itself from sibling openfinance_* tools by being the in-platform catalog and execution engine, with a specific core flow (search → describe → invoke).

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 recommends invoke for single/occasional use and install for permanent additions, and notes when invoke returns connect/checkout links to retry. It also indicates search_prompts/get_prompt/publish_prompt for the prompt library, and request_mcp when nothing fits, providing clear context vs 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 it as destructive; the description adds value by explaining that data becomes unavailable and that an add_connection_url is returned for reconnection. It discloses the behavioral consequences beyond the annotation.

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, each essential: action, consequence, and return value. No redundancy or filler. Ideal 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 one parameter and no output schema, the description covers the behavioral outcome and return value adequately but fails to clarify the critical parameter meaning, leaving a gap for correct invocation.

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

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

The sole parameter 'item' is completely undocumented in the schema (0% coverage). The description mentions 'specific bank' but does not clarify what the parameter represents (e.g., bank ID, consent ID). This leaves the parameter ambiguous.

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

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

The description clearly states the tool revokes Open Finance consent and deletes connection data for a specific bank, with a distinct verb-resource combination. It is unambiguous and differentiates from sibling tools like openfinance_list_connections or openfinance_force_sync.

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

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

The description implies usage when disconnecting a bank but provides no explicit guidance on when to choose this tool over alternatives, nor does it mention prerequisites or exclusions. The note about reconnection is helpful but insufficient for full 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 key behaviors: uses PATCH and polling, waits up to 60s, returns detailed result fields (status, executionStatus, lastUpdatedAt, synced, needs_action, reconnect_url, timed_out). Annotations show readOnlyHint=false and destructiveHint=false, supporting the mutation but non-destructive nature. 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 thorough but not overly verbose. It front-loads the main action and intent, then provides detailed explanations. Each sentence adds value, though some minor redundancy could be trimmed. Overall, well-structured.

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

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

Given the tool's complexity (sync with polling, multiple outcomes), the description covers behavior, parameters, return values, error handling (needs_action with reconnect_url, timed_out), and references a sibling tool. Without an output schema, it provides sufficient context for an agent to select and 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?

Schema description coverage is 0%, but the description fully explains the 'items' parameter as an array of selectors (item_id, connector_id, connector_name, custom_label nickname) and the 'wait' parameter as synchronous vs fire-and-forget. This provides clear meaning beyond the schema's type definitions.

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

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

The description uses specific verbs ('forces', 're-sync') and clearly states the resource (bank connections) and action (sync and wait). It distinguishes itself from sibling tools like openfinance_get_item_status by explaining that it initiates a sync and waits, while the sibling is for checking status after timeout.

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

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

The description explicitly states when to use (stale balance/transactions) and what it does without disconnecting/reconnecting. It mentions options like wait: false for fire-and-forget and refers to openfinance_get_item_status for timed_out results. However, it could more explicitly list when not to use or provide alternative tools for other scenarios.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds significant behavioral detail beyond annotations: explains degradation to last-synced balance with realtime:false, warnings instead of errors for CREDIT accounts, and the structured error response format. 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 well-structured and covers all essential aspects in a compact format without redundancy. It could be slightly more concise but the level of detail is justified given the 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?

Given the tool's complexity (real-time balancing, degradation, warning handling) and the absence of an output schema, the description covers return shape, error conditions, and degradation behavior comprehensively. It provides enough context for correct invocation and result interpretation.

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 explicitly explains the single parameter account_ids: it is an array, and constrains it to 1-50 items. This adds critical semantic information missing from 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 real-time balance per account id, specifies the HTTP method and path, and distinguishes from sibling tools like openfinance_list_accounts or openfinance_get_accounts_detail by focusing exclusively 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 provides explicit usage context: pass account_ids as an array (1-50), explains edge cases for CREDIT accounts (BALANCE_FETCH_ERROR) and degradation when upstream is unavailable. It does not explicitly mention when not to use, but the degradation behavior implicitly guides the agent on fallback expectations.

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 critical behavioral context beyond annotations by disclosing the provider_incident block and warning that credit limits and balances may be unreliable, which is essential for correct use of the data.

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 main purpose, followed by essential usage notes and a caution. No wasted words.

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

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

Given the single parameter and lack of output schema, the description fully covers the tool's behavior: input constraints, batch response shape, and reliability caveat, making it contextually 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?

Despite 0% schema coverage, the description explains the account_ids parameter format (array of strings, 1–50 items) and the batch output shape, providing meaningful semantics that aid the agent.

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, and the mention of batch shape and provider_incident distinguishes it from siblings like list_accounts which likely provide only basic details.

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

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

Implicitly clarifies usage by specifying account_ids array (1–50) and the batch shape, but does not explicitly state when to use this tool over alternatives like get_account_balance or list_accounts.

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

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

Adds substantial behavioral context beyond annotations: explains batch response shape ({ results, errors }), notes Pluggy's missing paid/status field, describes payments[] behavior across billing cycles, and warns about sparse/inconsistent billId in transactions. 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 well-structured, front-loading purpose then branching into exclusions, usage instructions, and behavioral notes. While relatively long, each sentence adds value. Could be slightly more concise, but clarity is prioritized effectively.

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

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

Given no output schema, the description adequately explains the response shape ({ results, errors }) and lists key fields. However, it does not fully enumerate all possible response fields (e.g., totalAmount, dueDate). Still covers critical aspects for correct invocation and interpretation.

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 that bill_ids should be an array, advises to discover IDs via openfinance_list_credit_card_bills first, and mentions the batch response shape. Though only one parameter, the description provides necessary context 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 the tool returns bill-level detail for credit card bills by ID, specifies the returned fields (financeCharges, payments[] with subfields), and explicitly distinguishes from sibling tools by stating what it does NOT do (individual transactions) and directing to openfinance_list_transactions for that purpose.

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

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

Provides explicit guidance: pass bill_ids as an array, first use openfinance_list_credit_card_bills to discover IDs. Warns about Pluggy not returning paid/status field, explains payments[] reflects payment of previous bill, and advises against reconstructing bill total from transactions. Clearly states when to use this tool versus 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds context that the tool also returns a reconnect_url for re-authentication without disconnecting or consuming a connection slot, which is valuable 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 concise (3-4 sentences), front-loaded with the key purpose, and every sentence adds value. No fluff or repetition of 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 the tool's simplicity (read-only, no output schema), the description adequately explains the return format (count, items for bulk; single status fields for one item) and the special reconnect_url behavior. It covers the main usage patterns without 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?

Input schema has 0% description coverage, so the description carries the full burden. It clarifies the meaning of each parameter: omit 'item' for all, pass a single 'item' or 'item_id' for one bank, and use 'item_ids' for bulk. This adds necessary 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 description explicitly states 'Returns the current status of a bank connection' with specific status values and details. It distinguishes from sibling tools by mentioning bulk support (item_ids) and the difference between querying all linked banks vs. a single one.

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

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

The description provides clear guidance on when to use 'item' vs. omitting it ('Omit item to get the status of ALL linked banks at once; pass item for a single bank') and mentions bulk support via item_ids. However, it does not explicitly state when not to use the tool or name alternatives among siblings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety is known. The description adds that it is a GET endpoint, returns specific fields, and returns a batch shape with results and errors, which is valuable beyond annotations.

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

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

The description is two sentences: one listing fields, one for usage. It is efficient and front-loaded with the main action. Could be slightly more structured, but no unnecessary words.

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

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

With no output schema, the description explains the return fields and batch shape. It covers purpose, parameter constraints, and usage sequence. For a simple tool with one parameter, it is 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 only parameter, loan_ids, has no description in schema (schema description coverage 0%). The description adds crucial meaning: it must be an array of strings with 1-50 items. This compensates fully for the missing schema documentation.

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

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

The description clearly states it returns full loan contract detail by ID, listing specific fields. It distinguishes itself from the sibling tool 'openfinance_list_loans' by advising use after listing loans for deep-dive.

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

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

The description gives clear usage context: use after openfinance_list_loans. It specifies the parameter format (array of 1-50 loan_ids) and the batch shape. Does not explicitly state when not to use, but the context is sufficient.

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

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

Beyond annotations (readOnlyHint, etc.), the description discloses critical behavioral traits: credit balance meaning varies by connector, potential provider incidents making balances unreliable, identity notice requiring deduplication, and batch support via item_ids. No contradiction with annotations.

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

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

The description is lengthy (over 300 words) but front-loads the core purpose. Every sentence is justified given the complexity, but some restructuring could improve readability. Still, it remains focused.

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

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

Given no output schema, the description explains the return fields, including special blocks like provider_incident and identity_notice. It also clarifies limitations and alternative tools. It lacks explicit mention of pagination, but overall it is sufficiently complete for a list tool.

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

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

With 0% schema coverage, the description carries the full burden. It explains 'item' and 'item_ids' well, and implies the 'type' parameter by mentioning BANK/CREDIT. However, it could more explicitly map each parameter to its purpose. Overall, it adds significant value beyond the schema.

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

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

The description clearly states the tool returns accounts for bank connections, specifying types (BANK/CREDIT) and fields returned. It distinguishes from sibling tools like openfinance_list_credit_card_bills by noting that for standardized credit card bill amounts, that tool should be used.

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 'item' parameter vs omitting it for aggregated results, how to handle credit card balance in a connector-dependent manner, and warnings about provider incidents and identity notices. It also suggests an alternative tool for credit card bills.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds value by noting the response is 'cached for the adapter session' and is a 'Single aggregated response — no batch ids', providing behavioral context beyond annotations. No contradictions.

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

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

Three sentences covering purpose (first sentence), response fields (second sentence), and response nature (third sentence). No filler, front-loaded, every sentence adds unique value.

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

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

Given no parameters, no output schema, and annotations providing safety, the description is complete. It explains that the result is cached per session, the fields and their usage (e.g., id for updating categories, descriptionTranslated for Portuguese users), and that there are no batch IDs. Sufficient for an agent to use effectively.

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

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

There are no parameters (schema coverage 100%), so the description does not need to explain params. It instead describes the response fields (id, description, descriptionTranslated, parentId, parentDescription), which is helpful for understanding the return value. A baseline of 4 is appropriate for zero-parameter tools.

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

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

The description explicitly states the tool returns 'Pluggy's transaction category taxonomy' from a specific API endpoint (GET /categories). It distinguishes itself from sibling tools like openfinance_list_transactions by focusing on categories and explains the structure of entries with fields like id, description, and parentId.

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 mentions that the category id is used by openfinance_update_transaction_category and that descriptionTranslated is preferred for pt-BR users. However, it does not explicitly state when to use this tool vs alternatives like openfinance_list_accounts or openfinance_list_transactions, leaving the context implied.

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 non-destructive behavior. The description adds valuable details about the reconnect_url's behavior (update mode, no slot consumption) that 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 two sentences, front-loaded with the core purpose and then elaborating on a key feature. Every sentence is informative and concise.

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

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

Despite no output schema, the description fully covers the returned fields and special behaviors. With zero parameters, it provides all necessary 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?

There are no parameters, and schema description coverage is 100% (trivially). The baseline for 0 parameters is 4, and the description adds no parameter-specific information, which is appropriate.

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

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

The description clearly states it returns saved bank connections and lists specific fields. It distinguishes itself from siblings by mentioning unique elements like reconnect_url and add_connection_url, making the tool's 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 provides guidance on using the reconnect_url for re-authentication scenarios, but does not explicitly compare to sibling tools. However, the context of listing connections is clear, and the reconnect use case is well explained.

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, idempotentHint, destructiveHint, so the tool is safe and read-only. The description adds substantial behavioral context: the complex payment_status derivation, open bill projection logic with confidence levels, connector asymmetry (upstream limitations), warning behaviors for product not enabled, and the fact that include_open_bill incurs extra cost. It also explains what happens when per-transaction grouping doesn't reconcile. This is far beyond typical disclosure.

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 headings (IMPORTANT, OPEN BILL & TOTAL DEBT, CONNECTOR ASYMMETRY). It is front-loaded with the core purpose. Some details about payment_status derivation and open bill logic could be streamlined, but every piece of information serves a purpose given the tool's complexity. It could be slightly more concise without losing critical context.

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

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

Given the tool's complexity (5 parameters, no output schema, annotations present), the description covers all essential aspects: return fields, payment status logic, open bill projection with confidence, connector asymmetry, warnings, bulk support, and cross-references to sibling tools. It even addresses edge cases like bill grouping reliability and multi-bank scenarios. No gaps remain for typical usage.

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

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

Schema description coverage is 0%, so the description must compensate. It does well for key parameters: account_id (required), account_ids (bulk support), include_open_bill (detailed explanation of opt-in behavior). However, page and page_size are not explicitly described beyond their names in the schema. While pagination may be assumed, explicit mention would improve clarity. Overall, the description adds significant meaning for 3 of 5 parameters, earning a 4.

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

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

The description clearly states the tool returns CLOSED credit card bills for a CREDIT-type account, enumerates returned fields like dueDate, totalAmount, and derived payment_status. It distinguishes from sibling tools by mentioning openfinance_list_transactions for itemized charges and openfinance_get_credit_card_bill for individual bills. The verb 'Returns' with specific resource and scope makes the purpose unmistakable.

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 extensively covers when to use this tool, including explicit alternatives: 'To see itemized purchases/charges, use openfinance_list_transactions' and caution against summing transactions by billId. It specifies when to use include_open_bill (opt-in) and when not to (connector asymmetry). It also instructs to cross-check account echo for multi-bank scenarios. This is exemplary usage guidance.

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

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

Annotations already declare readOnlyHint and non-destructive; description adds critical details about data integrity handling, mass zeroing checks, and warning flags, providing 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?

Description is front-loaded with the main purpose but then dives into a lengthy data integrity section that could be simplified or moved to a separate note. The technical details make it verbose.

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 return format ({ total, results, warning }) and error handling well. However, lacks details on pagination (page, page_size) and parameter interaction, leaving some gaps given the complexity and no output schema.

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

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

Schema coverage is 0%, but description only explains item_ids briefly. Other parameters (page, page_size, type, item, item_id) lack any description of their purpose, format, or constraints, leaving ambiguity.

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

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

Description clearly states it returns the investment portfolio for a connection, listing various types (FIIs, stocks, ETFs, etc.). The verb 'Returns' and specific resource are well-defined, and the tool is distinct from siblings like openfinance_list_accounts.

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

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

Provides context for when to use (INVESTMENTS enabled) and mentions bulk support. However, it does not explicitly differentiate from openfinance_list_investment_transactions or give when-not-to-use scenarios.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, establishing it as safe and idempotent. The description adds value by detailing the output fields (quantity, value, expenses, etc.) and transaction types, enriching understanding 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 concise with two sentences, front-loading the core purpose. However, it could be structured to list parameters explicitly. Still efficient and clear for the most part.

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 4 parameters, no output schema, and no parameter descriptions, the description partially compensates by listing output fields but leaves out pagination behavior and parameter details. It is adequate but not fully complete for an agent to invoke correctly without additional inference.

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% with no parameter descriptions. The description only indirectly mentions investment_id and investment_ids for bulk support, but fails to explain pagination parameters (page, page_size) or the required nature of investment_id. This is a significant gap for an agent.

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 movement history for a specific investment position, listing transaction types (BUY, SELL, etc.) and distinguishes from the sibling openfinance_list_investments by directing to use it afterward to obtain the investment_id.

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

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

The description explicitly states 'Use after openfinance_list_investments to get the investment_id', providing clear context and order-of-operations guidance. It also notes bulk support, but does not explicitly mention when not to use or 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 show readOnly, idempotent, non-destructive. Description adds sequential querying with rate-limit spacing and return format {results, errors}. 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 with purpose. Every sentence adds value. No fluff.

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

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

Complex tool with array parameter and sequential behavior, but description covers purpose, parameter usage, and return format. Minor gap: no mention of error handling per connection beyond returning errors field.

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 fully explains the `items` parameter: array of connection selectors (item_id uuid, connector_id, or connector_name) and that omitting lists all banks. Excellent compensation.

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 lists loan contracts per bank connection and specifies the endpoint (GET /loans). It distinguishes from siblings like openfinance_get_loan_detail by mentioning per-connection 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?

Describes when to use `items` (for specific connections) and when to omit (all banks). Mentions sequential querying with rate-limit spacing. Lacks explicit 'when not to use' but context is clear.

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

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

The description discloses many behavioral traits beyond annotations: pagination behavior (auto vs manual, 5000 ceiling, truncation), error handling (returns {total:0, results:[], warning, error}), detail levels and their implications, and caveats about creditCardMetadata.billId being a per-connector hint. Annotations already declare readOnlyHint=true and idempotentHint=true, and the description adds significant 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 long but well-structured, with clear sections on pagination, detail levels, and credit card specifics. It front-loads the core purpose. While verbose, the complexity of the tool justifies the length. A minor trim could improve conciseness, but it remains highly usable.

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

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

Given the tool's complexity (8 parameters, no output schema), the description is exceptionally complete. It covers all relevant aspects: filters, pagination, detail levels, error scenarios, credit card metadata nuances, bulk support, and integration with other tools (e.g., openfinance_get_item_status, openfinance_list_accounts). The response structure is explained.

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

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

Schema description coverage is 0%, but the description fully explains all parameters: from/to (ISO YYYY-MM-DD), page/page_size (default vs manual, defaults, max), detail (compact/rich/raw with usage guidance), search_queries (case-insensitive, OR semantics), account_id and account_ids. It adds meaning beyond the schema's bare property definitions.

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

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

The description clearly states it returns transactions for bank accounts (BANK or CREDIT type), and for CREDIT accounts it is the only way to get itemized transactions. It distinguishes from sibling tools like openfinance_list_credit_card_bills and openfinance_list_accounts by specifying their roles.

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 extensive guidance on when to use this tool vs alternatives, e.g., for open bills use openfinance_list_credit_card_bills. It explains pagination choices (default vs manual), when to narrow date ranges, and how to handle truncation. It also advises checking connection health when total is zero for CREDIT accounts.

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

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

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description discloses important behavioral traits: 5000/account scan cap with truncated flag, provider_incident block for incomplete data, and bulk support via item_ids. These add significant context for safe usage.

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 well-structured: a clear opening sentence followed by parameter details and usage examples. It uses markdown (backticks) effectively and avoids redundancy, though it could be slightly more terse.

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 format for both monthly and raw granularities, including the compact summary fields and the truncated flag. It also covers error/incomplete data scenarios, making it complete 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?

The description explains most parameters (item, from/to, granularity, detail, type, item_ids) in context, but top_n is not described, and the distinction between item, item_id, and item_ids is unclear. With 0% schema description coverage, more clarity on these parameters would improve 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 description clearly states it performs consolidated cash-flow analysis for a bank connection, resolving accounts internally and fanning out transactions. It explicitly distinguishes itself from openfinance_list_accounts by eliminating the need for that prior call. The verb 'analyze' and resource '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 provides clear usage context: pass 'item' for one bank or omit for all banks; use 'granularity:raw' only when itemized rows are needed; lists use cases like 'fluxo de caixa'. However, it does not explicitly compare to the sibling openfinance_list_transactions or state when to avoid 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 already indicate readOnly, idempotent, non-destructive. Description adds valuable behavioral context: it returns global indicator, degraded components, open incidents, and flags affected banks. No contradiction with annotations; description enriches 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?

Two sentences, front-loaded with main purpose, then usage guidelines, then return details. The second sentence is somewhat long but packs necessary information. Could be split for readability, but overall efficient.

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

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

For a zero-parameter tool with no output schema, the description fully explains the return value and how it distinguishes provider issues from connection issues. It also lists sibling tools and differentiates itself, providing complete context.

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

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

No parameters in input schema (0 params), so baseline is 4. The description correctly does not add parameter information since none exist. Schema coverage is 100% trivially.

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 checks the LIVE operational status of the Open Finance provider, distinguishing it from sibling openfinance_get_item_status, which checks your own connection. The verb 'checks', resource 'Open Finance provider', and explicit separation from the sibling tool provide exceptional purpose clarity.

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

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

Explicitly states when to use: 'whenever data looks incomplete or stale even though a connection shows UPDATED'. It also explains the alternative openfinance_get_item_status and provides a clear decision rule (provider-side problem vs connection issue). This is exemplary 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 declare readOnlyHint=true and destructiveHint=false, confirming safety. The description adds detailed behavioral context: it returns a connect_url, honors user plan, includes caveat warnings, and explains the PF/PJ logic—all 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 a single dense paragraph containing many details. While informative, it could benefit from bullet points or separation of distinct instructions (e.g., caveats, plan behavior) for easier scanning. It is not overly long but lacks structure.

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

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

The description covers the tool's input parameters, return values (connector id, access, audience, connect_url, etc.), and edge cases (non-Open-Finance caveats, plan filtering). Without an output schema, the description adequately informs the agent of the response shape. However, pagination or result limits are not mentioned, slightly diminishing completeness.

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 purpose of keywords (search terms) and include_accounts (boolean to include accounts). It even gives an example for keywords. However, it states keywords is REQUIRED while the schema shows no required fields, which is a minor inconsistency.

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

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

The description clearly states the tool searches bank connectors by name and lists the returned fields. It distinguishes itself from siblings by explicitly positioning it as a pre-connection search tool ('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?

The description provides explicit when-to-use guidance ('Call this BEFORE connecting'), explains that keywords[] is required (without it returns a hint), and advises preferring Open Finance connectors over those with caveats. It also clarifies plan-dependent behavior.

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 the side effect of creating a Category Rule for future transactions, and batch behavior with partial errors. Annotations (readOnlyHint=false, destructiveHint=false) are consistent and description adds significant context beyond them.

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

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

A single paragraph that is somewhat lengthy but well-organized with front-loaded purpose. Every sentence adds value; minor verbosity acceptable for 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?

Covers complex batch behavior, side effects, error handling, and return format despite no output schema. Provides complete guidance for correct invocation.

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

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

With 0% schema description coverage, the description fully explains the items array structure, sources of transaction_id and category_id, and the response shape. Provides essential meaning not in 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?

Description clearly states the verb 'corrects the category' and the resource 'one or more transactions', specifying the HTTP method. It references sibling tools for obtaining IDs, distinguishing its 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?

Explicitly explains when to use (fix miscategorizations, improve future categorization) and implies when not to (if side effects undesired). References sibling tools for required IDs.

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

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

Annotations already indicate idempotentHint=true and destructiveHint=false, covering safety. The description adds minimal behavioral context beyond the usage hint about conversation; it doesn't disclose traits like server-side effects, rate limits, or what happens after submission.

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

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

The description is a single concise sentence that directly states the tool's purpose and a key usage hint. It is front-loaded and efficient, though it could be slightly more structured to separate purpose and guidelines.

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 low parameter documentation (0% coverage), the description does not fully equip the agent to use the tool. The required 'message' parameter is not described, and the overall return or effect is not mentioned. The inclusion of 'conversation' is helpful but insufficient for complete 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?

Schema description coverage is 0%, so the description should compensate. It only mentions including the 'conversation' array, but does not explain the 'message' parameter (required) or the 'context' parameter. This leaves the agent with incomplete understanding of how to correctly fill the 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 is for reporting bugs, missing features, or sending feedback. It uses specific verbs ('report', 'send') and names the resources ('bug', 'feature', 'feedback'), distinguishing it from sibling tools that primarily deal with financial data operations.

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

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

The description instructs to 'include the conversation array with recent messages for reproduction', providing a clear usage hint. However, it does not specify when not to use the tool or mention alternatives, so the guidance is implicit rather than explicit.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds that it shows platform and adapter versions, but does not go beyond the safety profile already disclosed by 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 with no wasted words. It is front-loaded and 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?

The tool is simple with no parameters or output schema. The description fully covers what it does, making it complete for an informational tool.

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

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

No parameters exist, and schema coverage is 100%. With zero parameters, the description does not need to add param info; baseline is 4.

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

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

The description clearly states it shows MCP platform and adapter versions, using a specific verb and resource. It is distinct from all sibling tools, none of which serve this 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 implies usage for checking versions, but provides no explicit when-to-use or when-not-to-use guidance. There are no alternatives mentioned, and the context makes the use case clear, but formal guidance is absent.

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 known. The description adds the specific informational payload (installed MCPs, status, accounts, tool counts), which is useful context beyond the annotations and gives a clear picture of the returned data.

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

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

The description is a single sentence, front-loaded with the main verb and object ('Returns the current toolkit state'), and efficiently lists the key details. No wasted words.

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

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

For a zero-parameter informational tool, the description sufficiently covers what is returned and the context. There is no output schema, but the description enumerates the main result components, making it complete for the tool's simplicity.

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

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

The tool has zero parameters, so schema coverage is trivially 100%. Per the rubric, 0 params receive a baseline score of 4. The description correctly implies no inputs are needed.

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

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

The description clearly states the tool 'Returns the current toolkit state' and enumerates specific elements (installed MCPs, connection status, connected accounts, catalog tool counts). This distinguishes it from sibling tools like openfinance_list_connections or openfinance_provider_status, which focus on narrower aspects.

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 for when to use this tool: when an overall summary of the toolkit is needed. It does not explicitly name alternative tools or exclusions, but the scope is well-defined, and the high-level nature is evident from the listed contents.

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