Atacadão MCP

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

Description adds context beyond annotations: explains that authentication can be permanent or session-based, that token can be provided to set session, or omitted to get a link. Consistent with idempotentHint (calling with same token idempotent), no contradiction.

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

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

Description is moderately concise, front-loaded with purpose. Every sentence adds value (purpose, methods, best practice). Could be slightly tighter 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?

Covers key scenarios: permanent vs. session, how to obtain token, how to use. Lacks details on return values or error handling, but sufficient for typical authentication flow without 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 has 0% coverage for the one parameter 'token'. The description compensates fully: explains that token is optional, what it represents (JWT access token), and behaviors for providing it vs. not. 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?

The description clearly specifies the tool's role: authenticating to MCP.AI for IDE agents. It details two methods (config-based permanent token or session-only via paste) and distinguishes the resource (access token, login) effectively.

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

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

Provides explicit usage guidance: when to use config vs. paste, step-by-step instructions (log in, copy token, paste), and best practices. Does not explicitly exclude siblings but the guidance is clear and actionable.

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 specific details about response content in different states, such as 'authenticated:true' or 'connect_url'. 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?

Two sentences, front-loaded with the core purpose. No wasted words; each sentence provides distinct and useful 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 stateless status check with no parameters and no output schema, the description fully explains the return value behavior, making it self-sufficient.

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

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

There are no parameters, so the description does not need to add parameter semantics. Baseline of 4 is appropriate given 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 returns connection status and URLs, with specific conditions for connected vs missing credentials. It distinguishes itself from sibling tools like 'authenticate' by focusing on status rather than authentication flow.

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

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

The description implicitly guides usage by explaining what the tool returns, but it does not explicitly state when to use it versus alternatives. However, the purpose is clear enough for an agent to infer.

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

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

Beyond the sparse annotations, the description discloses crucial behaviors: invoke runs tools even when not installed, returns connect/checkout links on auth/payment issues, requires workspace owner/admin for writes, and flags installed_in_toolkit vs installed_in_workspace. 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 long but every sentence earns its place. It flows logically from the core flow (search→describe→invoke) to the key invoke-vs-install distinction, then to billing/auth/owner requirements, and finally to the prompt library. No fluff 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?

Given the tool's complexity (14 actions, 23 params), the description covers the core flows, edge cases (credentials, payment, permissions), and the prompt library thoroughly. It lacks explicit return formats for some actions (e.g., search results, list_tools), but with no output schema, it still provides enough context for an agent to use the tool 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?

With 0% schema coverage, the description meaningfully explains the main parameters through the workflow (action, mcp_id, tool_id, arguments, prompt_slug, etc.). However, it does not explicitly define all 23 params (e.g., conversation, report_context, immediate, tier_slug), though many are inferable from action names.

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

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

The description states the tool is 'The official mcp.ai marketplace — the in-platform catalog of every MCP/tool, AND the way to run them.' This gives a specific verb+resource (catalog and run) and clearly distinguishes it from sibling openfinance tools as the central hub for discovering and executing MCPs.

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

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

It explicitly explains when to use invoke vs install ('prefer invoke for a single/occasional use', 'Use install only to make an MCP PERMANENT'), and covers all other actions: list_tools for callable tools, subscribe/cancel for billing, request_mcp for new MCPs, and separate prompt library actions. This is excellent when-to-use guidance.

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

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

Annotations already mark destructiveHint=true, indicating irreversible action. The description adds behavioral details: revokes consent, deletes data, and returns a reconnection URL. This goes beyond annotations by explaining the post-action state and the ability to reconnect, which helps an agent understand consequences.

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 consists of two concise sentences that efficiently convey the core action and outcome. No unnecessary words, front-loaded with the key verb 'Revokes'. Every sentence adds value.

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

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

For a destructive tool with one parameter and no output schema, the description covers the action and result adequately. However, it lacks parameter documentation, reducing completeness. The return value (add_connection_url) is noted, which is helpful for post-action steps.

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 and no explanation of the 'item' parameter in the description, the agent has no guidance on what to pass. The description does not mention the parameter at all. For a single required string parameter, the description fails to add meaning beyond the schema.

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

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

The description clearly states the tool's function: revokes Open Finance consent for a specific bank, deletes connection data, and makes bank data unavailable. It also notes the return of an add_connection_url for reconnection. This distinguishes it from siblings 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?

