Itaú MCP

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

Discloses that calling with no args returns a login link, and with token sets the session. No destructive behavior is indicated, consistent with annotations (destructiveHint: false). However, it does not mention what happens on error (e.g., invalid token) or whether credentials are stored, a minor gap. No annotation contradiction detected.

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 (multiple clauses per sentence). It front-loads the intended audience (MCP.AI for IDE agents) which is good, but could be tightened without losing clarity.

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

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

For a simple authentication tool with no output schema, the description covers the main use cases. However, it lacks information about return values (e.g., status message after token set) and error handling, which would be helpful for an AI agent.

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

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

Schema coverage is 0%, but the description explains the single parameter 'token' as an optional JWT for session-only login. It adds context that 'no args' returns a link, clarifying 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 it is for authentication, specifying the action (log in, copy token) and the resource (this server). It distinguishes from sibling tools like 'connect' which likely handles OAuth flows, by focusing on token-based auth and permanent vs session credentials.

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: for session-only vs permanent setup. It explains the alternative of adding token to config for permanent connection, and when to call with or without args. This helps the agent decide which invocation method to use.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds scenario details about return values (authenticated vs connect_url) but does not disclose additional behaviors like rate limits or authentication requirements 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 consists of two sentences, efficiently front-loading the main purpose and key conditional details. No extraneous words or fluff.

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

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

The description covers the primary states (connected and missing credentials) for the return values. However, it does not mention error scenarios or other potential states (e.g., partial connectivity). Given zero parameters and good annotations, it is mostly 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 input schema has zero parameters, and schema description coverage is 100%. With no parameters, the description does not need to add parameter semantics; a baseline of 4 is appropriate.

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

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

The description clearly states the tool returns connection status and URLs, with specific conditions for connected vs missing credentials. However, it does not explicitly distinguish from sibling tools like 'authenticate' or 'marketplace', which may have overlapping purpose for connection-related 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 implies the tool is for checking connection status but does not provide explicit guidance on when to use it versus alternatives, such as 'authenticate' for initiating connections. No exclusions or when-not-to-use are mentioned.

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

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

The description discloses behavioral traits beyond annotations, such as that invoke works for uninstalled MCPs, that writes require workspace owner/admin, and that invoke may return connect or checkout links. It adds context about installed_in_toolkit vs installed_in_workspace, which annotations alone do not 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 structured with an initial purpose, core flow, and action-specific guidance, but it is verbose. Multiple sentences could be condensed without losing meaning (e.g., the note about 'pontualmente' and 'bloating'). It front-loads key information but overall lacks 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 (15 parameters, no output schema), the description omits details on many parameters and does not specify return values for each action. It covers high-level behavior but leaves gaps in input/output expectations, making it incomplete for thorough tool 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?

With 0% schema description coverage, the description only partially compensates. It explains the 'action' parameter and its values, and implies 'tool_id' and 'arguments' for invoke, but leaves 10+ parameters (e.g., limit, query, message, immediate, tier_slug, conversation) undocumented in both schema and 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 the tool is the official mcp.ai marketplace for discovering and running MCPs, with specific verb-resource combinations (search, describe, invoke, install, etc.). It distinguishes from external registries and sibling tools by stating 'use THIS tool FIRST, before any external/generic registry.'

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 each action (e.g., 'prefer invoke for a single/occasional use' vs install for permanent addition) and how to handle scenarios like missing credentials or empty wallet. It also contrasts invoke vs install and explains the core flow step-by-step.

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 aligns with annotations (destructiveHint=true) and adds context: 'The bank's data will no longer be available' and 'Returns an add_connection_url to re-connect if needed.' This provides clarity beyond the annotations.

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

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

The description is two sentences, no wasted words, and front-loaded with the primary action. It is efficient and directly conveys the tool's purpose and key effect.

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

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

The tool has low complexity (one required param, no output schema). The description covers the effect and a return value, but missing parameter documentation reduces completeness. It is adequate but not comprehensive.

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

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

The schema coverage is 0%, and the description does not explain the 'item' parameter. The agent cannot determine what value to provide, even though the tool name suggests it's a bank identifier. The description should document this parameter.

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

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

