Bradesco MCP

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

Annotations already indicate idempotentHint=true and non-destructive. Description adds that calling with no args returns a login link, while token arg logs in. 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?

Four sentences conveying necessary info; could be slightly more concise but no extraneous 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?

Covers both usage modes (permanent config and session token) and correctly describes behavior. No output schema needed; return values are implied (success or link). Complete for its purpose.

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

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

Schema coverage is 0%, but description partially compensates by stating token is a JWT string. However, it does not detail constraints (e.g., format, length) or that it's optional.

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's purpose: handling authentication via access token or login link. It distinguishes from siblings which are unrelated (e.g., connect, marketplace).

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 context: best to add token to config for permanent connection, or paste for session. Mentions calling with no args to get link. Lacks explicit 'when not to use' but is 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 (readOnlyHint, idempotentHint, destructiveHint) indicate safe, read-only behavior. Description adds detail on response structure (authenticated, pending, connect_url) 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, front-loaded with main purpose. No extraneous information.

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

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

For a simple status-checking tool with no parameters and no output schema, the description sufficiently covers expected response 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?

No parameters in input schema, and schema coverage is 100%. Description adds no parameter info, which is fine since none exist. Baseline score of 3 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?

The description clearly states the tool returns connection status and URLs, and distinguishes between different states (all providers connected vs missing credentials). This differentiates it from sibling tools like 'authenticate'.

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

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

The description explains when to expect 'authenticated:true' vs when to use connection URLs, providing context for when to invoke. It could explicitly mention when not to use, 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, etc.), the description discloses key runtime behaviors: invoke executes one-off even when the MCP is not installed, returns connect links for missing credentials, returns checkout/top-up links for empty wallets, and notes that writes require workspace owner/admin. It also explains the prompt library's purpose distinctly from MCP operations. No contradiction with annotations.

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

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

The description is a single dense paragraph but is front-loaded with the core identity and flow. Every sentence adds meaningful detail, and the content is organized logically from core flow to key invoke behavior to prompt library. It could be more scannable with bullet points, but for the complexity covered, it is appropriately sized and not 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?

Given 23 parameters and no output schema, the description is remarkably complete. It covers all action categories (search, describe, install, invoke, prompts, billing, bug reporting), explains credential and payment edge cases, distinguishes permanent vs one-off installation, and describes expected return behavior (connect links, checkout links, shareable prompt URLs). It leaves little ambiguity for an agent to select the right action and parameters.

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

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

Schema description coverage is 0%, so the description carries the full burden. It adds semantic meaning to central parameters like action (search, describe, invoke, install, list_tools, etc.), mcp_id, tool_id, arguments, and prompt-related fields (prompt_vars, prompt_slug, publish_prompt). However, some parameters (e.g., limit, immediate, tier_slug, cancel_reason) are not explicitly explained, leaving minor gaps despite strong overall compensation.

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

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

The description opens with a precise verb+resource statement: 'The official mcp.ai marketplace — the in-platform catalog of every MCP/tool, AND the way to run them.' It clearly enumerates the core flow (search → describe → invoke) and lists specific action categories, making it unmistakable what this tool does and how it differs from sibling tools focused on openfinance 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 gives explicit when-to-use guidance: 'Use install only to make an MCP PERMANENT in the active toolkit... prefer invoke for a single/occasional use.' It also names alternatives for specific needs: 'report_bug sends feedback; request_mcp asks us to build a NEW MCP when nothing fits.' This is model guidance for tool 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 already set destructiveHint=true, and the description confirms destructive behavior, adding that consent is revoked and data is deleted. It also mentions the return of an add_connection_url for reconnection. This provides context beyond annotations without contradiction.

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

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

The description is two sentences long, no unnecessary words. Each sentence adds value: first defines the action, second describes the outcome. Front-loaded with the core function.

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

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

Given the simplicity of the tool (one param, no output schema), the description covers the purpose and return value. However, it lacks parameter clarification and could mention that the data is permanently deleted (irreversible), which would help completeness.

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

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

With 0% schema description coverage, the description fails to explain the sole required parameter 'item'. It only states 'for a specific bank' but does not clarify what value should be passed (e.g., bank ID, connection ID). This is a critical 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 action: 'Revokes the Open Finance consent for a specific bank and deletes the connection data.' It uses specific verbs ('revokes', 'deletes') and identifies the resource ('bank connection data'), distinguishing it from sibling tools like 'connect' or 'list_connections'.

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

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