Description provides no explicit guidance on when to use this tool versus alternatives. It does not specify prerequisites, cautionary notes, or scenarios where other tools might be more appropriate (e.g., pausing vs. disconnecting). The only hint is the destructive nature, but no direct comparison with 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?

Describes polling up to 60s, timeout behavior, fire-and-forget mode, and handling of needs_action with reconnect_url. Consistent with annotations (readOnlyHint=false, destructiveHint=false).

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

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

Long but efficient; every sentence adds value. Well-structured: main action, usage, parameters, return value, special 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?

Covers all important aspects: behavior, parameters, return format, error states, timeout, fire-and-forget. Adequate for a complex tool with 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 has 0% coverage, but the description fully explains both parameters: 'items' as an array of selectors with examples, and 'wait' for fire-and-forget mode.

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

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

The description explicitly states it forces a bank to re-sync one or more connections and waits for completion. It distinguishes from sibling tools by specifying the use case for stale balances/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?

Provides explicit guidance on when to use ('when a balance or transaction list looks stale'), and what alternatives exist (re-check with openfinance_get_item_status on timeout).

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, covering safety. The description adds meaningful behavioral context: balance is a snapshot anchored to the last upstream sync, not a live read; certain errors are returned as structured `warning` rows rather than thrown exceptions; and specific error codes like BALANCE_FETCH_ERROR and BALANCE_CONSENT_ERROR are explained. This goes beyond the annotations and helps the agent interpret unusual responses correctly.

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

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

The description is dense and detailed, and the core purpose is front-loaded. Every sentence adds useful information about freshness, error handling, or usage guidance. It is longer than a minimal description, but the length is justified given the nuanced sync and error behavior, and it remains well-structured with clear cause/effect statements.

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

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

For a single-parameter read tool, the description covers the most important operational context: staleness semantics, the relationship to force_sync, the array constraint, and credit-account error handling. There is no output schema, so the mention of `updateDateTime`/`updatedAt` and the structured `warning` helps set expectations. It does not describe pagination, but with a 1–50 array limit that is less critical. Overall it is adequately complete for an agent to call this tool correctly in most real 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 must carry parameter meaning. It does: it explains that `account_ids` should be passed as an array of 1–50 items. It does not enumerate all array element semantics beyond that, but for a single-parameter tool this is sufficient and directly compensates for the schema's lack of description.

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 latest available balance per account id, specifies the exact endpoint (GET /accounts/:id/balance), and distinguishes itself from related list operations. It gives the agent a precise verb-resource pairing (get account balance) that is unambiguous even among many openfinance siblings.

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

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

The description explicitly explains when to use this tool, when the data may be stale, and names the alternative (openfinance_force_sync) to run first if fresher data is needed. It also addresses error conditions and consent failures, so the agent has clear routing and remediation 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?

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description reveals critical behavioral details: the batch response shape, provider_incident block, and warnings about unreliable values during provider incidents.

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 the main purpose first, followed by usage details and a warning. It is concise with no unnecessary words, though slightly longer due to the provider incident note.

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 primary function, batch shape, and a specific edge case (provider incident). It lacks explicit detail on return value structure, but given no output schema, the description provides adequate context for a single-parameter tool with safety 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?

Although schema coverage is 0%, the description adds the crucial constraint that account_ids must be an array of 1-50 strings, which is not present in the schema. This significantly aids correct parameter 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 'Returns full account objects including extended creditData per id' and specifies the HTTP method and endpoint path. It distinguishes itself from siblings like openfinance_list_accounts by being a batch detail retrieval for specific IDs.

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

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

The description implicitly indicates usage is for fetching detailed account data by IDs, but it does not explicitly compare to other tools or provide when-to-use 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?

Despite having `readOnlyHint` and `idempotentHint` annotations, the description adds rich behavioral caveats: the bill payload does not include transactions, `transactions_basis` can be estimate vs exact, and `payments[]` may refer to previous bills. These details prevent incorrect agent reasoning.

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 organized into functional sections and front-loads the purpose. Every sentence provides decision-relevant information about fields, transaction boundaries, paid-status caveats, or batch responses. A small amount of redundancy could be trimmed, but overall it is structured 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?

Without an output schema, the description properly carries the burden of explaining return fields, transaction basis, paid-status pitfalls, and batch response shape. It also provides cross-tool references, making the description complete for runtime decision-making.

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?