The description clearly states the action (revokes consent, deletes data) and the resource (a specific bank's connection). It distinguishes from siblings like openfinance_list_connections or openfinance_force_sync by focusing on disconnection and deletion.

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: when a bank connection needs to be revoked. It mentions returning a reconnection URL, hinting at post-use behavior. However, it lacks explicit when-not-to-use or direct 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?

Description adds context beyond annotations: waits up to ~60s, polls until done, returns fields like status, executionStatus, lastUpdatedAt, synced, and error conditions (needs_action, timed_out). 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 somewhat verbose but every sentence adds value and key information is front-loaded. A bit long but efficient given the complexity.

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

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

Complete for a complex sync tool: covers input, output format, error states, and alternative usage (fire-and-forget). No output schema, but description adequately covers return values.

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 fully explains parameters: items as array of selectors (item_id, connector_id, connector_name) and the wait boolean, including the special case of omitting items to sync all.

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

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

The description clearly identifies the tool as forcing a bank to re-sync connections and waits for completion. It distinguishes from siblings like openfinance_get_item_status by specifying when to use this tool vs checking 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?

Explicit when-to-use (stale balance/transactions) and when-not (no disconnect/reconnect). Provides alternatives like openfinance_get_item_status for timed_out cases and mentions fire-and-forget option with wait:false.

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 significant detail beyond annotations, including error handling with structured warnings, degradation behavior with realtime: false, and response shape. No contradiction with annotations (readOnlyHint, idempotentHint, destructiveHint).

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

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

The description is detailed but each sentence adds value. It is front-loaded with the core purpose and then covers edge cases and response format. Minor room for slight tightening.

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 a simple tool with one parameter and no output schema, the description fully explains inputs, edge cases, and response structure. It is complete for an agent to understand and use correctly.

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

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

The only parameter account_ids is described as an array of 1-50 strings, adding constraints not in the schema (no min/max). With 0% schema description coverage, the description compensates well.

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 payload per account id' and specifies the endpoint. It distinguishes from siblings like openfinance_list_accounts by focusing on balance retrieval for specific account 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 explains when to use the tool and covers edge cases (CREDIT accounts, upstream 5xx errors). It does not explicitly state when not to use or mention 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?

Adds valuable behavioral context beyond annotations: warns about provider_incident blocks causing unreliable credit limits/balances and instructs not to present those values as real. Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which align with the description.

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

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

Three sentences, no redundancy. Front-loaded with the core purpose, followed by parameter usage and a notable behavioral note. Every sentence earns its place.

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

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

Covers the main functionality, parameter constraints, and an important edge case (provider_incident). Lacks explicit mention of typical fields or response structure beyond the batch shape, but given no output schema, it is reasonably complete.

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

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

The schema has 0% description coverage, but the description compensates by explaining that account_ids should be an array (1–50) and that the response has a batch shape { results, errors }. This adds meaning beyond the bare schema.

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

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

The description clearly states 'Returns full account objects including extended creditData... per id', indicating the tool fetches detailed account data by ID. It distinguishes itself from siblings like openfinance_list_accounts by mentioning extended creditData, but does not explicitly contrast with other 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?

Implicitly suggests using this tool when full account details are needed, as it says 'Returns full account objects including extended creditData'. However, there is no explicit guidance on when not to use it or direct alternatives like openfinance_list_accounts for summary data.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description adds critical behavioral details: batch shape { results, errors }, absence of paid/status field, and nuance that payments[] may refer to previous bill payment. No contradiction with annotations.

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

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

The description is concise yet comprehensive, front-loading the purpose and adding essential behavioral context without redundancy. Every sentence contributes 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 output schema, the description adequately describes return fields (financeCharges, payments with subfields), batch shape, and addresses complexity like paid status and payments meaning. It is complete for the tool's scope.

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 compensates by explaining that bill_ids is an array and should be obtained from openfinance_list_credit_card_bills. It adds meaning beyond the bare schema but could provide more detail on ID format.

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, and distinguishes from sibling tools by specifying it does not return individual transactions and recommending openfinance_list_transactions for that purpose.

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

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

The description explicitly guides when to use this tool (after discovering IDs via openfinance_list_credit_card_bills), when not to use it (e.g., to avoid reconstructing bill totals), and provides an alternative tool (openfinance_list_transactions) for itemized transactions.

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

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

Annotations already indicate readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds value by specifying the returned data (status, executionStatus, metadata) and the dual response shapes. No contradiction with annotations.

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

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

Two sentences that are front-loaded with purpose and usage. Every word earns its place; no redundancy or fluff.

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

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

For a simple tool with one optional parameter and no output schema, the description covers both usage modes and the output structure. It does not mention error cases or potential null status, but completeness is 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?

Schema coverage is 0%, so the description must compensate. It explains that omitting 'item' returns all banks and passing it returns a single bank. It could specify the type or format of 'item' more precisely, but the name and context are sufficient.

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

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

The description clearly states it returns the current status of a bank connection, listing possible status values and mentioning executionStatus and connector metadata. It distinguishes between querying all linked banks versus a single bank via the optional 'item' parameter, which sets it apart from sibling tools like openfinance_list_connections.

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

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

It explicitly explains when to omit or pass the 'item' parameter, and describes the return shapes for each case. It does not explicitly mention when not to use this tool or alternatives, but the context is clear enough for an agent to decide.

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

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

Annotations already declare readOnlyHint and destructiveHint. The description adds value by specifying the response shape ({ results, errors }), the array size limit (1-50), and the batch behavior. 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 a single dense paragraph covering all necessary elements without wasted words. It could be slightly more structured but remains efficient.

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

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

Given no output schema, the description covers purpose, usage context, parameter constraints, and response fields. It lacks error specifics but is complete enough for an AI agent to use correctly.

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

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

Schema description coverage is 0%, but the description fully compensates: it explains the loan_ids parameter type and constraint (array of 1-50), and details the response structure with specific fields listed. Adds significant 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 returns full loan contract details by ID, listing specific fields. It explicitly distinguishes from sibling tool openfinance_list_loans by advising use after listing, making the purpose unambiguous.

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

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

The description explicitly says 'Use after openfinance_list_loans to deep-dive on a specific contract', providing clear context. It does not explicitly state when not to use, but the guidance is sufficient.

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

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

Annotations already convey safety (readOnlyHint, idempotentHint). The description adds critical behavioral details: aggregation behavior when omitting `item`, connector-dependent meaning of CREDIT balance, and the presence of a `provider_incident` block indicating unreliable data. 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 thorough and well-structured, front-loading the main function and then detailing usage nuances. However, it is somewhat lengthy; slight trimming of redundant phrases could improve conciseness without losing clarity.

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 specifies returned fields (balance, number, type, subtype, bankData, creditData, bank, connector_id, item_id), explains special cases (name vs bank), and alerts about provider incidents. References a sibling tool for more details, making it self-contained and complete.

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

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

The description explains the `item` parameter very well, including when to include or omit it. The `type` parameter is implied by the return types mentioned, but not directly described as a filter. Given 0% schema coverage, the description partially compensates but could be more explicit about `type` 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 accounts for a bank connection, specifying types (BANK and CREDIT) and key fields. It distinguishes itself from sibling tools like openfinance_list_credit_card_bills by directing users to that tool for standardized bill amounts.

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

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

Excellent guidance: explicitly tells when to omit `item` (to list all banks) versus when to pass it (for a single bank). Warns against misinterpreting CREDIT balance as 'this month's bill' and refers to a specialized tool for the correct data. Advises caution during 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?

The description adds significant behavioral context beyond annotations: it explains caching, the response structure (id, description, descriptionTranslated, parentId, parentDescription), and that it's a single aggregated response. Annotations already indicate readOnlyHint, idempotentHint, and destructiveHint, all consistent.

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?

Four sentences, no wasted words. The main purpose is front-loaded, and each sentence adds value: caching, output fields, and relationship to another tool.

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, rich annotations, and no output schema, the description is complete. It explains the output structure, caching behavior, and how it connects to the update tool. No gaps identified.

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 the baseline is 4. The description does not need to add parameter info but describes the output fields in detail, which indirectly helps the agent understand what the tool returns.

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

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

The description clearly states the tool returns the transaction category taxonomy from Pluggy, specifying the action (returns), resource (category taxonomy), and caching. It distinguishes itself from sibling tools like openfinance_update_transaction_category by noting that the category ids are used by that tool.

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

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

The description implies usage: to retrieve categories for use with update_transaction_category. It mentions caching and that it's a single aggregated response, but does not explicitly state when not to use it or provide alternatives. Given the clear context, it's mostly sufficient.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds value by specifying the exact returned fields and noting an add_connection_url for linking additional banks, providing behavioral context beyond annotations.

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

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

The description is a single sentence that covers the tool's purpose, output, and key elements. It is front-loaded with the core function and contains no superfluous 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 parameters and no output schema, the description provides sufficient context about the return value (fields and add_connection_url). It could mention the purpose of listing connections (e.g., to manage bank links), but it is largely complete for a simple 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?

There are zero parameters, and schema description coverage is 100% (implicitly complete). With no parameters, the baseline is 4, and the description adds no parameter info, which is adequate since none exist.

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 for the install, listing specific fields (connector_id, item_id, bank name, add_connection_url). It uses a specific verb 'Returns' and resource 'saved bank connections', which distinguishes it from sibling list tools that return other entities (e.g., accounts, transactions).

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, when-not-to-use, or name sibling tools that might be more appropriate for specific scenarios. Agents have no basis to choose this tool over others like openfinance_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?

Beyond annotations (readOnlyHint, idempotentHint), the description discloses complex payment semantics, derivation of payment_status, open_bill behavior, connector asymmetry, and bill grouping reliability warnings. It offers extensive behavioral context that prevents misinterpretation, even though annotations already indicate safety.

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 every part serves a clear purpose due to domain complexity. It could be slightly more structured (e.g., bullet points), but it is front-loaded with the core output and progressively adds critical context. Very low redundancy.

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

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

Given the tool's complexity (5 params, no output schema, only basic annotations), the description is remarkably complete. It covers edge cases, derived fields, connector behavior, cross-bank checks, and fallback scenarios. No gaps remain for an agent to misunderstand.

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

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

The input schema has zero description coverage (0%), so the description fully compensates. It explains the required account_id, optional page and page_size, the bulk account_ids parameter, and the include_open_bill parameter with detailed semantics and behavioral effects.

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

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

The description clearly states it returns closed credit card bills for a credit-type account, listing specific fields. It distinguishes from siblings by noting that this tool provides bill-level summaries, not individual transactions, and contrasts with openfinance_list_transactions. The purpose is specific and unambiguous.

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

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

The description provides explicit guidance: when to use openfinance_list_transactions for itemized purchases, warnings against summing transactions by billId, instructions for handling multiple banks, and advice on interpreting payment_status. It also explains the opt-in parameter include_open_bill and cautions when to avoid certain interpretations.

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 valuable behavioral context, such as returning a structured error object (total, results, warning) instead of throwing exceptions when INVESTMENTS is not enabled. No contradictions with annotations.

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

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

The description is a single paragraph that is front-loaded with the main purpose. While it packs a lot of detail, it could be more structured (e.g., separating output details from error handling). Still, every sentence serves a purpose without unnecessary 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?

There is no output schema, so the description compensates by explaining the return structure (total, results, warning) and listing fields like balance, amount, etc. It also addresses error cases. However, it lacks documentation on pagination parameters (page, page_size) and the meaning of 'item' and 'type', leaving gaps for the agent.

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

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

The input schema has 4 parameters (item, page, type, page_size) with 0% description coverage. The tool description does not explain the purpose or allowed values for any parameter (e.g., what 'item' refers to, how pagination works). With low schema coverage, the description should compensate but fails to do so.

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

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

The description clearly states it returns investment portfolio data for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.) and fields. This distinguishes it from siblings like openfinance_list_investment_transactions, which deal with transactions rather than portfolio overview.

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 portfolio data and mentions error handling (returns a warning structure instead of throwing). However, it does not explicitly state when to use this tool versus alternatives like openfinance_list_investment_transactions or other listing tools. No when-not or exclusion criteria are provided.

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 return data (movement types, fields like netAmount, expenses), but does not disclose additional behavioral traits (e.g., authentication, rate limits). Given annotation coverage, a score of 3 is appropriate.

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

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