The description implies usage when needing to disconnect a bank, but it does not provide explicit guidance on when to use versus alternatives (e.g., not for temporary pauses, not for troubleshooting). It lacks exclusions or mention of prerequisites.

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

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

Annotations show readOnlyHint=false (mutation) and destructiveHint=false. Description adds extensive behavioral details: it waits up to ~60s, polls, returns results with specific fields like status, executionStatus, lastUpdatedAt, synced, needs_action, reconnect_url, and timed_out. 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 relatively long but well-structured, starting with the main action and then explaining details in separate sentences. Each sentence adds value, though some information (e.g., the reconnect_url section) could be slightly condensed 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?

No output schema, but description thoroughly explains return object (results, errors, fields), handles error conditions (timed_out, needs_action), and provides reconnection guidance. Given the tool's complexity and two parameters, the description covers all necessary context for correct usage.

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

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

Schema coverage is 0%, so description must explain parameters. It covers both parameters: 'items' as an array of selectors (with example types) and that omitting it syncs all connections; 'wait' as boolean with implied default (true) and explains behavior for false. Adds meaning beyond schema, but could explicitly state default for wait.

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 forces a bank to re-sync connections and waits for completion. Uses specific verb 'forces' and resource 'connections'. Distinguishes from siblings by mentioning it pulls fresh data without disconnecting/reconnecting, and specifies the use case (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?

Explicitly says when to use (stale data) and when to set wait: false (fire-and-forget). Also mentions alternative action for timed_out (re-check with openfinance_get_item_status) and explains the needs_action scenario. Lacks explicit when-not-to-use or comparison to other sibling tools, but still provides strong 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 declare readOnlyHint=true and destructiveHint=false, confirming safe reads. The description adds valuable behavioral details beyond annotations: explains warning vs. error behavior, degradation to last-synced balance with `realtime: false`, and structured response shape. 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 front-loaded with the main purpose and API path, then proceeds to parameter constraints and edge cases. It is slightly lengthy but each sentence adds value (warning behavior, degradation, response shape). Could be trimmed slightly, but remains clear and efficient.

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

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

Given no output schema, the description fully explains the response shape (`{ results: [...], errors: [...] }`) and all relevant error/degradation modes. It covers real-time vs. last-synced balance, warning vs. error, and success/error structure. No gaps for the intended use case.

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

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

Schema coverage is 0% and the schema only defines required string array. The description mentions account_ids is an array of 1–50 items, which adds minimal semantic value but does not describe format, examples, or optional parameters. With zero schema coverage, the description must compensate more.

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' via a specific endpoint (GET /accounts/:id/balance). It distinguishes from sibling tools like openfinance_list_accounts (which lists accounts) and openfinance_get_accounts_detail (which provides details), making its 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 specifies that account_ids must be an array of 1–50 items, and it explains error conditions (CREDIT accounts may return BALANCE_FETCH_ERROR, temporary upstream unavailability degrades to last-synced balance). While it doesn't explicitly compare to siblings, the context makes it clear when to use this balance-specific tool.

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

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

Annotations already indicate a safe, read-only operation. The description adds critical context about the provider_incident block and warns against presenting unreliable data, which goes 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?

Three sentences, front-loaded with purpose, every sentence adds distinct value without redundancy.

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

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

Despite no output schema, the description covers batch shape, provider_incident warning, and lists included data types, providing sufficient completeness 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 has 0% description coverage, but the description adds cardinality (1-50 array), batch shape, and provider_incident context, significantly aiding parameter understanding.

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

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

The description clearly states it returns full account objects with extended creditData per ID, and distinguishes itself from sibling tools like list_accounts by specifying it retrieves details 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?

While it implies use when needing details for specific account IDs, it does not explicitly contrast with alternatives like get_account_balance for balance-only queries, 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?

Annotations declare readOnlyHint, idempotentHint, and destructiveHint. The description adds critical context: batch shape {results, errors}, absence of paid/status field in Pluggy, and nuanced explanation that payments[] typically refers to previous bill. This goes well 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 fairly long but each sentence provides value, with clear structure: return fields, exclusions, usage guidance, and nuances. It could be trimmed slightly but remains effective.

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

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

Given no output schema, the description thoroughly explains return structure, field meanings, missing status, payment nuances, and connector-specific caveats (Nubank). It handles edge cases and complexity well.

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

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

The input schema has one parameter (bill_ids, array of strings) with 0% schema description coverage. The description explains 'Pass bill_ids as an array' and mentions batch shape, adding meaning beyond the raw schema. However, it could give more detail about array element 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 it returns bill-level detail for credit card bills by ID, listing specific fields (financeCharges, payments). It distinguishes from getting individual transactions, 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 provides explicit guidance: when to use (bill details), what NOT to do (do not reconstruct bill total from transactions), and directs to use openfinance_list_credit_card_bills first to discover IDs and openfinance_list_transactions for transactions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, indicating a safe read operation. The description adds valuable context: the reconnect_url reopens the widget in UPDATE mode without disconnecting or consuming a connection slot. This goes beyond annotations and reveals important behavioral nuances. No contradictions found.

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 conveys essential information without excessive verbosity. However, it could be better structured (e.g., bullet points for status list or parameter usage) to improve scanability. The information is front-loaded with the core function, which is good.

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 lack of output schema, the description does a fair job of explaining return values (e.g., `{ count, items }` for bulk) and lists possible statuses. It covers parameter behavior and edge cases (omitting item). A minor gap is the lack of explanation for the single-item return structure. Overall, it's quite complete for a read-only, well-annotated tool.

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

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

With 0% schema description coverage, the description must explain parameters. It effectively explains `item` (single) and `item_ids` (bulk), but does not mention `item_id` at all. This omission is a minor gap, but overall the description adds significant meaning beyond the raw schema, which only defines types and no 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 that the tool returns the current status of a bank connection, listing specific status values like UPDATED, UPDATING, LOGIN_ERROR. It distinguishes between fetching all connections or a single one, and mentions additional metadata and reconnect_url. This specificity sets it apart from sibling tools like openfinance_list_connections or openfinance_provider_status, which serve different purposes.

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

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

The description provides clear usage patterns: omit `item` for all connections, pass `item` for a single bank, and use `item_ids` for bulk support. However, it does not explicitly state when NOT to use this tool or contrast it with alternatives (e.g., when to use openfinance_list_connections instead). This minor omission prevents a perfect score.

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, idempotentHint=true. Description adds batch shape {} and array size limit, which is useful 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?

Single sentence is dense but efficiently packs the main action and field list. Could be slightly more structured, but remains clear.

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

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

Covers return fields, batch behavior, usage hint, and parameter constraint. No output schema exists, but description provides sufficient context for a simple tool.

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

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

Schema has 0% description coverage, but description adds meaning by stating 'Pass loan_ids as an array (1-50)', clarifying the parameter's range and batch nature.

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 detail by ID, listing many fields, and distinguishes from sibling openfinance_list_loans by advising to use it after listing for deep-diving.

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

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

Explicitly says to use after openfinance_list_loans, and provides batch size range (1-50). Does not explicitly state when not to use, but context is clear.

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

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

Annotations declare readOnlyHint, idempotentHint, destructiveHint. Description adds valuable context: provider_incident block for unreliable data and identity_notice for deduplication. No contradictions, but could mention rate limits.

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?

Front-loaded with main purpose, then detailed notes and edge cases. Somewhat lengthy but each sentence adds necessary context. Slight redundancy (mentions 'bank' field twice).

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

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

Covers return fields, behavior with and without 'item', special blocks (provider_incident, identity_notice), and references sibling tool for credit card bills. No output schema, but description provides sufficient context for usage.

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

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

Schema coverage is 0%, so description must compensate. It explains 'item', 'type', and 'item_ids' but does not explicitly describe 'item_id'. The mapping to parameter names is implicit, leaving some ambiguity.

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

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

The description clearly states it returns accounts for a bank connection, specifying types (BANK/CREDIT) and key fields. It distinguishes from sibling tools like openfinance_list_credit_card_bills by directing usage for standardized billing 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?

Explicit guidance on when to omit 'item' for all banks vs. passing it for a single bank, and when to use openfinance_list_credit_card_bills instead. Also warns not to treat 'balance' as this month's bill.

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 description adds valuable context: it reveals caching behavior (per session) and details the returned data fields. 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 efficient sentences front-load the main purpose and pack essential details (caching, response structure, field meanings) without redundancy. 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?

Even without an output schema, the description fully explains the response format and key fields. It also addresses caching and confirms it's a single aggregated response, making it complete for a zero-parameter query.

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 coverage is 100%. The description correctly notes it takes no inputs, which is sufficient. Baseline for 0 parameters is 4.

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

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

The description explicitly states it returns Pluggy's transaction category taxonomy, cached per session. It clearly distinguishes from sibling tools by noting it's a single aggregated response with no batch ids, and details the entry structure (id, description, translations, parent fields).

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 makes it clear when to use this tool (to obtain category taxonomy, especially for mapping category IDs to descriptions or using Portuguese translations). It provides context but does not explicitly list when not to use it or alternatives; however, the purpose is well-defined.

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 behavioral details beyond annotations: it explains that reconnect_url opens the widget in UPDATE mode, does not consume a connection slot, and does not require disconnecting first. 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, no fluff. The first sentence lists the returned fields, the second explains the crucial reconnect_url behavior. 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?

For a parameter-free list tool with no output schema, the description fully covers the purpose, return fields, and key behavioral nuance (reconnect_url semantics). The agent can confidently invoke the tool.

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

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

The tool has 0 parameters, so schema coverage is 100%. The description does not need to add parameter semantics. 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?

The description clearly states the tool returns saved bank connections with specific fields (connector_id, item_id, bank name, reconnect_url, add_connection_url). It distinguishes the tool's purpose 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 explains when to use the tool (to get connection details and reconnect_url for re-authentication) but does not explicitly mention when not to use it or point to alternative tools. However, 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?

Beyond annotations (readOnlyHint, idempotentHint), the description details payment status derivation, connector asymmetry, open bill availability conditions, and warnings. Full disclosure of edge cases and limits.

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 lengthy, every sentence adds necessary complexity (Brazilian semantics, payment logic, connector notes). Well-structured: starts with core purpose, then nuances, then opt-in details. Justified for domain complexity.

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

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

Covers all aspects: return fields, derived payment_status, open bill projections, connector asymmetry, pagination, bulk support, and error handling (warning). No output schema needed; description suffices for correct agent invocation.

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

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

Given 0% schema coverage, the description thoroughly explains account_id, include_open_bill, and account_ids. Pagination parameters (page, page_size) are implied but not detailed; still sufficient for correct usage.

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

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

The description explicitly states the tool returns CLOSED credit card bills for a CREDIT-type account, listing specific fields. It distinguishes from sibling tools like openfinance_list_transactions and openfinance_get_credit_card_bill, eliminating ambiguity.

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 when-to-use (getting closed bills) and when-not-to (to see individual transactions, use openfinance_list_transactions). Explains opt-in open_bill parameter and connector asymmetry, guiding appropriate invocation.

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 the tool as non-destructive and idempotent. The description adds critical behavioral context: error handling returns a warning instead of throwing, and a detailed data integrity mechanism for mass zeroing positions. This goes well 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 front-loaded with the main purpose and structured logically: purpose, asset list, error handling, data integrity, bulk support. It is comprehensive but slightly verbose; a more concise version could omit redundancy.

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

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

The description covers purpose, error handling, and data integrity, but lacks details on pagination (despite page/page_size parameters) and output field descriptions. Given no output schema, more completeness would be beneficial.

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%, and the description only mentions the item_ids parameter for bulk support. The other parameters (item, page, type, page_size) are not described, forcing the agent to infer meaning from names alone. This is insufficient for 6 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 returns investment portfolio for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.). This specific verb-resource combination distinguishes it from sibling tools that handle transactions or account balances.

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 contrast with sibling tools like openfinance_list_investment_transactions. No guidance on when not to use it is 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 indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds value by listing the exact fields returned (e.g., quantity, value, netAmount, expenses) and transaction types (BUY/SELL/TAX/etc.). It also mentions bulk support. No contradiction with annotations. It does not disclose pagination behavior despite page/page_size parameters.

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 concise sentences with a separate line for bulk support. It front-loads the purpose and lists important details. No redundant information. Could be slightly more structured (e.g., separate sections), but it is efficient and effective.

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

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