Since the schema has no parameter descriptions, the description compensates well. It explains that `bill_ids` is an array discovered via a sibling endpoint, explains the relationship between `include_transactions`, `account_id`, and `transactions_basis`, and clarifies `transactions_detail` usage for rich/raw. It could explain the exact shape differences between `compact`, `rich`, and `raw` further, but the core semantics are 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?

The description clearly states the resource ('credit card bills by id') and the verb ('Returns bill-level detail'), and names exact fields. It also distinguishes itself from sibling tools by explicitly telling users to use `openfinance_list_credit_card_bills` for paid status.

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

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

The description provides clear when-to-use and when-not-to-use guidance. It instructs the agent to discover `bill_ids` through `openfinance_list_credit_card_bills`, to pass `account_id` and `include_transactions` for itemized transactions, and to avoid this method for paid status.

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

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

Annotations already indicate readOnly, idempotent, non-destructive. The description adds valuable behavioral context: the reconnect_url reopens the widget in UPDATE mode without disconnecting or consuming a slot, and explains return format for both single and bulk queries. 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 three sentences, each carrying essential information: what is returned, how to use for single/all, and bulk support. No redundant text, front-loaded with key details.

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 three optional parameters, the description covers return values for single and all modes, bulk support, and behavioral traits. It doesn't explain error handling or parameter relationships (e.g., item vs item_id), but is largely complete for a read-only tool.

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

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

Schema description coverage is 0%, so the description must compensate. It explains 'item' and 'item_ids' but does not mention 'item_id', leaving its purpose ambiguous. While it adds meaning for two parameters, the third is underexplained.

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

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

The description clearly states the tool returns the current status of a bank connection, including specific fields like executionStatus and reconnect_url. It distinguishes single vs. all banks and mentions bulk support, making the purpose very specific compared to sibling tools.

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

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

The description explains when to use the tool (get status) and provides usage instructions for different cases: omit item for all, pass item for single, and bulk via item_ids. It does not explicitly mention when not to use or alternatives, but the context is clear.

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

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

The description adds context beyond annotations (which already declare readOnly, idempotent, non-destructive) by mentioning the HTTP method, path, and batch response shape with results and errors. It does not contradict annotations.

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

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

The description is a single dense paragraph that lists many fields but remains efficient. It could be slightly more structured, but it avoids unnecessary words.

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

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

Given no output schema, the description compensates by listing key response fields and indicating the batch shape. It is sufficient for an agent to understand the tool's output, though some details like error statuses are omitted.

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?

Although the schema has 0% description coverage, the description explains that loan_ids should be passed as an array of strings with a limit of 1-50. This adds practical 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 it returns full loan contract detail by ID, listing specific fields like interestRates, amortizationScheduled, etc. It distinguishes itself from openfinance_list_loans, which is a sibling tool for listing loans.

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 to use after openfinance_list_loans for deep-diving into a specific contract. It also specifies the array size limit of 1-50 and the batch shape. However, it does not mention 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?

Even with readOnlyHint and idempotentHint annotations already present, the description adds substantial behavioral context: `balance` can be connector-dependent, `balance_notice` indicates outstanding amounts when balance is zero, bankData extras may lag and require a force sync, provider incidents can make values unreliable, and identity_notice requires deduplication by account number. These are exactly the kind of non-obvious behaviors an agent needs to avoid misleading users.

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?

Though long, every section earns its place: the core return summary is front-loaded, followed by critical naming guidance, account selection instructions, and a series of warning signs that materially affect how results should be interpreted. The structure uses clear paragraphs and labels such as 'Note:', 'Bulk support:', and named notice fields, making the density navigable rather than bloated.

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 and no parameter descriptions in the schema, the description carries the full burden of explaining output semantics, edge cases, and alternatives. It covers the bank vs legal-entity name distinction, cross-connection aggregation, credit bill nuances, stale/lagging fields, provider incidents, joint-account deduplication, and bulk execution. The tool is complex, and the description is remarkably complete for safe and correct use.

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

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