The description is concise (two short paragraphs) and front-loaded with the core purpose. It uses bullet-style listing for movement types. Slightly more structure could improve readability, but no unnecessary content exists.

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 and no output schema, the description covers the main purpose and usage sequence but omits details on pagination (page, page_size), meaning of parameters, and explicit output structure. It does list key fields, but more detail would enhance 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?

Schema description coverage is 0%, so the description must compensate. It explains that investment_id is required and investment_ids enables bulk, but does not describe page or page_size. No format or constraints are provided for any parameter. This leaves significant gaps for an agent to use the tool correctly.

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, lists movement types (BUY/SELL/TAX/INTEREST/AMORTIZATION/TRANSFER), and names key fields. It distinguishes itself from sibling tools like openfinance_list_investments by stating it should be used after that tool to get the investment_id, and inherently differs from openfinance_list_transactions by being per-investment.

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

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

Explicitly advises to use after openfinance_list_investments to obtain the investment_id. Mentions bulk support with investment_ids. No explicit when-not-to-use or alternatives, but the context is clear for its intended use case.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, indicating safe read behavior. The description adds behavioral details like sequential querying with rate-limit spacing and the return format per connection, which are 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 two sentences: the first states purpose and method, the second covers parameter usage and response format. It is front-loaded and contains no superfluous 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?