Given no output schema, the description provides good detail on return fields and transaction types. It also gives a prerequisite. However, it lacks information on pagination behavior, limits, sorting, or error conditions. As a list tool, these are important for 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 the purpose of investment_id (implicitly via usage) and investment_ids (bulk support). However, it does not explain page and page_size parameters. The description adds some meaning for the non-pagination parameters, but not fully compensating for the coverage 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 it returns movement history for a specific investment position, listing transaction types and fields. It explicitly distinguishes from 'openfinance_list_investments' by saying 'Use after openfinance_list_investments to get the investment_id.' The verb 'Returns' and resource 'movement history for a specific investment position' are specific and differentiate it from siblings like 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 gives a clear usage sequence: 'Use after openfinance_list_investments to get the investment_id.' It also mentions bulk support via 'investment_ids' for batched execution, providing context on when to use this tool. However, it does not explicitly state when not to use it or compare with other list tools like openfinance_list_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 readOnly, idempotent, non-destructive. Description adds details about sequential execution, rate-limit spacing, and result structure ({ results, errors } per connection).

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: purpose, parameter usage, return format. Efficient, no fluff, front-loaded with key information.

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

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

For a simple tool with one optional parameter and no output schema, description covers everything: purpose, parameter semantics, behavior, and return structure. No gaps.

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

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