The input schema has 0% description coverage, so the description must compensate. It does explain `item` (omit for all, pass for single), `item_ids` (bulk execution), and implicitly describes `type` by naming BANK and CREDIT account categories. However, the `item_id` parameter is only mentioned as a returned field tag, not explained as an input parameter, and the filtering behavior of `type` is not explicitly stated. This leaves some parameter meaning to inference.

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 accounts for bank connections, enumerates both account types (BANK and CREDIT), and lists the returned fields (balance, number, type, subtype, bankData, creditData). It also distinguishes itself from openfinance_list_credit_card_bills by specifying that standardized open-bill data comes from that sibling, making the purpose unambiguous even among many related tools.

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

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

The description explicitly tells the agent when to omit `item` to list accounts across all linked banks versus passing `item` to target a single bank. It also routes the agent to openfinance_list_credit_card_bills when standardized open-bill amounts or closed bills are needed, and mentions bulk support via `item_ids`. This gives clear, actionable selection 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, idempotentHint, destructiveHint. Description adds caching behavior, single aggregated response, and details about response fields, adding value 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?

Two sentences, each informative and front-loaded. No wasted words.

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

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

Given no parameters and annotations present, description covers caching, response structure, and relevance to another tool. Minor gaps like prerequisites, but adequate.

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, schema coverage 100%. Baseline 4 applies.

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 states it returns Pluggy's transaction category taxonomy, cached for the adapter session, and distinguishes from sibling tools by specifying it's a list of categories used by another tool.

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

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

Description implies usage for getting categories but does not explicitly state when to use vs alternatives or any exclusions. However, the tool is simple and context is clear.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds value by detailing the reconnect_url behavior (opens widget in UPDATE mode, does not consume slot) and explaining the output fields. No contradictions.

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

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

The description is informative but slightly verbose. It is front-loaded with the main purpose and includes necessary details. Could be slightly more concise, but 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?

For a tool with zero parameters and no output schema, the description provides complete context: it lists the output fields, explains the reconnect_url and add_connection_url usage, and covers behavioral details. Nothing essential is missing.

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

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

The input schema has 0 parameters, so no additional meaning is needed. Baseline score of 4 is appropriate as the description does not need to compensate for parameter 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 the tool returns saved bank connections and lists specific fields (connector_id, item_id, bank name, reconnect_url, add_connection_url). It distinguishes itself from sibling tools by focusing on listing connections and explaining the unique reconnect_url and add_connection_url.

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

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

The description explains when to use the reconnect_url (for re-authentication scenarios) and clarifies that it does not consume a connection slot or require disconnecting. It lacks explicit guidance on when not to use this tool versus alternatives like connect or authenticate, but the context of listing is clear.

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

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

Annotations confirm read-only, idempotent, non-destructive. Description adds critical context: payment status derivation logic, bill grouping reliability, connector asymmetry for open bill, and warning behavior. No contradiction with annotations.

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

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

Description is lengthy but front-loaded with the core purpose and structured logically. Each section addresses a specific concern (payment status, open bill derivation, connector asymmetry). Could be slightly more concise, but no redundant sentences.

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

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

Given no output schema, description thoroughly explains return structure, derived fields (`payment_status`, `open_bill`, `future_bills`), edge cases (connector asymmetry, grouping warnings), and essential usage guidance. Covers all five parameters adequately.

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 compensates by explaining `include_open_bill` (opt-in logic) and `account_ids` (bulk support). Pagination params (`page`, `page_size`) are not explicitly described but are standard. The description adds significant meaning beyond schema.

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

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

Description clearly states it returns closed credit card bills for CREDIT-type accounts, listing specific fields and derived attributes. It distinguishes from siblings like openfinance_list_transactions (which gets individual transactions) and openfinance_get_credit_card_bill (single bill).

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 describes when to use this tool (e.g., to get closed bills with payment status) and when not to (e.g., use openfinance_list_transactions for itemized purchases). Provides alternatives and warns about connector asymmetry for open 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?

The description goes well beyond annotations (readOnlyHint, idempotentHint, etc.). It details handling of errors, data integrity checks for mass zeroing, and flagging of suspect rows. 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 informative but somewhat lengthy. It is well-structured with overview, field details, error handling, and data integrity warnings. Every sentence adds value, though minor trimming could improve conciseness.

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

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