The description mentions the return format ({ results, errors }) and sequential behavior. However, without an output schema, it could elaborate on the structure of 'results', but the core information is sufficient for a listing tool.

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

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

The schema has 0% description coverage for the 'items' parameter. The description compensates fully by explaining that the array contains connection selectors (item_id, connector_id, or connector_name) and the effect of providing or omitting it.

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

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

The description clearly states the action ('Lists loan contracts') and the resource ('per bank connection'), and specifies the HTTP method. This differentiates it from sibling tools like list_accounts or list_transactions.

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

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

The description provides explicit guidance on using the 'items' parameter to fetch loans for specific connections, and omitting it to get all. It also mentions rate-limit spacing for multiple connections. However, it does not explicitly state when not to use this tool or suggest 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 are read-only and idempotent. Description adds extensive behavioral context: auto-pagination vs manual, truncation at 5000, error handling, detail levels, per-connector inconsistencies (e.g., sparse billId on Nubank), and upstream incident handling. 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?

Long description but well-structured: starts with purpose, then detailed behaviors, parameter explanations, troubleshooting. Every sentence adds value given the tool's complexity.

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

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

Extremely thorough: covers all parameters, edge cases, error handling, per-connector variations, bulk support, troubleshooting steps for zero results and credit card sync issues. No output schema, but description provides sufficient 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?