Schema only shows `items` as array of strings with 0% coverage. Description fully compensates by explaining that entries can be item_id uuid, connector_id, or connector_name, and clarifies behavior when omitted.

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 lists loan contracts per bank connection with specific API endpoint. Distinguishes from sibling tools like openfinance_get_loan_detail which gets 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?

Explains when to pass `items` (specific connections) and when to omit (all linked banks). Mentions sequential querying with rate-limit spacing, but doesn't explicitly contrast with 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?

Discloses many behaviors: auto vs manual pagination, search semantics (case-insensitive, OR, 5000 ceiling), error handling (returns {total:0,...} on error), detail modes, provider incidents, account echo, and need to check connection health. All this adds 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?

The description is long but well-structured with distinct sections (credit card specifics, pagination, detail modes). Every sentence provides value, though it could be slightly more concise. Front-loaded 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 (8 parameters, no output schema, many siblings), the description covers all necessary aspects: edge cases, error handling, provider incidents, bulk support, and cross-references to other tools. 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 compensates fully by explaining each parameter: account_id, from/to (ISO format), page, page_size, detail (enum meanings), search_queries (substring match, OR), account_ids (bulk). Adds meaning beyond schema.

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

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

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

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

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

Explicitly tells when to use this tool (for credit card itemized transactions) and when to use alternatives (openfinance_list_credit_card_bills for standardized totals). Also provides guidance on pagination modes and search behavior.

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

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