Given the complexity (multiple asset types, error modes, data integrity logic) and lack of output schema, the description covers key behaviors. However, it lacks details on pagination (page/page_size), sorting, and batch processing with item_ids.

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 should compensate but only briefly mentions item_ids for batched execution. The other five parameters (item, page, type, item_id, page_size) are not explained, leaving their semantics 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 that the tool returns an investment portfolio for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.). This differentiates it from sibling tools like openfinance_list_accounts or 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 implies usage for retrieving investment portfolios but does not explicitly state when to use this tool versus alternatives like openfinance_list_investment_transactions. It mentions error handling (returns empty for non-enabled investments) but lacks direct guidance on selection.

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

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

The description adds value beyond annotations by detailing the specific fields returned (quantity, value, netAmount, etc.) and the bulk feature. It aligns with annotations (readOnlyHint, idempotentHint, destructiveHint). It could mention pagination behavior but the schema already includes page and page_size, mitigating the gap.

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

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

The description is very concise: two short sentences plus one for bulk support. It front-loads the purpose and includes necessary details without redundancy or verbosity.

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

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

Given the tool has 4 parameters and no output schema, the description covers the main aspects: purpose, prerequisite, bulk support, and field details. It lacks explanation of pagination parameters but they are inferable from the schema. It is fairly complete for an agent to use the tool correctly.

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

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

Schema coverage is 0%, so the description must explain parameters. It explains the key parameters investment_id and investment_ids (bulk), but does not describe page and page_size, which are self-explanatory but still missing from the description. The explanation of core parameters is sufficient but not complete.

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 movement history for investment positions with specific transaction types (BUY, SELL, etc.) and details the fields returned. It distinguishes itself from sibling tools like openfinance_list_investments and openfinance_list_transactions by specifying the resource and prerequisite usage.

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 after openfinance_list_investments to obtain the investment_id, providing a clear prerequisite and sequence. It also mentions bulk support for batched execution. However, it does not explicitly state when not to use it or alternative tools for general 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, idempotentHint, destructiveHint), the description adds crucial behavioral details: sequential querying per connection, rate-limit spacing, and the return format `{ results, errors }` per connection. No contradiction with annotations.

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

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

Three sentences effectively front-load the purpose, then explain parameter usage and alternative behavior. No wasted words, and every sentence provides essential information.

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

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

Given no output schema, the description still covers return format, handling of multiple connections, and optional parameter behavior. It is fully adequate for a simple list tool with one parameter.

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?

Although schema coverage is 0%, the description thoroughly explains the `items` parameter: its value types (item_id uuid, connector_id, or connector_name) and the effect of omitting it (list across all linked banks). This adds significant meaning beyond the bare schema type 'array of strings'.

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 specifies the exact resource ('loan contracts per bank connection') and HTTP method ('GET /loans'), distinguishing it from sibling 'openfinance_get_loan_detail' which provides detail on a single loan.

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

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

The description clearly explains how to use the `items` parameter to target specific connections or omit it for all banks, and notes sequential querying with rate-limit spacing. It does not explicitly mention when not to use this tool, but the context is clear enough.

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

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

The annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description goes well beyond them with high-value behavioral context: the auto-pagination that collapses results onto a single logical page, the 5000-transaction ceiling that sets truncated:true, the inconsistent per-connector PENDING/POSTED coverage, the deterministic scheduled/interrupted behavior (future-dated installments at the top of a DESCENDING list), and the explicit failure contract that returns { total:1, results:[], warning, error } instead of throwing. Nothing in the text contradicts the read-only/idempotent 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 effectively a mini-manual with uppercase section headers (CREDIT PENDING vs POSTED, SCHEDULED, PAGINATION) that make the density navigable, and nearly every sentence carries distinct operational value. However it is notably long and repeats the same billId/summing warning in two separate sections, and some sentences are dense and either overly long or interpreted; it earns a 4, not a 5, for what should be a structural exercise of tightening the duplicate 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?

Even though there is no output schema, the description covers the shape of the response almost completely: the account echo block, scheduled_count + notice, total/totalPages under both auto and manual pagination, truncated plus the warning, the provider_incident block, and the fallback contract for upstream errors. It also anticipates the real failure modes an agent will hit in practice — mismatched accounts, stale credit data, connector-sparse billId fields — and traverses them all, so no additional context is needed to invoke it correctly.

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

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