Schema has 0% description coverage, but description fully compensates: explains each parameter (date format ISO YYYY-MM-DD, page omission for auto, page_size max 500, detail options with meanings, search_queries case-insensitive OR logic, account_ids for bulk).

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 returns transactions for bank accounts, distinguishes between BANK and CREDIT types, and uniquely positions itself as the only way for credit card itemized transactions. Differentiates from sibling openfinance_list_credit_card_bills.

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

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

Provides explicit when-to-use and when-not-to-use guidance: only way for credit card transactions, when to use alternative for standardized totals, warns against reconstructing totals by billId, explains bulk support, and offers troubleshooting steps for zero results.

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

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

Discloses behavioral traits beyond annotations: caps at 5000/account with truncated flag, provider_incident block when provider issues affect data, and explains granularity/detail modes. No contradiction with annotations (readOnlyHint, idempotentHint, destructiveHint).

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-organized, front-loading the core purpose. Each sentence adds value, though some repetition (e.g., 'entradas e saídas') could be trimmed. Still, it remains clear and actionable.

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 thoroughly explains the return structure: compact summary (totals, por_mes, top_despesas, by_account) and raw rows with detail options. Also covers truncation and provider_incident. For 7 parameters and no schema, it is largely 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 schema description coverage at 0%, the description carries full burden. It explains all 7 parameters: item (target or omit), from/to (ISO dates), granularity (monthly/raw), detail (compact/rich/raw), top_n (implied in top expenses), type (BANK/CREDIT). Missing explicit syntax for top_n, but context suffices.

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 performs consolidated cash-flow analysis for a bank connection over a period in one call, resolving accounts internally. It clearly distinguishes from siblings like openfinance_list_accounts (no need to call first) and openfinance_list_transactions (more granular).

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

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

Provides clear use cases ('fluxo de caixa', 'maiores gastos') and explains when to omit 'item' for all banks. Mentions when to use granularity='raw' for itemized rows. However, it does not explicitly state when NOT to use this tool, though alternatives are 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 declare readOnlyHint=true and idempotentHint=true. Description adds context: it checks a public status page (non-destructive, external call), returns specific fields (global indicator, degraded components, incidents, affected banks), and explains how it helps diagnose outages. 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 well-structured and front-loaded with the core purpose. Each sentence adds value: purpose, usage guidance, and output details. No unnecessary words despite 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?

With no parameters and no output schema, the description fully explains the tool's purpose, behavior, return fields, and use case. Complete information 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?

No parameters exist; schema coverage is 100% (empty). Description does not need to add parameter info. Baseline 4 is appropriate.

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

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

Description clearly states the tool checks the LIVE operational status of the Open Finance provider, distinguishing it from the user's own connection status via explicit mention of sibling tool 'openfinance_get_item_status'. The verb 'checks' and resource 'provider status' 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?

Explicitly describes when to use: when data looks incomplete or stale despite an updated connection. Contrasts with connection-level status, guiding the agent to differentiate provider-side problems from connection issues.

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

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