Beyond annotations (readOnlyHint, idempotentHint), description reveals important behaviors: transaction cap at 5000/account with truncated flag, and provider_incident block during outages that may yield incomplete 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 but slightly verbose; however, it is well-structured with front-loaded purpose, then parameter details, then usage examples and caveats. Every sentence adds value, but could be more concise.

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

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

For a complex tool with 9 parameters, no output schema, and no required parameters, the description covers output characteristics (compact summary fields, truncated flag, provider_incident) and bulk support comprehensively. Minimal gaps remain.

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 explains most parameters (item accepts connector_id/connector_name/item_id, from/to ISO dates, granularity and detail options, type filter, item_ids for bulk). However, top_n and the distinction between item and item_id are not fully clarified, leaving some gaps.

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

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

The description clearly states it performs consolidated cash-flow analysis for a bank connection in one call, resolving accounts internally. It distinguishes itself from siblings like openfinance_list_transactions and openfinance_list_accounts by eliminating the need to call them 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?

Explicitly tells when to use (e.g., 'análise anual/mensal', 'fluxo de caixa'), when to omit item for all banks, when to use granularity 'raw' vs 'monthly', and detail options. Also warns about provider incidents affecting data completeness.

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 valuable context: it returns global indicator, degraded components, open incidents, and flags affecting connected banks. No contradictions, and the description enriches 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 three sentences, front-loaded with the primary purpose, and each sentence adds necessary information without redundancy. It is concise and 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?

Despite having no parameters and no output schema, the description thoroughly explains the tool's purpose, when to use it, what it returns, and how to interpret results for connected banks. It is complete for effective agent invocation.

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

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

The tool has zero parameters with 100% schema coverage, so the baseline is 4. The description does not need to add parameter details, as there are none. It appropriately focuses on behavior and use cases.

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

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