Schema description coverage is 1%, so the description takes the full burden of explaining parameters, and it does so thoroughly: from/to use ISO YYYY-MM-DD, search_queries means a case- and accent-insensitive substring match against description and merchant name with OR semantics across terms, detail is defaulting to a specific value and describes when to switch to 'rich' vs 'raw', page/page_size semantics differ radically depending on whether both are omitted, and each carries concrete defaults (50, max 500). The semantic contract is richer than the raw input schema alone, covering even the recommended widths and recommendations.

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 and resource immediately: "Returns transactions for a bank account (BANK or CREDIT type)" and further narrows the scope by saying "For CREDIT (credit card) accounts, this is the ONLY way to get itemized transactions", which distinctly separates it from siblings like openfinance_list_credit_card_bills and openfinance_list_transactions_by_item. The description even names the siblings an agent should favor for other purposes, making the tool's identity 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?

Provides explicit when-to-use and when-not-to-use guidance: it should be used for itemized credit card transactions, and NOT for computing a bill total ("Do NOT reconstruct a bill's total by summing transactions by billId" — use openfinance_list_credit_card_bills instead); for closing/due dates it routes to openfinance_list_accounts; for a zero-count credit account it routes to openfinance_get_item_status; and it tells the agent to narrow to the window with an action when truncated:true occurs. The guidelines name alternatives and conditions rather than leaving the agent to infer.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds important behavioral details beyond these annotations: the scan caps at 5000 transactions per account with a 'truncated:true' flag, and the presence of a 'provider_incident' block that indicates potential incomplete data. It also clarifies that reconnecting does not fix provider issues. No contradiction with annotations.

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

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

The description is relatively long but well-structured, starting with the core purpose then expanding into parameter details and behaviors. Every sentence adds value for the agent, especially given the tool's complexity (9 parameters, multiple granularities). It could be slightly more concise, but it is not overly 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?

Given the tool's complexity (9 parameters, no output schema, and annotations providing safety hints), the description is remarkably complete. It covers purpose, all parameter details, behavioral nuances (truncation, provider incidents), and provides concrete usage guidance. There are no missing pieces that would leave an agent confused.

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 9 parameters with 0% schema description coverage, so the description must compensate. It explains the meaning of most parameters: item (targets one bank or all), from/to (ISO dates), granularity (monthly vs raw), detail (compact, rich, raw), type (BANK or CREDIT), and item_ids (bulk support). However, the 'top_n' parameter is not explicitly described, though it is implied by 'largest N each.' This is a minor gap.

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

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

The description clearly states the tool's purpose: 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call.' It distinguishes itself from sibling tools like openfinance_list_accounts and openfinance_list_transactions by emphasizing that it resolves accounts internally and fans out transactions, so users don't need to call those tools first.

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

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

The description explicitly tells when to use this tool versus alternatives: 'so you do NOT need to call openfinance_list_accounts first nor carry account_id uuids between calls.' It also provides when to omit the item parameter for all banks, lists concrete use cases like 'análise anual/mensal', specifies when to use granularity 'raw' vs 'monthly', and warns about data caps and provider incidents.

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

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

Annotations already indicate readOnly, idempotent, and non-destructive. The description adds behavioral detail: returns global indicator, degraded components, open incidents, and flags affected banks. 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 paragraph with front-loaded first sentence stating core purpose. Every sentence adds value, though could be slightly more concise. 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 no output schema and zero parameters, the description is fully complete: explains return values, usage context, and how it integrates with connected banks.

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; baseline 4. The description adds meaning by explaining what the tool does, which is sufficient for a parameter-less tool.

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

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

Clearly defines the tool as checking the LIVE operational status of the Open Finance provider, distinct from the connection-level tool 'openfinance_get_item_status'. Uses specific verb+resource and differentiates itself among siblings.

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

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

Explicitly states when to use the tool (when data appears incomplete/stale despite updated connection) and what it reveals (upstream outage or incident). Lacks explicit when-not-to-use, but context is sufficiently clear.

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

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

Annotations declare readOnlyHint, idempotentHint, and non-destructive. The description adds significant behavioral context: caveat for non-Open-Finance connectors, plan-based visibility of banks, and the fact that the tool never dumps the entire catalog. 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 dense with information but well-structured and front-loaded. It includes example, caveat, plan behavior, and usage guidance. Every sentence adds value, though slightly verbose; still highly efficient.

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

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

Despite no output schema, the description details the return structure (connector id, access type, audience, linked connections, accounts, connect_url) and special behaviors (caveat warning, plan honors). It is fully complete for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It fully explains both parameters: keywords[] is required and returns a hint if omitted, with example usage; include_accounts triggers account details in the response. This adds complete semantic meaning.

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

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