Annotations already mark as read-only and idempotent. Description adds critical behaviors: keyword requirement (returns hint if missing), caveats for non-Open-Finance connectors (manual reconnection), and plan filtering. Adds substantial 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?

Every sentence adds value, though slightly long. Front-loaded with main purpose and key instructions. Minor redundancy 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?

Given no output schema, description comprehensively covers return fields (connector id, access, audience, linked connections/accounts, connect_url, caveat). Also explains plan filtering and keyword requirement, leaving no major gaps.

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

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

Schema has 0% description coverage. Description fully explains both parameters: keywords as array of strings with examples, include_accounts for including account details. Adds 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?

Clear verb 'searches' and specific resource 'bank connectors' with well-defined output fields (connector id, access, audience, connect_url). Distinguishes from sibling tools like openfinance_list_connections or 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?

Explicitly states 'Call this BEFORE connecting' and notes plan-dependent visibility (PF plan hides PJ banks). Does not explicitly list when not to use or compare with alternatives, but provides sufficient context.

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

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

Annotations are minimal (no readOnly, destructive hints). The description goes beyond them by revealing that recategorizing creates a Category Rule, affecting future categorization, and describing batch error handling. This provides essential 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 front-loaded with the core action and progressively details side effects, input sources, and output format. Every sentence adds value, and the information is well-organized for quick comprehension.

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

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

Given no output schema, the description fully specifies the return shape (`updated`, `results`, `errors`). It also covers error handling (per-item errors don't fail batch) and side effects (rule creation). This makes the tool's behavior complete and predictable.

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 bears the full load. It explains the `items` array structure, required fields (`transaction_id`, `category_id`), and the source of each ID from sibling tools. This adds significant meaning beyond the schema.

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

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

The description clearly states the verb 'corrects' and the resource 'category of transactions', and includes the HTTP method PATCH. It distinguishes from sibling tools like listing or syncing by focusing on category correction and future learning.

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

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

The description explains when to use the tool ('to fix miscategorized transactions') and where to obtain required IDs from related tools. It does not explicitly state when not to use it or provide alternatives, but the context is sufficient for appropriate 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?

Annotations indicate idempotentHint true and destructiveHint false, so the description adds value by specifying the need for recent messages for reproduction. However, it does not disclose privacy implications or whether the report is stored.

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-loading the purpose and providing a key instruction. Every word earns its place.

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

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

The description covers the basic use case but omits expected outcomes (e.g., confirmation) and detailed parameter semantics. Given the tool's simplicity, it is minimally 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?

With 0% schema description coverage, the description should explain each parameter. It only mentions the conversation array and lacks guidance on the required 'message' and optional 'context' 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, which distinguishes it from sibling tools focused on financial operations. However, it does not specify what happens after submission (e.g., ticket generation).

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 advises including the conversation array for reproduction, which provides clear context for when to use the tool. No exclusions or alternative tools are mentioned, but the sibling list shows no overlap.

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 no behavioral context beyond what annotations provide, such as output format or side effects.

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, front-loaded sentence with zero wasted words. It is exactly as concise as needed for this trivial tool.

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, no-output-schema tool, the description is complete enough. It covers the fundamental purpose, though it could hint at return format for full clarity.

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 coverage is 100%, so the description does not need to add parameter details. Baseline score of 3 is appropriate as it adds no extra semantic value.

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 MCP platform and adapter versions, using a specific verb and resource. Even though there is a sibling 'toolkit_info', the scope is distinct and immediately understood.

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

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

No explicit when-to-use or alternatives are provided, but the tool is self-evident as a version checker. The absence of guidance is acceptable given its simplicity, but it does not differentiate from similar information tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable context about what the returned state contains (installed MCPs, connection status, catalog count), which goes beyond the annotations without contradicting 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?

Single sentence that fronts the purpose ('Returns the current toolkit state:') followed by concise enumeration of returned data. No wasted words, easy to parse.

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

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

Given zero parameters, no output schema, and simple nature of the tool (state introspection), the description covers all essential information: what the tool does and what it returns. No gaps for an agent to make errors.

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?

Tool has zero parameters, so baseline is 4. Description does not need to add parameter meaning. It correctly omits any parameter details since none exist.

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 'toolkit state' and lists three specific pieces: installed MCPs, connection status, and catalog tool count. This verb+resource+scope distinguishes it from siblings that perform actions on finance data or authentication.

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

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

The description implies usage for checking toolkit state, but provides no explicit when/when-not guidance or alternatives. No exclusions mentioned. Context makes it clear this is for introspection, but lacks explicit guidance.

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