The description clearly states the tool checks the LIVE operational status of the Open Finance provider, distinguishing it from the sibling 'openfinance_get_item_status' which checks the user's own connection. The verb 'Checks' and resource 'provider status' are 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 explicitly states when to use this tool: whenever data looks incomplete or stale despite a connection showing UPDATED, with specific scenarios like missing accounts/transactions or a bank not returning everything. It contrasts with the alternative sibling tool, providing clear 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, it describes the ready connect_url, plan filtering, caveat for non-Open-Finance connectors, and that it never dumps catalog without keywords. 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?

Front-loaded with purpose and comprehensive, but slightly dense. Could be broken into shorter sentences, but 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?

Despite no output schema, the description details all return fields, plan behavior, caveats, and usage context. It is fully informative 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?

With 0% schema coverage, the description fully explains both 'keywords' (array, required, example) and 'include_accounts' (boolean effect). This compensates completely.

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

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

The description clearly states it searches bank connectors by name and enumerates return fields. It distinguishes itself from sibling tools by advising to call this before connecting.

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

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

Explicitly says to call before connecting, explains plan behavior, warns about credential caveats, and instructs that keywords are required to avoid dumping catalog.

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 thoroughly discloses a critical behavioral trait: recategorizing automatically creates a Category Rule, affecting future similar transactions. It also describes the batch error behavior in detail, which goes well beyond the minimal annotations.

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

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

The description is well-structured with logical flow: action, parameter, side effect, output shape. It is slightly long but every sentence adds value; could be trimmed slightly without losing meaning.

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

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

Given only one parameter and no output schema, the description covers all necessary aspects: input format, side effects, output structure, and error handling. No information gaps remain for effective 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?

With zero schema coverage, the description fully compensates by explaining the `items` parameter structure, including that `transaction_id` comes from openfinance_list_transactions and `category_id` from openfinance_list_categories, adding crucial context missing from the schema.

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

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

The description clearly states it 'Corrects the category of one or more transactions' using a specific HTTP method (PATCH). It distinguishes itself from sibling tools by referencing openfinance_list_transactions and openfinance_list_categories as data sources.

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 improve categorization accuracy going forward.' It implicitly advises against using it when no category correction is needed, though no explicit alternatives 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 indicate idempotentHint true and no destructiveness, aligning with the description. However, the description adds little beyond stating the purpose, missing details like whether it creates a ticket or logs data.

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

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

Two sentences with no waste, front-loaded with purpose, and each 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?

Simple tool with no output schema, but parameters are under-described. The description is adequate for a basic feedback tool but could elaborate on what happens after reporting.

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

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

Schema coverage is 0%, and the description only mentions the conversation parameter, ignoring context and message. The required message parameter lacks any explanation of its content or 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 reports bugs, missing features, or feedback, which is specific and distinguishes it from sibling tools focused on openfinance 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?

It advises including the conversation array for reproduction, giving context for use. While not specifying when not to use it, the purpose is clear enough to guide 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 context that the tool shows platform and adapter versions, which complements the annotations (readOnlyHint, idempotentHint, destructiveHint). No contradictions; behavior is fully transparent.

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 with 8 words, perfectly concise and front-loaded. Every word adds value.

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

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

The tool is simple (no params, no output schema). The description and annotations together provide complete context for an agent to use this 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?

Tool has zero parameters so schema coverage is 100%. No parameter info is needed in the description. 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?

The description clearly states the tool shows current MCP platform and adapter versions. It has a specific verb ('Show') and resource ('versions'), and among siblings it is unique as a version information 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 using this tool to get version information. Although no explicit when-not-to-use or alternatives are given, the context is clear enough for such a simple tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds what the state includes but no further behavioral context (e.g., rate limits, auth needs).

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 (19 words) with no wasted words. Directly states purpose and output without redundancy.

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

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

For a no-parameter, read-only tool with good annotations, description adequately covers what the tool returns. Lacks format details but not essential for this simple case.

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%. Description has no need to explain parameter semantics, earning baseline 4.

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

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

Description specifies verb 'returns', resource 'current toolkit state', and enumerates included details (installed MCPs, connection status, catalog tool count). Differentiates from sibling tools like openfinance_* and 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?

No explicit when-to-use or when-not-to-use guidance. Context implies it is for checking system state, but no mention of alternatives or prerequisites.

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