The description clearly states the tool's purpose: searches bank connectors by name and returns connector details, a connect URL, and linked connections. It gives specific verb and resource, includes example keywords, and distinguishes from siblings by instructing 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?

The description explicitly states when to use this tool: 'Call this BEFORE connecting to hand the user a one-click link to the right bank.' It also explains the behavior of the required keywords parameter and the include_accounts option. However, it does not explicitly exclude alternative tools or provide when-not-to-use scenarios, but the context is clear.

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

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

Beyond annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=false), the description discloses that it overrides automatic categorization, teaches the system by creating a Category Rule (case-insensitive exact match) for future similar transactions, and details the batch response shape including per-item errors. This adds critical behavioral context.

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

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

The description is concise yet comprehensive, efficiently using each sentence to convey purpose, parameter structure, behavioral side effects, and response format. It is well-structured 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 the tool's complexity (batch update with side effects and no output schema), the description covers all necessary aspects: purpose, parameter format, behavioral implications, and response structure. There are no critical 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?

With 0% schema description coverage, the description fully compensates by explaining the items array structure, the meaning of each field (transaction_id, category_id), and where to obtain them from other tools. This provides complete parameter semantics 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 verb 'corrects' and resource 'category of transactions', specifies the API endpoint (PATCH /transactions/:id), and distinguishes from sibling tools by referencing specific related tools (openfinance_list_transactions, openfinance_list_categories) and the batch nature.

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 for use (fix miscategorized transactions and improve accuracy), tells where to get required IDs from sibling tools, and warns about the side effect of creating a Category Rule. However, it does not explicitly state when not to use the tool or mention alternatives beyond sourcing 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 declare non-destructive and idempotent behavior. Description adds that conversation array is needed for reproduction, which is useful but does not contradict annotations.

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

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

Two sentences, front-loaded with purpose, efficient without extra 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?

Simple tool with 3 params and no output schema. Description covers main purpose and one usage instruction, but lacks details on report handling or expected outcome.

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%. Description only explains the 'conversation' parameter, leaving 'message' and 'context' undefined beyond schema names. Does not fully compensate for 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 reports bugs, missing features, or feedback, using specific verbs and resources. It distinguishes itself from sibling financial 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?

Implied usage for reporting issues, but no explicit guidance on when not to use or alternatives. The instruction to include conversation array is helpful but doesn't cover avoidance 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?

The description adds context beyond annotations by specifying the exact information returned (MCP platform and adapter versions). 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?

Single, well-formed sentence that is perfectly concise and front-loaded, accomplishing the goal without any 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 zero parameters and no output schema, the description adequately explains the tool's behavior. It lacks detail on the exact format of versions, but this is acceptable for a straightforward version display 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, so baseline score of 4 applies. The description correctly indicates no input is 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 shows current MCP platform and adapter versions, distinguishing it from all sibling tools which perform authentication, data retrieval, or financial 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 is clear about what the tool does and implies it should be used when version information is needed. No exclusion or alternative guidance is necessary given the tool's 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, so the tool's safety profile is covered. The description adds meaningful context by specifying the exact content of the returned state (installed MCPs, connection status, accounts, catalog tool counts), which goes beyond the annotations and helps the agent understand what to expect.

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

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

The description is a single, well-structured sentence that front-loads the key verb 'Returns' and immediately specifies the resource. Every word adds value, and there is no redundancy or 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, parameterless info tool, the description is complete. It fully explains what the tool returns, covering the key aspects an agent would need to know. No output schema exists, but the description enumerates the return content sufficiently. No additional context is necessary.

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

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

The tool has zero parameters, so the description does not need to explain parameter semantics. The schema coverage is trivially 100% with an empty properties object. A baseline score of 4 is appropriate for a parameterless tool.

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

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

The description clearly states the tool's function with a specific verb ('Returns') and resource ('current toolkit state'), listing the exact components returned (installed MCPs, connection status, accounts, catalog tool counts). It does not explicitly distinguish this from siblings like show_version, but the purpose is 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?

No guidance is provided on when to use this tool versus alternatives such as show_version, report_bug, or the openfinance_* tools. The description only states what the tool does, without any mention of scenarios, prerequisites, or exclusions.

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